Source Code
Overview
ETH Balance
0 ETH
More Info
ContractCreator
Multichain Info
N/A
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
Pool
Compiler Version
v0.8.21+commit.d9974bed
Optimization Enabled:
Yes with 200 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Params, Constants, Validator, Controller as ORController, OpenRewards as ORData, OpenRewardsProvider as provider, Positions} from "../../providers/deployables/a-pool.sol"; import "../standards/enumerable.sol"; import {Eunice as Helper} from "../../providers/common/eunice.sol"; contract Pool is ORController, NonFungibleAndEnumerable { constructor( address reward, address meToken, Params.ConfigForTypeAOpenRewards memory config ) NonFungible(Constants.ME_PROTOCOL, Constants.ME_P) { provider.setUpOpenRewards(reward, meToken, config); } function initialize( address reward, address meToken, Params.ConfigForTypeAOpenRewards memory config ) external returns (bool) { return provider.setUpOpenRewards(reward, meToken, config); } function startOpenRewards() external returns (uint256 optimalRatioInPrecision) { optimalRatioInPrecision = provider.startOpenRewards(); } function pauseOpenRewards() external returns (bool) { return provider.pauseOpenRewards(); } function resumeOpenRewards() external returns (bool) { return provider.resumeOpenRewards(); } function recordLiquidityProvided( Params.LiquidityInfo memory info ) external returns (uint256 position) { (uint256 inputPosition, uint256 potentialPosition) = provider .recordLiquidityProvided(info); if (Validator.isZero(inputPosition)) _mint(info.to, potentialPosition); position = potentialPosition; } function recordMeTokensProvidedByProtocolTeam( uint256 amount ) external returns (uint256 recordedAmount) { recordedAmount = provider.recordMeTokensProvidedByProtocolTeam(amount); } function withdrawLiquidity( Params.LiquidityInfo memory info ) external returns (uint256 rewardAmount, uint256 meAmount) { (rewardAmount, meAmount) = provider.withdrawLiquidity(info); } function releaseMeTokensProvidedByProtocolTeam( uint256 amount, address to, bytes32 releaseType ) external returns (uint256 rewardAmount, uint256 meAmount) { (rewardAmount, meAmount) = provider .releaseMeTokensProvidedByProtocolTeam(amount, to, releaseType); } function addOpenRewardsManager(address account) external returns (bool) { return provider.addOpenRewardsManager(account); } function addLiquidityManager(address account) external returns (bool) { return provider.addLiquidityManager(account); } function removeOpenRewardsManager(address account) external returns (bool) { return provider.removeOpenRewardsManager(account); } function removeLiquidityManager(address account) external returns (bool) { return provider.removeLiquidityManager(account); } function getLiquidityRatios() external view returns (uint256 rOptimalInPrecision, uint256 rlastInPrecision) { (rOptimalInPrecision, rlastInPrecision) = provider.getLiquidityRatios(); } function getOpenRewardsState() external pure returns (ORData.State memory state) { state = ORData.getState(); } function setBusy() external returns (bool) { return ORData.setBusy(); } function getOpenRewardsConfigurations() external pure returns (ORData.Config memory config) { config = ORData.getConfig(); } function setUpConfig( Params.ConfigForTypeAOpenRewards memory _config ) external returns (bool) { return ORData.setUpConfig(_config); } function getLiquidityIds() external view returns (address initiator, address reward, address meToken) { (initiator, reward, meToken) = ORData.getLiqudityIds(); } function initiateOutgoingConversation( Params.OutgoingConversationInfo memory info ) external returns (Params.InitiateConversationReturnType memory conversionDigest) { conversionDigest = provider.initiateOutgoingConversation(info); } function engageIncomingConversation( uint256 _outputRewardAmount, address to ) external returns (uint256 outputRewardAmount) { outputRewardAmount = provider.engageIncomingConversation( _outputRewardAmount, to ); } function changeConfigExceptOptimalRatio( Params.EditableConfigForTypeAOpenRewards memory editableConfig, bool ignoreDefault ) external returns (bool) { return provider.changeOpenRewardsConfigExceptROptimal( editableConfig, ignoreDefault ); } function changeOptimalRatio( uint256 newOptimalRatio ) external returns (bool) { return provider.changeROptimal(newOptimalRatio); } function getLiquidityPositionByIndex( uint256 index, address account ) external view returns (uint256 position) { position = provider.getPositionByIndex(index, account); } function getAllLiquidityPositionForAccount( address account ) external view returns (uint256[] memory positions) { positions = provider.getAllPositions(account); } function getOptimalRatio() external view returns (uint256 r) { r = ORData.getOptimalRatio(); } function leverageOutgoingConversationInsight( uint256 meAmount, uint256 slippageInPrecision ) external view returns (uint256 rewardAmount) { return provider.leverageOutgoingConversationInsight( meAmount, slippageInPrecision ); } function leverageIncomingConversationInsight( uint256 rewardAmount ) external view returns (uint256, uint256) { return provider.leverageIncomingConversationInsight(rewardAmount); } function getOutgoingConversationInsight( uint256 meAmount, uint256 slippageInPrecision ) external view returns (uint256 rewardAmount, uint256 lastRewardAmount) { return provider.getOutgoingConversationInsight( meAmount, slippageInPrecision ); } function getIncomingConversationInsight( uint256 rewardAmount ) external view returns (uint256 optimalMeAmount, uint256 lastRewardAmount) { return provider.getIncomingConversationInsight(rewardAmount); } function getPositionData( uint256 _positionId ) external view returns (Positions.PositionMetadata memory data) { return provider.getPositionData(_positionId); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Context} from "../common/context.sol"; import {OpenRewardsData as OpenRewards, Positions, Params, Errors, Constants} from "../data/a-pool.sol"; import {RoleGuard as Guard, Validator, Roles as SEEDS} from "../common/roleguard.sol"; import {Eunice as Helper, Fungible} from "../common/eunice.sol"; import {OpenRewardsController as Controller, NonFungible} from "../../controllers/deployables/a-pool.controller.sol"; import {OpenRewardsLogs as Logs} from "../logs/a-pool.sol"; library OpenRewardsProvider { function setUpOpenRewards( address reward, address meToken, Params.ConfigForTypeAOpenRewards memory _config ) internal returns (bool) { { Validator.ensureAddressIsNotZeroAddress(reward); Validator.ensureAddressIsNotZeroAddress(meToken); } OpenRewards.State storage state = OpenRewards.writableState(); if (state.initialized) { revert Errors.OPEN_REWARDS_ALREADY_INITIALIZED(); } address initiator = Context.sender(); state.initiator = initiator; state.reward = reward; state.meToken = meToken; state.lastTransactionTime = uint40(Context.timestamp()); OpenRewards.setUpConfig(_config); address openRewardsId = address(this); bytes32[] memory seeds = new bytes32[](3); seeds[0] = SEEDS.OPEN_REWARDS_MANAGER; seeds[1] = SEEDS.LIQUIDITY_MANAGER; seeds[2] = SEEDS.PROTOCOL_ADMIN; OpenRewards.setInitialized(); return Guard.createNewAccessKeysForOpenRewards( initiator, openRewardsId, seeds ); } function startOpenRewards() internal returns (uint256 rOptimal_) { address openRewardsId = address(this); address _requestor = Context.sender(); Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.OPEN_REWARDS_MANAGER, _requestor ); OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (state.started) revert Errors.OPEN_REWARDS_ALREADY_STARTED(); if (state.active) revert Errors.OPEN_REWARDS_IS_ACTIVE(); if (config.rOptimal == 0) { revert Errors.OPTIMAL_REWARD_RATIO_CANNOT_BE_ZERO(); } if (config.maximumRLimit < config.rOptimal) { revert Errors .MAXIMUM_REWARD_RATIO_CANNOT_BE_LESS_THAN_THE_OPTIMAL_RATIO(); } (uint256 currentRewardAmount, uint256 currentMeAmount) = Helper .objectivelyObtainDoubleBalances( openRewardsId, state.reward, state.meToken ); if ( Helper.calculateLiquidityRatio( currentRewardAmount, currentMeAmount ) > config.rOptimal ) { revert Errors.OPEN_REWARDS_SHOULD_START_AT_R_OPTIMAL_OR_LESS(); } state.meTokensFromProtocolTeam = currentMeAmount; state.started = true; state.active = true; rOptimal_ = config.rOptimal; emit Logs.openRewardsStarted(_requestor, rOptimal_); } function pauseOpenRewards() internal returns (bool) { address openRewardsId = address(this); address _requestor = Context.sender(); Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.OPEN_REWARDS_MANAGER, _requestor ); OpenRewards.State storage state = OpenRewards.writableState(); if (!state.active) revert Errors.OPEN_REWARDS_IS_NOT_ACTIVE(); state.active = false; emit Logs.openRewardsPaused(_requestor); return true; } function resumeOpenRewards() internal returns (bool) { address openRewardsId = address(this); address _requestor = Context.sender(); Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.OPEN_REWARDS_MANAGER, _requestor ); OpenRewards.State storage state = OpenRewards.writableState(); if (state.active) revert Errors.OPEN_REWARDS_IS_ACTIVE(); state.active = true; emit Logs.openRewardsResumed(_requestor); return true; } function recordLiquidityProvided( Params.LiquidityInfo memory info ) internal returns (uint256, uint256) { { Validator.ensureAddressIsNotZeroAddress(info.to); Validator.ensureAddressIsNotZeroAddress(info.requestor); } address openRewardsId = address(this); address requestor = Context.sender(); { bytes32[] memory seeds = new bytes32[](2); seeds[0] = SEEDS.OPEN_REWARDS_MANAGER; seeds[1] = SEEDS.LIQUIDITY_MANAGER; Guard.ensureAccountIsAuthorized(openRewardsId, seeds, requestor); } OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); ( uint256 currentRewarAmount, uint256 currentMeAmount, uint256 addedRewardAmount, uint256 addedMeAmount ) = validateDepositRequest( state.reward, state.meToken, openRewardsId, info.rewardAmount, info.meAmount, state.lastRewardAmount, state.lastMeAmount ); updateOpenRewardsState( state, config, currentRewarAmount, currentMeAmount, uint40(Context.timestamp()) ); if ( currentMeAmount > config.notifyMeAmount && currentRewarAmount > config.notifyRewardAmount ) { OpenRewards.incrementDepositNonce(); } if (info.position != 0) { requestor = requestor == state.initiator ? info.requestor : requestor; NonFungible(openRewardsId).ensureRequestorIsPositionOwner( info.position, requestor ); } uint256 position = info.position == 0 ? OpenRewards.createNewPosition(addedRewardAmount, addedMeAmount) : OpenRewards.addToPosition( info.position, addedRewardAmount, addedMeAmount ); emit Logs.liquidityProvided( addedRewardAmount, addedMeAmount, requestor, info.to ); return (info.position, position); } function withdrawLiquidity( Params.LiquidityInfo memory info ) internal returns (uint256 rewardAmount, uint256 meAmount) { { Validator.ensureAddressIsNotZeroAddress(info.to); Validator.ensureAddressIsNotZeroAddress(info.requestor); Validator.ensureValueIsNotZero(info.position); } address openRewardsId = address(this); bytes32[] memory seeds = new bytes32[](2); seeds[0] = SEEDS.OPEN_REWARDS_MANAGER; seeds[1] = SEEDS.LIQUIDITY_MANAGER; address requestor = Context.sender(); Guard.ensureAccountIsAuthorized(openRewardsId, seeds, requestor); OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (state.busy) revert Errors.POOL_IS_BUSY(); state.busy = true; if (info.rewardAmount == 0 && info.meAmount == 0) { revert Errors.BOTH_WITHDRAWALS_CANNOT_BE_ZERO(); } NonFungible(openRewardsId).ensureRequestorIsPositionOwner( info.position, info.requestor ); OpenRewards.removeFromPosition( info.position, info.rewardAmount, info.meAmount ); (rewardAmount, meAmount) = obtainAmountOfLiquidityToWithdraw( Params.ExtendedLiquidityInfo( info.rewardAmount, info.meAmount, state.lastRewardAmount, state.lastMeAmount, config.minimumRewardAmountForConversation, config.minimumMeAmountForConversation, state.meTokensFromProtocolTeam, config.rOptimal ) ); if (rewardAmount != 0) { Helper.transferFungibleRewards(state.reward, info.to, rewardAmount); } if (meAmount != 0) { Helper.transferMeTokens(state.meToken, info.to, meAmount); } (uint256 _currentRewardAmount, uint256 _currentMeAmount) = Helper .objectivelyObtainDoubleBalances( openRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, _currentRewardAmount, _currentMeAmount, uint40(Context.timestamp()) ); state.busy = false; emit Logs.liqudityWithdrawn( rewardAmount, meAmount, info.requestor, info.to ); } function getPositionData( uint256 _positionId ) internal view returns (Positions.PositionMetadata memory data) { Validator.ensureValueIsNotZero(_positionId); return OpenRewards.getPositionData(_positionId); } function getLiquidityRatios() internal view returns (uint256 rOptimal, uint256 rLast) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); rOptimal = config.rOptimal; rLast = Helper.calculateLiquidityRatio( state.lastRewardAmount, state.lastMeAmount ); } function initiateOutgoingConversation( Params.OutgoingConversationInfo memory info ) internal returns (Params.InitiateConversationReturnType memory returnType) { { Validator.ensureValueIsNotZero(info.rewardAmountIn); Validator.ensureValueIsNotZero(info.expectedAmountOfOutputReward); Validator.ensureValueIsNotZero(info.listenerROptimal); Validator.ensureAddressIsNotZeroAddress(info.listener); Validator.ensureAddressIsNotZeroAddress(info.requestor); Validator.ensureAddressIsNotZeroAddress(info.outputRewardReceiver); } OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (!state.active) revert Errors.OPEN_REWARDS_IS_NOT_ACTIVE(); if (state.busy) revert Errors.POOL_IS_BUSY(); state.busy = true; address openRewardsId = address(this); uint256 currentRewardAmount = Helper.objectivelyObtainSingleBalance( openRewardsId, state.reward ); uint256 actuallyDepositedRewardAmount = currentRewardAmount - state.lastRewardAmount; if (actuallyDepositedRewardAmount < info.rewardAmountIn) { Helper.ensureIsWithinAcceptablePercentRange( actuallyDepositedRewardAmount, info.rewardAmountIn ); } uint256 neededMeTokenAmount = Helper .determineOptimalMeAmountForConversationGivenRewardAmount( info.listenerROptimal, info.expectedAmountOfOutputReward ); if ( neededMeTokenAmount > state.lastMeAmount - config.minimumMeAmountForConversation ) { revert Errors .ACTION_WILL_TAKE_POOL_ME_TOKENS_BELOW_CONVERSATION_LIMIT(); } uint256 rLast = Helper.calculateLiquidityRatio( state.lastRewardAmount, state.lastMeAmount ); uint256 needRewardAmount = Helper .determineRewardAmountForConversationGivenMeAmount( rLast, config.rOptimal, neededMeTokenAmount, state.lastMeAmount ); if (actuallyDepositedRewardAmount < needRewardAmount) { revert Errors.INSUFFICENT_REWARD_AMOUNT_DEPOSITED_FOR_CONVERSATION(); } Helper.transferMeTokens( state.meToken, info.listener, neededMeTokenAmount ); OpenRewards.State memory poolTwoState = Controller(info.listener) .getOpenRewardsState(); OpenRewards.Config memory poolTwoConfig = Controller(info.listener) .getOpenRewardsConfigurations(); returnType = Params.InitiateConversationReturnType( state.lastMeAmount, state.lastRewardAmount, config.notifyRewardAmount, config.notifyMeAmount, poolTwoState.lastMeAmount, poolTwoState.lastRewardAmount, poolTwoConfig.notifyRewardAmount, poolTwoConfig.notifyMeAmount, Helper.makeConversation(info), state.depositNonce, poolTwoState.depositNonce ); Helper.ensureIsWithinAcceptablePercentRange( info.expectedAmountOfOutputReward, returnType.outputRewardsAmount ); uint256 excessDepositedRewardAmount = actuallyDepositedRewardAmount - needRewardAmount; if (excessDepositedRewardAmount > 0) { Helper.transferFungibleRewards( state.reward, info.requestor, excessDepositedRewardAmount ); } (uint256 _currentRewardAmount, uint256 _currentMeAmount) = Helper .objectivelyObtainDoubleBalances( openRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, _currentRewardAmount, _currentMeAmount, uint40(Context.timestamp()) ); state.busy = false; } function engageIncomingConversation( uint256 expectedRewardAmount, address outputRewardReceiver ) internal returns (uint256) { { Validator.ensureValueIsNotZero(expectedRewardAmount); Validator.ensureAddressIsNotZeroAddress(outputRewardReceiver); } Helper.ensureIsOpenRewardsConversation(); OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (!state.active) revert Errors.OPEN_REWARDS_IS_NOT_ACTIVE(); address openRewardsId = address(this); uint256 currentMeAmount = Helper.objectivelyObtainSingleBalance( openRewardsId, state.meToken ); uint256 meAmountFromConversation = currentMeAmount - state.lastMeAmount; uint256 outputRewardAmount = Helper .determineOptimalRewardAmountForConversationGivenMeAmount( config.rOptimal, meAmountFromConversation ); Helper.ensureIsWithinAcceptablePercentRange( expectedRewardAmount, outputRewardAmount ); if ( expectedRewardAmount > state.lastRewardAmount - config.minimumRewardAmountForConversation ) { revert Errors .CONVERSATION_WILL_CAUSE_OPEN_REWARDS_TO_GO_OUT_OF_RANGE(); } Helper.transferFungibleRewards( state.reward, outputRewardReceiver, outputRewardAmount ); (uint256 _currentRewardAmount, uint256 _currentMeAmount) = Helper .objectivelyObtainDoubleBalances( openRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, _currentRewardAmount, _currentMeAmount, uint40(Context.timestamp()) ); emit Logs.conversationMade( outputRewardAmount, expectedRewardAmount, outputRewardReceiver, Context.sender() ); return outputRewardAmount; } function recordMeTokensProvidedByProtocolTeam( uint256 amount ) internal returns (uint256) { Validator.ensureValueIsNotZero(amount); address openRewardsId = address(this); address _requestor = Context.sender(); uint256 _time = Context.timestamp(); Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.PROTOCOL_ADMIN, _requestor ); OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); address OpenRewardsId = address(this); uint256 currentMeBalance = Helper.objectivelyObtainSingleBalance( OpenRewardsId, state.meToken ); uint256 actualMeOffset = currentMeBalance - state.lastMeAmount; if (actualMeOffset < amount) { Helper.ensureIsWithinAcceptablePercentRange(amount, actualMeOffset); } (uint256 _currentRewardAmount, uint256 _currentMeAmount) = Helper .objectivelyObtainDoubleBalances( OpenRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, _currentRewardAmount, _currentMeAmount, uint40(_time) ); state.meTokensFromProtocolTeam += actualMeOffset; emit Logs.meTokensProvidedByProtocolTeam(actualMeOffset); return actualMeOffset; } function releaseMeTokensProvidedByProtocolTeam( uint256 amountToRelease, address to, bytes32 releaseType ) internal returns (uint256 rewardAmount, uint256 meAmount) { { Validator.ensureValueIsNotZero(amountToRelease); Validator.ensureAddressIsNotZeroAddress(to); } address openRewardsId = address(this); address _requestor = Context.sender(); { Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.PROTOCOL_ADMIN, _requestor ); } { (rewardAmount, meAmount) = releaseType == Constants.WITH_REWARDS_IF_NEED_BE ? _withdrawProtocolMeOffsetWithRewardsIfNeedBe( amountToRelease, to ) : _withdrawProtocolMeOffsetWithdrawable(amountToRelease, to); } emit Logs.meTokensRemovedByProtocolTeam(meAmount); } function changeOpenRewardsConfigExceptROptimal( Params.EditableConfigForTypeAOpenRewards memory editableConfig, bool ignoreDefault ) internal returns (bool) { address openRewardsId = address(this); address _requestor = Context.sender(); Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.OPEN_REWARDS_MANAGER, _requestor ); emit Logs.openRewardsConfigChanged(editableConfig, ignoreDefault); return ignoreDefault ? OpenRewards.updateConfigIgnoreDefault(editableConfig) : OpenRewards.updateConfig(editableConfig); } function changeROptimal(uint256 _newROptimal) internal returns (bool) { if (_newROptimal == 0) { revert Errors.R_OPTIMAL_CANNOT_BE_ZERO(); } address openRewardsId = address(this); address _requestor = Context.sender(); Guard.ensureAccountIsAuthorized( openRewardsId, SEEDS.OPEN_REWARDS_MANAGER, _requestor ); OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); // uint256 actualROptimalInPrecision = _newROptimal * Constants.PRECISION; uint256 actualROptimalInPrecision = _newROptimal; // with this r-optimal should come in in precision, it is more flexible this way (uint256 currentRewardAmount, uint256 currentMeAmount) = Helper .objectivelyObtainDoubleBalances( openRewardsId, state.reward, state.meToken ); if (config.maximumRLimit < actualROptimalInPrecision) { revert Errors .MAXIMUM_REWARD_RATIO_CANNOT_BE_LESS_THAN_THE_OPTIMAL_RATIO(); } if ( Helper.calculateLiquidityRatio( currentRewardAmount, currentMeAmount ) > actualROptimalInPrecision ) { revert Errors .LIQUIDITY_RATIO_DURING_RESET_OF_OPTIMAL_RATIO_CANNOT_BE_GREATER_THAN_THE_OPTIMAL_RATIO(); } config.rOptimal = actualROptimalInPrecision; emit Logs.optimalRatioChanged( config.rOptimal, actualROptimalInPrecision ); return true; } function addOpenRewardsManager(address account) internal returns (bool) { { Validator.ensureAddressIsNotZeroAddress(account); } address openRewardsId = address(this); address _requestor = Context.sender(); OpenRewards.State storage state = OpenRewards.writableState(); if (_requestor != state.initiator) { revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } (bytes32 adminAccessKey, bytes32 accessKey) = Guard .synthesizeAdminAndAccessKeysForOpenRewards( state.initiator, openRewardsId, SEEDS.OPEN_REWARDS_MANAGER ); emit Logs.openRewardsManagerAdded(account, _requestor); return Guard.grantAccessToAccount(accessKey, adminAccessKey, account); } function addLiquidityManager(address account) internal returns (bool) { { Validator.ensureAddressIsNotZeroAddress(account); } address openRewardsId = address(this); address _requestor = Context.sender(); OpenRewards.State storage state = OpenRewards.writableState(); if (_requestor != state.initiator) { revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } (bytes32 adminAccessKey, bytes32 accessKey) = Guard .synthesizeAdminAndAccessKeysForOpenRewards( state.initiator, openRewardsId, SEEDS.LIQUIDITY_MANAGER ); emit Logs.liqudityManagerAdded(account, _requestor); return Guard.grantAccessToAccount(accessKey, adminAccessKey, account); } function removeOpenRewardsManager( address poolManager ) internal returns (bool) { Validator.ensureAddressIsNotZeroAddress(poolManager); address openRewardsId = address(this); address _requestor = Context.sender(); OpenRewards.State storage state = OpenRewards.writableState(); if (_requestor != state.initiator) { revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } (bytes32 adminAccessKey, bytes32 accessKey) = Guard .synthesizeAdminAndAccessKeysForOpenRewards( state.initiator, openRewardsId, SEEDS.OPEN_REWARDS_MANAGER ); emit Logs.openRewardsManagerRemoved(poolManager, _requestor); return Guard.revokeAccessFromAccount( accessKey, adminAccessKey, poolManager ); } function removeLiquidityManager( address liqudityManager ) internal returns (bool) { Validator.ensureAddressIsNotZeroAddress(liqudityManager); address openRewardsId = address(this); address _requestor = Context.sender(); OpenRewards.State storage state = OpenRewards.writableState(); if (_requestor != state.initiator) { revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } (bytes32 adminAccessKey, bytes32 accessKey) = Guard .synthesizeAdminAndAccessKeysForOpenRewards( state.initiator, openRewardsId, SEEDS.LIQUIDITY_MANAGER ); emit Logs.liquidityManagerRemoved(liqudityManager, _requestor); return Guard.revokeAccessFromAccount( accessKey, adminAccessKey, liqudityManager ); } function getPositionByIndex( uint256 _index, address _originalRequestor ) internal view returns (uint256 position) { { Validator.ensureAddressIsNotZeroAddress(_originalRequestor); } address openRewardsId = address(this); uint256 totalNumberOfPostion = NonFungible(openRewardsId).balanceOf( _originalRequestor ); if (_index > totalNumberOfPostion) { revert Errors.INVALID_POSITION_INDEX(); } position = NonFungible(openRewardsId).tokenOfOwnerByIndex( _originalRequestor, _index ); } function getAllPositions( address _originalRequestor ) internal view returns (uint256[] memory) { Validator.ensureAddressIsNotZeroAddress(_originalRequestor); address openRewardsId = address(this); uint256 totalNumberOfPostion = NonFungible(openRewardsId).balanceOf( _originalRequestor ); // if (totalNumberOfPostion == 0) { // revert Errors.REQUESTOR_HAS_NO_POSITION(); // } if (totalNumberOfPostion > 20) { revert Errors .POSITIONS_ARE_MORE_THAN_TWENTY_TRY_GETTING_THEM_ONE_AT_A_TIME(); } uint256[] memory positionPlaceholder = new uint256[]( totalNumberOfPostion ); for (uint256 i; i < totalNumberOfPostion; ) { positionPlaceholder[i] = NonFungible(openRewardsId) .tokenOfOwnerByIndex(_originalRequestor, i); ++i; } return positionPlaceholder; } function implementsOpenReward() internal pure returns (bytes4) { return Constants.OPEN_REWARDS; } function leverageOutgoingConversationInsight( uint256 meAmount, uint256 slippageInPrecision ) internal view returns (uint256 rewardAmount) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); uint256 lastRewardAmount = state.lastRewardAmount; uint256 lastMeAmount = state.lastMeAmount; uint256 rOptimal = config.rOptimal; if (slippageInPrecision == 0) { slippageInPrecision = config.defaultSlippageInPrecision; } uint256 rLast = Helper.calculateLiquidityRatio( lastRewardAmount, lastMeAmount ); uint256 exactRewardAmount = Helper .determineRewardAmountForConversationGivenMeAmount( rLast, rOptimal, meAmount, lastMeAmount ); if ( exactRewardAmount > state.lastRewardAmount - config.minimumRewardAmountForConversation ) { revert Errors .CONVERSATION_WILL_CAUSE_OPEN_REWARDS_TO_GO_OUT_OF_RANGE(); } rewardAmount = Helper.determineRewardAmountForConversationGivenMeAmount( rLast, rOptimal, meAmount, lastMeAmount ); } function leverageIncomingConversationInsight( uint256 rewardAmount ) internal view returns (uint256 optimalMeAmount, uint256 rOptimal) { OpenRewards.Config storage config = OpenRewards.writableConfig(); OpenRewards.State storage state = OpenRewards.writableState(); rOptimal = config.rOptimal; optimalMeAmount = Helper .determineOptimalMeAmountForConversationGivenRewardAmount( rOptimal, rewardAmount ); if ( rewardAmount > state.lastRewardAmount - config.minimumRewardAmountForConversation ) { revert Errors .CONVERSATION_WILL_CAUSE_OPEN_REWARDS_TO_GO_OUT_OF_RANGE(); } } function getOutgoingConversationInsight( uint256 meAmount, uint256 slippageInPrecision ) internal view returns (uint256 rewardAmount, uint256 lastRewardAmount) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); lastRewardAmount = state.lastRewardAmount; uint256 lastMeAmount = state.lastMeAmount; uint256 rOptimal = config.rOptimal; if (slippageInPrecision == 0) { slippageInPrecision = config.defaultSlippageInPrecision; } uint256 rLast = Helper.calculateLiquidityRatio( lastRewardAmount, lastMeAmount ); rewardAmount = Helper.determineRewardAmountForConversationGivenMeAmount( rLast, rOptimal, meAmount, lastMeAmount ); } function getIncomingConversationInsight( uint256 rewardAmount ) internal view returns (uint256 optimalMeAmount, uint256 lastRewardAmount) { OpenRewards.Config storage config = OpenRewards.writableConfig(); OpenRewards.State storage state = OpenRewards.writableState(); optimalMeAmount = Helper .determineOptimalMeAmountForConversationGivenRewardAmount( config.rOptimal, rewardAmount ); lastRewardAmount = state.lastRewardAmount; } // ========================================================= // FUNCTIONS INTERNALS // ========================================================= function updateOpenRewardsState( OpenRewards.State storage state, OpenRewards.Config storage config, uint256 _currentRewardAmount, uint256 _currentMeAmount, uint40 _transactionTime ) internal { uint256 r = Helper.calculateLiquidityRatio( _currentRewardAmount, _currentMeAmount ); Validator.ensureRIsWithinAcceptableRange(r, config.maximumRLimit); state.lastRewardAmount = _currentRewardAmount; state.lastMeAmount = _currentMeAmount; state.lastTransactionTime = _transactionTime; emit Logs.liquidityUpdated( _currentRewardAmount, _currentMeAmount, _transactionTime ); } function validateDepositRequest( address _reward, address _meToken, address _OpenRewardsId, uint256 _rewardAmount, uint256 _meAmount, uint256 _lastRewardAmount, uint256 _lastMeAmount ) internal view returns (uint256, uint256, uint256, uint256) { (uint256 _currentRewardAmount, uint256 _currentMeAmount) = Helper .objectivelyObtainDoubleBalances(_OpenRewardsId, _reward, _meToken); uint256 addedRewardAmount = _currentRewardAmount - _lastRewardAmount; uint256 addedMeAmount = _currentMeAmount - _lastMeAmount; if (addedRewardAmount < _rewardAmount) { revert Errors.REQUEST_IS_NOT_WITHIN_ACCEPTED_RANGE(); } if (addedMeAmount < _meAmount) { revert Errors.REQUEST_IS_NOT_WITHIN_ACCEPTED_RANGE(); } return ( _currentRewardAmount, _currentMeAmount, addedRewardAmount, addedMeAmount ); } function rewardWithdrawalTypeA( uint256 _positionRewardAmount ) internal pure returns (uint256, uint256) { return (_positionRewardAmount, 0); } function rewardWithdrawalTypeC( uint256 _positionRewardAmount, uint256 _currentRewardAmount, uint256 _minimumRewardAmountForConversation, uint256 _minimumMeAmountForConversation, uint256 _currentMeAmount, uint256 _protocolMeOffset, uint256 _rOptimal ) internal pure returns (uint256, uint256) { (uint256 base, string memory errorCode) = _protocolMeOffset > _minimumMeAmountForConversation ? (_protocolMeOffset, "PROTOCOL_OFFSET_MUST_BE_CONSIDERED") : ( _minimumMeAmountForConversation, "ACTION_WILL_TAKE_OpenRewards_ME_TOKENS_BELOW_CONVERSATION_LIMIT" ); if (_currentMeAmount > base) { revert Errors.REWARD_WITHDRAWAL_TYPE_C_ERROR(errorCode); } uint256 rewardAmountToWithdraw = _currentRewardAmount - _minimumRewardAmountForConversation; uint256 meAmountToWithdraw = ((_positionRewardAmount - rewardAmountToWithdraw) * Constants.PRECISION) / _rOptimal; if (_currentMeAmount - meAmountToWithdraw < base) { revert Errors.REWARD_WITHDRAWAL_TYPE_C_ERROR(errorCode); } return (rewardAmountToWithdraw, meAmountToWithdraw); } function meWithdrawalTypeA( uint256 _positionMeAmount ) internal pure returns (uint256, uint256) { return (0, _positionMeAmount); } function meWithdrawalTypeC( uint256 _positionMeAmount, uint256 _currentMeAmount, uint256 _currentRewardAmount, uint256 _minimumRewardAmountForConversation, uint256 _base, uint256 _rOptimal ) internal pure returns (uint256, uint256) { uint256 meAmountToWithdraw = 0; uint256 rewardAmountToWithdraw = 0; if (_currentMeAmount < _base) { rewardAmountToWithdraw = (_positionMeAmount * _rOptimal) / Constants.PRECISION; if ( _currentRewardAmount - rewardAmountToWithdraw < _minimumRewardAmountForConversation ) { revert Errors .ACTION_WOULD_TAKE_POOL_REWARDS_BELOW_CONVERSATION_LIMIT(); } } else { meAmountToWithdraw = _currentMeAmount - _base; rewardAmountToWithdraw = ((_positionMeAmount - meAmountToWithdraw) * _rOptimal) / Constants.PRECISION; if ( _currentRewardAmount - rewardAmountToWithdraw < _minimumRewardAmountForConversation ) { revert Errors .ACTION_WOULD_TAKE_POOL_REWARDS_BELOW_CONVERSATION_LIMIT(); } } return (rewardAmountToWithdraw, meAmountToWithdraw); } function obtainAmountOfLiquidityToWithdraw( Params.ExtendedLiquidityInfo memory _params ) internal pure returns (uint256, uint256) { uint256 rewardAmountToWithdrawA; uint256 rewardAmountToWithdrawB; uint256 meAmountToWithdrawA; uint256 meAmountToWithdrawB; uint256 base = _params.meTokensFromProtocolTeam > _params.minimumMeAmountForConversation ? (_params.meTokensFromProtocolTeam) : (_params.minimumMeAmountForConversation); if ( _params.currentRewardAmount < _params.rewardAmount || _params.currentRewardAmount - _params.rewardAmount < _params.minimumRewardAmountForConversation ) { ( rewardAmountToWithdrawA, meAmountToWithdrawA ) = rewardWithdrawalTypeC( _params.rewardAmount, _params.currentRewardAmount, _params.minimumRewardAmountForConversation, _params.minimumMeAmountForConversation, _params.currentMeAmount, _params.meTokensFromProtocolTeam, _params.rOptimal ); } else { ( rewardAmountToWithdrawA, meAmountToWithdrawA ) = rewardWithdrawalTypeA(_params.rewardAmount); } if ( _params.currentMeAmount < _params.meAmount || _params.currentRewardAmount - _params.meAmount < base ) { (rewardAmountToWithdrawB, meAmountToWithdrawB) = meWithdrawalTypeC( _params.meAmount, _params.currentMeAmount, _params.currentRewardAmount, _params.minimumRewardAmountForConversation, base, _params.rOptimal ); } else { (rewardAmountToWithdrawB, meAmountToWithdrawB) = meWithdrawalTypeA( _params.meAmount ); } return ( rewardAmountToWithdrawA + rewardAmountToWithdrawB, meAmountToWithdrawA + meAmountToWithdrawB ); } function _withDrawProtocolMeOffset( uint256 _meAmountToWithdraw, address to, uint256 time ) internal returns (uint256, uint256) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (state.busy) revert Errors.POOL_IS_BUSY(); state.busy = true; address OpenRewardsId = address(this); uint256 currentMeOffset = state.meTokensFromProtocolTeam; if (_meAmountToWithdraw > currentMeOffset) { revert Errors.EXPECTED_PROTOCOL_ME_OFFSET_EXCEEDS_ACTUAL_ME_OFFSET(); } uint256 currentMeAmount = Helper.objectivelyObtainSingleBalance( OpenRewardsId, state.meToken ); if (currentMeAmount < config.minimumMeAmountForConversation) { revert Errors.LIQUIDITY_IS_CURRENTLY_BELOW_CONVERSATION_LIMIT(); } if ( currentMeAmount < _meAmountToWithdraw || currentMeAmount - _meAmountToWithdraw < config.minimumMeAmountForConversation ) { revert Errors .ACTION_WOULD_TAKE_POOL_REWARDS_BELOW_CONVERSATION_LIMIT(); } state.meTokensFromProtocolTeam -= _meAmountToWithdraw; Helper.transferMeTokens(state.meToken, to, _meAmountToWithdraw); (uint256 currentRewardAmount, uint256 currentMeAmount_) = Helper .objectivelyObtainDoubleBalances( OpenRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, currentRewardAmount, currentMeAmount_, uint40(time) ); state.busy = false; return (0, _meAmountToWithdraw); } function _withdrawProtocolMeOffsetWithRewardsIfNeedBe( uint256 _meAmountToWithdraw, address to ) internal returns (uint256, uint256) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (state.busy) revert Errors.POOL_IS_BUSY(); state.busy = true; address OpenRewardsId = address(this); uint256 withdrawableMeAmount; uint256 withdrawableRewardAmount; uint256 currentMeOffset = state.meTokensFromProtocolTeam; if (_meAmountToWithdraw > currentMeOffset) { revert Errors.EXPECTED_PROTOCOL_ME_OFFSET_EXCEEDS_ACTUAL_ME_OFFSET(); } (uint256 currentRewardAmount, uint256 currentMeAmount) = Helper .objectivelyObtainDoubleBalances( OpenRewardsId, state.reward, state.meToken ); if (currentMeAmount < config.minimumMeAmountForConversation) { revert Errors.LIQUIDITY_IS_CURRENTLY_BELOW_CONVERSATION_LIMIT(); } if ( currentMeAmount <= _meAmountToWithdraw || currentMeAmount - _meAmountToWithdraw < config.minimumMeAmountForConversation ) { withdrawableMeAmount = currentMeAmount - config.minimumMeAmountForConversation; uint256 rewardAmount = Helper .determineOptimalRewardAmountForConversationGivenMeAmount( config.rOptimal, _meAmountToWithdraw - withdrawableMeAmount ); if ( currentRewardAmount > config.minimumRewardAmountForConversation ) { if (currentRewardAmount <= rewardAmount) { withdrawableRewardAmount = currentRewardAmount - config.minimumRewardAmountForConversation; } else { withdrawableRewardAmount = rewardAmount; } } } else { withdrawableMeAmount = _meAmountToWithdraw; withdrawableRewardAmount = 0; } state.meTokensFromProtocolTeam = state.meTokensFromProtocolTeam - withdrawableMeAmount; if (withdrawableMeAmount != 0) { Helper.transferMeTokens(state.meToken, to, withdrawableMeAmount); } if (withdrawableRewardAmount != 0) { Helper.transferFungibleRewards( state.reward, to, withdrawableRewardAmount ); } (currentRewardAmount, currentMeAmount) = Helper .objectivelyObtainDoubleBalances( OpenRewardsId, state.reward, state.meToken ); { updateOpenRewardsState( state, config, currentRewardAmount, currentMeAmount, uint40(Context.timestamp()) ); state.busy = false; } return (withdrawableRewardAmount, withdrawableMeAmount); } function _forcefullywithdrawProtocolOffsetMeTokens( uint256 _meAmountToWithdraw, address to, uint256 time ) internal returns (uint256, uint256) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (state.busy) revert Errors.POOL_IS_BUSY(); state.busy = true; address OpenRewardsId = address(this); uint256 withdrawableMeAmount; uint256 currentMeOffset = state.meTokensFromProtocolTeam; if (_meAmountToWithdraw > currentMeOffset) { revert Errors.EXPECTED_PROTOCOL_ME_OFFSET_EXCEEDS_ACTUAL_ME_OFFSET(); } uint256 currentMeAmount = Helper.objectivelyObtainSingleBalance( OpenRewardsId, state.meToken ); if (_meAmountToWithdraw > currentMeAmount) { withdrawableMeAmount = currentMeAmount; } else { withdrawableMeAmount = _meAmountToWithdraw; } if (withdrawableMeAmount != 0) { Helper.transferMeTokens(state.meToken, to, withdrawableMeAmount); } state.meTokensFromProtocolTeam = state.meTokensFromProtocolTeam - withdrawableMeAmount; (uint256 currentRewardAmount, uint256 currentMeAmount_) = Helper .objectivelyObtainDoubleBalances( OpenRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, currentRewardAmount, currentMeAmount_, uint40(time) ); state.busy = false; return (0, withdrawableMeAmount); } function _withdrawProtocolMeOffsetWithdrawable( uint256 _meAmountToWithdraw, address to ) internal returns (uint256, uint256) { OpenRewards.State storage state = OpenRewards.writableState(); OpenRewards.Config storage config = OpenRewards.writableConfig(); if (state.busy) revert Errors.POOL_IS_BUSY(); state.busy = true; address OpenRewardsId = address(this); uint256 withdrawableAmount; uint256 currentMeOffset = state.meTokensFromProtocolTeam; if (_meAmountToWithdraw > currentMeOffset) { revert Errors.EXPECTED_PROTOCOL_ME_OFFSET_EXCEEDS_ACTUAL_ME_OFFSET(); } uint256 currentMeAmount = Helper.objectivelyObtainSingleBalance( OpenRewardsId, state.meToken ); if (currentMeAmount < config.minimumMeAmountForConversation) { revert Errors.LIQUIDITY_IS_CURRENTLY_BELOW_CONVERSATION_LIMIT(); } if ( currentMeAmount <= _meAmountToWithdraw || currentMeAmount - _meAmountToWithdraw < config.minimumMeAmountForConversation ) { withdrawableAmount = currentMeAmount - config.minimumMeAmountForConversation; } else { withdrawableAmount = _meAmountToWithdraw; } state.meTokensFromProtocolTeam -= withdrawableAmount; { Helper.transferMeTokens(state.meToken, to, withdrawableAmount); (uint256 currentRewardAmount, uint256 currentMeAmount_) = Helper .objectivelyObtainDoubleBalances( OpenRewardsId, state.reward, state.meToken ); updateOpenRewardsState( state, config, currentRewardAmount, currentMeAmount_, uint40(Context.timestamp()) ); } state.busy = false; return (0, withdrawableAmount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.20; import {ERC721 as NonFungible, IERC165} from "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol"; import {Errors} from "../../providers/common/errors.sol"; abstract contract NonFungibleAndEnumerable is NonFungible, IERC721Enumerable { mapping(address => mapping(uint256 => uint256)) private _ownedTokens; mapping(uint256 => uint256) private _ownedTokensIndex; uint256[] private _allTokens; mapping(uint256 => uint256) private _allTokensIndex; function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, NonFungible) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < NonFungible.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < NonFungibleAndEnumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual override { super._beforeTokenTransfer(from, to, firstTokenId, batchSize); if (batchSize > 1) { revert("ERC721Enumerable: consecutive transfers not supported"); } uint256 tokenId = firstTokenId; if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = NonFungible.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { uint256 lastTokenIndex = NonFungible.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; _ownedTokensIndex[lastTokenId] = tokenIndex; } delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; _allTokensIndex[lastTokenId] = tokenIndex; delete _allTokensIndex[tokenId]; _allTokens.pop(); } ///added Logic function ensureRequestorIsPositionOwner(uint256 position, address requestor) external view returns (uint256) { if (_ownerOf(position) == address(0)) revert Errors.INVALID_POSITION(); if (requestor != _ownerOf(position)) { revert Errors.REQUESTOR_IS_NOT_OWNER_OF_POSITION(); } return position; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Validator, Errors} from "./validators.sol"; import {Constants} from "./constants.sol"; import {FungibleController as Fungible} from "../../controllers/standards/fungible.controller.sol"; import {Params} from "./params.sol"; library Eunice { function calculateLiquidityRatio(uint256 _rewardAmount, uint256 _meAmount) internal pure returns (uint256 ratio) { Validator.ensureValueIsNotZero(_meAmount); ratio = (_rewardAmount * Constants.PRECISION) / _meAmount; } function objectivelyObtainSingleBalance(address _pool, address _reward) internal view returns (uint256 bal) { bal = Fungible(_reward).balanceOf(_pool); } function objectivelyObtainDoubleBalances(address _pool, address _reward, address _me) internal view returns (uint256 rewardAmount, uint256 meAmount) { rewardAmount = Fungible(_reward).balanceOf(_pool); meAmount = Fungible(_me).balanceOf(_pool); } function objectivelyObtainLiquidityRatio(address _pool, address _reward, address _me) internal view returns (uint256 ratio) { (uint256 a, uint256 b) = objectivelyObtainDoubleBalances(_pool, _reward, _me); ratio = calculateLiquidityRatio(a, b); } function calculateExchangeRatio(uint256 rLast, uint256 percentageChange, uint256 rOptimal) internal pure returns (uint256 exchangeRatio) { exchangeRatio = (rLast * (1 * Constants.PRECISION + (Constants.EXCHANGE_SLOPE * percentageChange) / 100)) / Constants.PRECISION; exchangeRatio = exchangeRatio < rOptimal ? rOptimal : exchangeRatio; } function determineRewardAmountForConversationGivenMeAmount( uint256 _rLast, uint256 _rOptimal, uint256 _meAmount, uint256 _lastMeAmount ) internal pure returns (uint256 t) { uint256 percentageChange = (_meAmount * 100) / _lastMeAmount; uint256 actualReward = (_meAmount * calculateExchangeRatio(_rLast, percentageChange, _rOptimal)) / Constants.PRECISION; t = actualReward; } function determineOptimalMeAmountForConversationGivenRewardAmount(uint256 _rOptimal, uint256 _rewardAmount) internal pure returns (uint256 t) { Validator.ensureValueIsNotZero(_rOptimal); t = (_rewardAmount * Constants.PRECISION) / _rOptimal; } function determineOptimalRewardAmountForConversationGivenMeAmount(uint256 _rOptimal, uint256 _meAmount) internal pure returns (uint256 t) { t = (_meAmount * _rOptimal) / Constants.PRECISION; } function checkIfWithinAcceptableSlippageRange( uint256 _obtainedValue, uint256 _actualValue, uint256 _slippageInPrecision ) internal pure returns (bool t) { Validator.ensureValueIsNotZero(_actualValue); uint256 a = _obtainedValue > _actualValue ? (_obtainedValue - _actualValue) : (_actualValue - _obtainedValue); t = (a * Constants.PRECISION) / _actualValue <= (Constants.PRECISION * _slippageInPrecision) / 100; } function checkIfWithinAcceptablePercentRange(uint256 _obtainedValue, uint256 _actualValue) internal pure returns (bool t) { Validator.ensureValueIsNotZero(_actualValue); uint256 a = _obtainedValue > _actualValue ? (_obtainedValue - _actualValue) : (_actualValue - _obtainedValue); t = (a * Constants.PRECISION) / _actualValue <= Constants.PRECISION / 100; } function ensureIsWithinAcceptablePercentRange(uint256 _obtainedValue, uint256 _actualValue) internal pure { if (!checkIfWithinAcceptablePercentRange(_obtainedValue, _actualValue)) { revert Errors.REQUEST_IS_NOT_WITHIN_ACCEPTED_RANGE(); } } function ensureIsWithinAcceptableSlippageRange(uint256 _obtainedValue, uint256 _actualValue, uint256 _slippage) internal pure { if (!checkIfWithinAcceptableSlippageRange(_obtainedValue, _actualValue, _slippage)) { revert Errors.REQUEST_NOT_WITHIN_SLIPPAGE_RANGE(); } } function transferFungibleRewards(address _erc20address, address _to, uint256 _amount) internal { (bool success, bytes memory data) = _erc20address.call(abi.encodeWithSelector(bytes4(keccak256("transfer(address,uint256)")), _to, _amount)); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) { revert Errors.REWARDS_TRANSFER_FAILED(); } } function approveFungibleRewards(address _erc20address, address _to, uint256 _amount) internal { (bool success, bytes memory data) = _erc20address.call(abi.encodeWithSelector(bytes4(keccak256("approve(address,uint256)")), _to, _amount)); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) { revert Errors.REWARDS_APPROVAL_FAILED(); } } function transferMeTokens(address _erc20address, address _to, uint256 _amount) internal { (bool success, bytes memory data) = _erc20address.call(abi.encodeWithSelector(bytes4(keccak256("transfer(address,uint256)")), _to, _amount)); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) { revert Errors.REWARDS_TRANSFER_FAILED(); } } function transferFungibleRewardsFromAccount(address _rewardAddress, address _from, address _to, uint256 _amount) internal { (bool success, bytes memory data) = _rewardAddress.call( abi.encodeWithSelector(bytes4(keccak256("transferFrom(address,address,uint256)")), _from, _to, _amount) ); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) { revert Errors.REWARDS_TRANSFER_FAILED(); } } function transferFungibleRewardsFromAccountWithPermit( address _rewardAddress, address _from, address _to, uint256 _amount, Params.PermitParam memory permitParam ) internal { (bool success_p, bytes memory data_p) = _rewardAddress.call( abi.encodeWithSelector( bytes4(keccak256("permit(address,address,uint256,uint256,uint8,bytes32,bytes32)")), _from, address(this), _amount, permitParam._deadline, permitParam._v, permitParam._r, permitParam._s ) ); if (!(success_p && (data_p.length == 0 || abi.decode(data_p, (bool))))) { revert Errors.REWARDS_PERMIT_FAILED(); } (bool success, bytes memory data) = _rewardAddress.call( abi.encodeWithSelector(bytes4(keccak256("transferFrom(address,address,uint256)")), _from, _to, _amount) ); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) { revert Errors.REWARDS_TRANSFER_FAILED(); } } function transferMeTokensFromAccount(address _meAddress, address _from, address _to, uint256 _amount) internal { (bool success, bytes memory data) = _meAddress.call( abi.encodeWithSelector(bytes4(keccak256("transferFrom(address,address,uint256)")), _from, _to, _amount) ); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) { revert Errors.REWARDS_TRANSFER_FAILED(); } } function takeSlippageInPercentageToPrecision(uint256 slippage) internal pure returns (uint256) { return (slippage * Constants.PRECISION) / Constants.PERCENTAGE; } // function makeConversation(address listener, uint256 outputRewardAmount, address receiver) function makeConversation(Params.OutgoingConversationInfo memory info) internal returns (uint256 result) { bytes memory tre = abi.encodeWithSelector( bytes4(keccak256("engageIncomingConversation(uint256,address)")), info.expectedAmountOfOutputReward, info.outputRewardReceiver ); // bytes memory tre = abi.encodeWithSignature("engageIncomingConversation(uint256,address)", outputRewardAmount, receiver); bytes memory conversationData = abi.encodePacked(tre, Constants.OPEN_REWARDS); (bool success, bytes memory returnData) = info.listener.call(conversationData); if (!success) revert Errors.CONVERSATION_FAILED(); result = abi.decode(returnData, (uint256)); } function ensureIsOpenRewardsConversation() internal pure { bytes4 data; assembly { data := calldataload(68) // 68 is the offset to where the extra data starts } if (data != Constants.OPEN_REWARDS) { revert Errors.NOT_OPEN_REWARDS_CONVERSATION(); } } function addBountyContribution(uint256 rewardAmountForConversation, uint256 bountyContributionInPrecision) internal pure returns (uint256) { uint256 actualBountyContribution = (bountyContributionInPrecision * rewardAmountForConversation) / Constants.PRECISION; return actualBountyContribution + rewardAmountForConversation; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Database} from "./database.sol"; library Context { struct ContextData { mapping(address => bool) isTrustedForwarder; } function writeableStorage() internal pure returns (ContextData storage ds) { bytes32 position = Database.CONTEXT_RECORD; assembly { ds.slot := position } } // This function must be called on diamnd init to set the trusted forwarder function setTrustedForwarder(address forwarder) internal { writeableStorage().isTrustedForwarder[forwarder] = true; } function isTrustedForwarder(address forwarder) internal view returns (bool) { return writeableStorage().isTrustedForwarder[forwarder]; } function sender() internal view returns (address senderAddress) { if (isTrustedForwarder(msg.sender)) { assembly { senderAddress := shr(96, calldataload(sub(calldatasize(), 20))) } } else { return msg.sender; } } function data() internal view returns (bytes calldata) { if (isTrustedForwarder(msg.sender)) { return msg.data[:msg.data.length - 20]; } else { return msg.data; } } function timestamp() internal view returns (uint256) { return block.timestamp; } function blocks() internal view returns (uint256) { return block.number; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Positions} from "./a-position.sol"; import {Database, Params, Validator, Errors, Constants} from "../common/database.sol"; library OpenRewardsData { struct State { bool initialized; bool started; bool active; bool busy; address initiator; address reward; address meToken; uint256 lastRewardAmount; uint256 lastMeAmount; uint256 meTokensFromProtocolTeam; uint256 depositNonce; uint40 lastTransactionTime; } struct Config { uint256 rOptimal; uint256 maximumRLimit; uint256 minimumRewardAmountForConversation; uint256 minimumMeAmountForConversation; uint256 notifyRewardAmount; uint256 notifyMeAmount; uint256 defaultSlippageInPrecision; bool allowSwaps; } function writableState() internal pure returns (State storage state) { bytes32 position = Database.OPEN_REWARDS_STATE_TYPE_A; assembly { state.slot := position } } function writableConfig() internal pure returns (Config storage config) { bytes32 position = Database.OPEN_REWARDS_CONFIG_TYPE_A; assembly { config.slot := position } } function writablePositions() internal pure returns (Positions.Position storage positions) { bytes32 position = Database.OPEN_REWARDS_POSITIONS_TYPE_A; assembly { positions.slot := position } } function getDepositNonce() internal view returns (uint256 nonce) { State storage state = writableState(); nonce = state.depositNonce; } function incrementDepositNonce() internal returns (uint256 nonce) { State storage state = writableState(); nonce = state.depositNonce + 1; state.depositNonce = nonce; } function setBusy() internal returns (bool) { State storage state = writableState(); return state.busy = true; } function createNewPosition( uint256 rewardAmount, uint256 meAmount ) internal returns (uint256 newPosition) { Positions.Position storage position = writablePositions(); uint256 currentPosition = position.lastPosition; newPosition = currentPosition + 1; position.lastPosition = newPosition; position.positionMetadata[newPosition] = Positions.PositionMetadata( rewardAmount, meAmount ); } function addToPosition( uint256 _position, uint256 rewardAmount, uint256 meAmount ) internal returns (uint256) { Positions.Position storage position = writablePositions(); if (_position > position.lastPosition) revert Errors.INVALID_POSITION(); Positions.PositionMetadata memory currentMetadata = position .positionMetadata[_position]; position.positionMetadata[_position] = Positions.PositionMetadata( currentMetadata.rewardPosition + rewardAmount, currentMetadata.mePosition + meAmount ); return _position; } function removeFromPosition( uint256 _position, uint256 rewardAmount, uint256 meAmount ) internal returns (uint256) { Positions.Position storage position = writablePositions(); if (_position > position.lastPosition) revert Errors.INVALID_POSITION(); Positions.PositionMetadata memory currentMetadata = position .positionMetadata[_position]; if (currentMetadata.rewardPosition < rewardAmount) { revert Errors.INSUFFICIENT_REWARD_POSITION(); } if (currentMetadata.mePosition < meAmount) { revert Errors.INSUFFICIENT_ME_POSITION(); } position.positionMetadata[_position] = Positions.PositionMetadata( currentMetadata.rewardPosition - rewardAmount, currentMetadata.mePosition - meAmount ); return _position; } function ensurePositionExists( uint256 _position ) internal view returns (uint256) { Positions.Position storage position = writablePositions(); if (_position > position.lastPosition) revert Errors.INVALID_POSITION(); return _position; } function getPositionData( uint256 _position ) internal view returns (Positions.PositionMetadata memory data) { Positions.Position storage position = writablePositions(); if (_position > position.lastPosition) revert Errors.INVALID_POSITION(); data = position.positionMetadata[_position]; } function updateConfig( Params.EditableConfigForTypeAOpenRewards memory _config ) internal returns (bool) { Config storage config = writableConfig(); config.maximumRLimit = _config.maximumRLimit; config.minimumRewardAmountForConversation = _config .minimumRewardAmountForConversation; config.minimumMeAmountForConversation = _config .minimumMeAmountForConversation; config.notifyRewardAmount = _config.notifyRewardAmount; config.notifyMeAmount = _config.notifyMeAmount; config.defaultSlippageInPrecision = _config.defaultSlippageInPrecision; config.allowSwaps = _config.allowSwaps; return true; } function updateConfigIgnoreDefault( Params.EditableConfigForTypeAOpenRewards memory _config ) internal returns (bool) { Config storage config = writableConfig(); if (!Validator.isZero(_config.maximumRLimit)) { config.maximumRLimit = _config.maximumRLimit; } if (!Validator.isZero(_config.minimumRewardAmountForConversation)) { config.minimumRewardAmountForConversation = _config .minimumRewardAmountForConversation; } if (!Validator.isZero(_config.minimumMeAmountForConversation)) { config.minimumMeAmountForConversation = _config .minimumMeAmountForConversation; } if (!Validator.isZero(_config.notifyRewardAmount)) { config.notifyRewardAmount = _config.notifyRewardAmount; } if (!Validator.isZero(_config.notifyMeAmount)) { config.notifyMeAmount = _config.notifyMeAmount; } if (!Validator.isZero(_config.defaultSlippageInPrecision)) { config.defaultSlippageInPrecision = _config .defaultSlippageInPrecision; } if (!Validator.isFalse(_config.allowSwaps)) { config.allowSwaps = _config.allowSwaps; } return true; } function setUpConfig( Params.ConfigForTypeAOpenRewards memory _config ) internal returns (bool) { Config storage config = writableConfig(); config.rOptimal = _config.rOptimal; config.maximumRLimit = _config.maximumRLimit; config.minimumRewardAmountForConversation = _config .minimumRewardAmountForConversation; config.minimumMeAmountForConversation = _config .minimumMeAmountForConversation; config.notifyRewardAmount = _config.notifyRewardAmount; config.notifyMeAmount = _config.notifyMeAmount; config.defaultSlippageInPrecision = _config.defaultSlippageInPrecision; config.allowSwaps = _config.allowSwaps; return true; } function getLastRecordedBalances() internal view returns (uint256 rewardBalance, uint256 meBalance) { State storage state = writableState(); rewardBalance = state.lastRewardAmount; meBalance = state.lastMeAmount; } function getOptimalRatio() internal view returns (uint256 optimalRatio) { Config storage config = writableConfig(); optimalRatio = config.rOptimal; } function getState() internal pure returns (State memory state) { state = writableState(); } function getConfig() internal pure returns (Config memory config) { config = writableConfig(); } function getLiqudityIds() internal view returns (address initiator, address reward, address meToken) { State storage state = writableState(); initiator = state.initiator; reward = state.reward; meToken = state.meToken; } function setInitialized() internal returns (bool) { State storage state = writableState(); return state.initialized = true; } function getIsInitialized() internal view returns (bool) { State storage state = writableState(); return state.initialized; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Database} from "./database.sol"; import {Errors} from "./errors.sol"; import {Validator} from "./validators.sol"; import {Params} from "./params.sol"; import {Constants} from "./constants.sol"; import {Roles} from "./roles.sol"; library RoleGuard { struct AccessData { bytes32 adminAccessKey; mapping(address => bool) members; } function writableRoleRecords() internal pure returns (mapping(bytes32 => AccessData) storage records) { bytes32 position = Database.ACCESS_RECORDS; assembly { records.slot := position } } function isAuthorized( bytes32 accessKey, address account ) internal view returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); return records[accessKey].members[account]; } ///@dev many seeds, single reward with brandId input function ensureAccountIsAuthorized( address target, bytes32[] memory seeds, address account, bytes10 brandId ) internal view returns (bool) { if (seeds.length > 5) revert Errors.SEEDS_ARE_TOO_MUCH(); mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (!Validator.isEmpty(brandId)) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForReward(brandId, target, seeds[0]); if (adminAccessKey == records[accessKey].adminAccessKey) { return true; } } for (uint256 i; i < seeds.length; ) { bytes32 accessKey = synthesizeAccessKeyForReward(target, seeds[i]); if (records[accessKey].members[account]) { return true; } ++i; } revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } ///@dev many seeds, with brandId target function ensureAccountIsAuthorized( bytes10 target, bytes32[] memory seeds, address account, bytes10 brandId ) internal view returns (bool) { if (seeds.length > 5) revert Errors.SEEDS_ARE_TOO_MUCH(); mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (!Validator.isEmpty(brandId)) { if (target == brandId) return true; } for (uint256 i; i < seeds.length; ) { bytes32 accessKey = synthesizeAccessKeyForBrand(target, seeds[i]); if (records[accessKey].members[account]) { return true; } ++i; } revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } ///@dev used with openRewards function ensureAccountIsAuthorized( address target, bytes32[] memory seeds, address account ) internal view returns (bool) { if (seeds.length > 5) revert Errors.SEEDS_ARE_TOO_MUCH(); mapping(bytes32 => AccessData) storage records = writableRoleRecords(); ( bytes32 adminAccessKey, bytes32 _accessKey ) = synthesizeAdminAndAccessKeysForOpenRewards( account, target, seeds[0] ); if (adminAccessKey == records[_accessKey].adminAccessKey) return true; for (uint256 i; i < seeds.length; ) { bytes32 accessKey = synthesizeAccessKeyForReward(target, seeds[i]); if (records[accessKey].members[account]) { return true; } ++i; } revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } ///@dev single seed, single reward with brand id function ensureAccountIsAuthorized( address target, bytes32 seed, address account, bytes10 brandId ) internal view returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); ( bytes32 adminKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForReward(brandId, target, seed); if (adminKey != records[accessKey].adminAccessKey) { if (!records[accessKey].members[account]) { revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } } return true; } ///@dev single seed, single target brand with brand id function ensureAccountIsAuthorized( bytes10 target, bytes32 seed, address account, bytes10 brandId ) internal view returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (brandId != target) { bytes32 accessKey = synthesizeAccessKeyForBrand(target, seed); if (!records[accessKey].members[account]) { revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } } return true; } ///@dev used for openrewards function ensureAccountIsAuthorized( address target, bytes32 seed, address account ) internal view returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeysForOpenRewards(account, target, seed); if (adminAccessKey == records[accessKey].adminAccessKey) return true; if (records[accessKey].members[account]) return true; revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } ///@dev this is used foe the main me-protocol rule function ensureAccountIsAuthorized( bytes32 seed, address account ) internal view returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForMeProtocol(account, seed); if (adminAccessKey == records[accessKey].adminAccessKey) return true; if (records[accessKey].members[account]) return true; revert Errors.ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); } function grantAccessToAccount( bytes32 accessKey, bytes32 adminAccessKey, address account ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (adminAccessKey != records[accessKey].adminAccessKey) { revert Errors.REQUESTOR_IS_NOT_ADMIN_FOR_THIS_ACCESS_KEY(); } if (records[accessKey].members[account]) { revert Errors.ACCOUNT_ALREADY_HAS_ACCESS(); } records[accessKey].members[account] = true; return true; } function revokeAccessFromAccount( bytes32 accessKey, bytes32 adminAccessKey, address account ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (adminAccessKey != records[accessKey].adminAccessKey) { revert Errors.REQUESTOR_IS_NOT_ADMIN_FOR_THIS_ACCESS_KEY(); } if (!records[accessKey].members[account]) { revert Errors.ACCOUNT_DOES_NOT_HAVE_ACCESS(); } records[accessKey].members[account] = false; return true; } function createNewAccesskeyForReward( bytes10 brand, address target, bytes32 seed ) internal returns (bool) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForReward(brand, target, seed); return _createNewAccessKey(accessKey, adminAccessKey); } function createNewAccessKeysForReward( bytes10 brand, address target, bytes32[] memory seeds ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (seeds.length > 5) revert Errors.SEEDS_ARE_TOO_MUCH(); for (uint256 i; i < seeds.length; ) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForReward(brand, target, seeds[i]); if ( records[accessKey].adminAccessKey != Constants.EMPTY_ACCESS_KEY ) { revert Errors.ACCESS_KEY_ALREADY_EXISTS_PLEASE_CHANGE_INSTEAD(); } records[accessKey].adminAccessKey = adminAccessKey; ++i; } return true; } function createNewAccessKeysForOpenRewards( address admin, address target, bytes32[] memory seeds ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (seeds.length > 5) revert Errors.SEEDS_ARE_TOO_MUCH(); for (uint256 i; i < seeds.length; ) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeysForOpenRewards( admin, target, seeds[i] ); if ( records[accessKey].adminAccessKey != Constants.EMPTY_ACCESS_KEY ) { revert Errors.ACCESS_KEY_ALREADY_EXISTS_PLEASE_CHANGE_INSTEAD(); } records[accessKey].adminAccessKey = adminAccessKey; ++i; } return true; } function createNewAccessKeyForMeProtocol( address admin, bytes32[] memory seed ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (seed.length > 5) revert Errors.SEEDS_ARE_TOO_MUCH(); for (uint256 i; i < seed.length; ) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForMeProtocol(admin, seed[i]); if ( records[accessKey].adminAccessKey != Constants.EMPTY_ACCESS_KEY ) { revert Errors.ACCESS_KEY_ALREADY_EXISTS_PLEASE_CHANGE_INSTEAD(); } records[accessKey].adminAccessKey = adminAccessKey; ++i; } return true; } function createNewAccessKeyForMeProtocol( address admin, bytes32 seed ) internal returns (bool) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForMeProtocol(admin, seed); return _createNewAccessKey(accessKey, adminAccessKey); } function createNewAccesskeyForBrand( bytes10 brand, bytes32 seed ) internal returns (bool) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeyForBrand(brand, seed); return _createNewAccessKey(accessKey, adminAccessKey); } function createNewAccessKeyForOpenRewards( address admin, address target, bytes32 seed ) internal returns (bool) { ( bytes32 adminAccessKey, bytes32 accessKey ) = synthesizeAdminAndAccessKeysForOpenRewards(admin, target, seed); return _createNewAccessKey(accessKey, adminAccessKey); } function _createNewAccessKey( bytes32 accessKey, bytes32 adminAccessKey ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (records[accessKey].adminAccessKey != Constants.EMPTY_ACCESS_KEY) { revert Errors.ACCESS_KEY_ALREADY_EXISTS_PLEASE_CHANGE_INSTEAD(); } records[accessKey].adminAccessKey = adminAccessKey; return true; } function changeAdminAccessKey( bytes32 accessKey, bytes32 adminAccessKey, bytes32 newAdminAccessKey ) internal returns (bool) { mapping(bytes32 => AccessData) storage records = writableRoleRecords(); if (adminAccessKey != records[accessKey].adminAccessKey) { revert Errors.REQUESTOR_IS_NOT_ADMIN_FOR_THIS_ACCESS_KEY(); } records[accessKey].adminAccessKey = newAdminAccessKey; return true; } function synthesizeAdminAndAccessKeyForMeProtocol( address admin, bytes32 seed ) internal pure returns (bytes32 adminAccessKey, bytes32 accessKey) { accessKey = synthesizeAccessKeyForMeProtocol(seed); adminAccessKey = synthesizeAdminAccessKeyForMeProtocol(admin, seed); } function synthesizeAdminAndAccessKeyForReward( bytes10 brand, address target, bytes32 seed ) internal pure returns (bytes32 adminAccessKey, bytes32 accessKey) { accessKey = synthesizeAccessKeyForReward(target, seed); adminAccessKey = synthesizeAdminAccessKeyForReward(brand, target); } function synthesizeAdminAndAccessKeyForBrand( bytes10 brand, bytes32 seed ) internal pure returns (bytes32 adminAccessKey, bytes32 accessKey) { accessKey = synthesizeAccessKeyForBrand(brand, seed); adminAccessKey = synthesizeAdminAcessKeyForBrand(brand); } function synthesizeAccessKeyForReward( address target, bytes32 seed ) internal pure returns (bytes32 accessKey) { accessKey = keccak256(abi.encodePacked(target, seed)); } function synthesizeAccessKeyForOpenRewards( address target, bytes32 seed ) internal pure returns (bytes32 accessKey) { accessKey = keccak256(abi.encodePacked(target, seed)); } function synthesizeAdminAccessKeyForOpenRewards( address admin, address target ) internal pure returns (bytes32 adminAccessKey) { adminAccessKey = keccak256(abi.encodePacked(admin, target)); } function synthesizeAdminAcessKeyForBrand( bytes10 brand ) internal pure returns (bytes32 adminAccessKey) { adminAccessKey = keccak256(abi.encodePacked(brand)); } function synthesizeAdminAccessKeyForMeProtocol( address admin, bytes32 seed ) internal pure returns (bytes32 accessKey) { accessKey = keccak256(abi.encodePacked(admin, seed)); } function synthesizeAccessKeyForMeProtocol( bytes32 seed ) internal pure returns (bytes32 adminAccessKey) { adminAccessKey = keccak256(abi.encodePacked(seed)); } function synthesizeAdminAccessKeyForReward( bytes32 brand, address target ) internal pure returns (bytes32 adminAccessKey) { adminAccessKey = keccak256(abi.encodePacked(brand, target)); } function synthesizeAccessKeyForBrand( bytes10 brand, bytes32 seed ) internal pure returns (bytes32 accessKey) { accessKey = keccak256(abi.encodePacked(brand, seed)); } function synthesizeAdminAndAccessKeysForOpenRewards( address admin, address target, bytes32 seed ) internal pure returns (bytes32 adminAccessKey, bytes32 accessKey) { accessKey = synthesizeAccessKeyForOpenRewards(target, seed); adminAccessKey = synthesizeAdminAccessKeyForOpenRewards(admin, target); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {NonFungibleController as NonFungible} from "../standards/nonFungible.controller.sol"; import {Params, OpenRewardsData as ORData} from "../../providers/data/a-pool.sol"; interface OpenRewardsController { function startOpenRewards() external returns (uint256 optimalRewardValueInPrecision); function pauseOpenRewards() external returns (bool); function resumeOpenRewards() external returns (bool); function recordLiquidityProvided(Params.LiquidityInfo memory info) external returns (uint256); function withdrawLiquidity(Params.LiquidityInfo memory info) external returns (uint256, uint256); function addOpenRewardsManager(address newPoolManager) external returns (bool); function removeOpenRewardsManager(address poolManager) external returns (bool); function addLiquidityManager(address account) external returns (bool); function removeLiquidityManager(address liquidityManger) external returns (bool); function getLiquidityRatios() external view returns (uint256, uint256); function getLiquidityIds() external view returns (address, address, address); function getOpenRewardsState() external view returns (ORData.State memory); function getOpenRewardsConfigurations() external view returns (ORData.Config memory); function initiateOutgoingConversation(Params.OutgoingConversationInfo memory info) external returns (Params.InitiateConversationReturnType memory conversionDigest); function engageIncomingConversation(uint256 outputRewardAmount, address to) external returns (uint256); function recordMeTokensProvidedByProtocolTeam(uint256 expecteDeposit) external returns (uint256); function releaseMeTokensProvidedByProtocolTeam(uint256 amountToRelease, address to, bytes32 typeOfRelease) external returns (uint256, uint256); function changeConfigExceptOptimalRatio( Params.EditableConfigForTypeAOpenRewards memory editableConfig, bool ignoreDefault ) external returns (bool); function changeOptimalRatio(uint256 newOptimalRatio) external returns (bool); function getLiquidityPositionByIndex(uint256 index, address account) external view returns (uint256); function getAllLiquidityPositionForAccount(address requestor) external view returns (uint256[] memory); function getOptimalRatio() external view returns (uint256); function leverageOutgoingConversationInsight(uint256 meAmount, uint256 slippageInPrecision) external view returns (uint256 rewardAmount); function leverageIncomingConversationInsight(uint256 rewardAmount) external view returns (uint256 optimalMeAmount, uint256 rOptimal); function getOutgoingConversationInsight(uint256 meAmount, uint256 slippageInPrecision) external view returns (uint256 rewardAmount, uint256 lastRewardAmount); function getIncomingConversationInsight(uint256 rewardAmount) external view returns (uint256 optimalMeAmount, uint256 lastRewardAmount); function initialize(address reward, address meToken, Params.ConfigForTypeAOpenRewards memory config) external returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Params} from "../common/params.sol"; library OpenRewardsLogs { event openRewardsStarted(address requestor, uint256 optimalRatioInPrecision); event openRewardsPaused(address requestor); event openRewardsResumed(address requestor); event liquidityProvided(uint256 rewardAmount, uint256 meAmount, address requestor, address to); event liqudityWithdrawn(uint256 rewardAmount, uint256 meAmount, address requestor, address to); event openRewardsManagerAdded(address newOpenRewardsManager, address requestor); event openRewardsManagerRemoved(address openRewardsManager, address requestor); event liqudityManagerAdded(address account, address requestor); event liquidityManagerRemoved(address liqudityManager, address requestor); event conversationMade(uint256 inputReward, uint256 outputReward, address outputOpenRewardsId, address requestor); event meTokensProvidedByProtocolTeam(uint256 amount); event meTokensRemovedByProtocolTeam(uint256 amount); event openRewardsConfigChanged(Params.EditableConfigForTypeAOpenRewards editableConfig, bool ignoreDefault); event optimalRatioChanged(uint256 oldRatio, uint256 newRatio); event refunded(address reward, address user, uint256 amount); event liquidityUpdated(uint256 rewardAmount, uint256 meAmount, uint40 timestamp); event currentPoolsState( address indexed rewardOne, uint256 currentAmountOfMeTokensrewardOne, uint256 currentAmountOfRewardTokensrewardOne, uint256 notifyRewardAmountrewardOne, uint256 notifyMeTokenAmountrewardOne, address indexed rewardTwo, uint256 currentAmountOfMeTokensRewardTwo, uint256 currentAmountOfRewardTokensRewardTwo, uint256 notifyRewardAmountRewardTwo, uint256 notifyMeTokenAmountRewardTwo ); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.2) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; import "./IERC721.sol"; import "./IERC721Receiver.sol"; import "./extensions/IERC721Metadata.sol"; import "../../utils/Address.sol"; import "../../utils/Context.sol"; import "../../utils/Strings.sol"; import "../../utils/introspection/ERC165.sol"; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such * that `ownerOf(tokenId)` is `a`. */ // solhint-disable-next-line func-name-mixedcase function __unsafe_increaseBalance(address account, uint256 amount) internal { _balances[account] += amount; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; library Errors { error ADDRESS_ZERO_NOT_ALLOWED(); error ZERO_NOT_ALLOWED(); error EMPTY_STRING_NOT_ALLOWED(); error EMPTY_REASON_NOT_ALLOWED(); error OPEN_REWARDS_NOT_STARTED(); error OPEN_REWARDS_ALREADY_STARTED(); error OPEN_REWARDS_IS_PAUSED(); error OPEN_REWARDS_IS_ACTIVE(); error OPEN_REWARDS_IS_NOT_ACTIVE(); error OPTIMAL_REWARD_RATIO_CANNOT_BE_ZERO(); error MAXIMUM_REWARD_RATIO_CANNOT_BE_LESS_THAN_THE_OPTIMAL_RATIO(); error OPEN_REWARDS_SHOULD_START_AT_R_OPTIMAL_OR_LESS(); error EXPECTED_PROTOCOL_ME_OFFSET_EXCEEDS_ACTUAL_ME_OFFSET(); error CONVERSATION_WILL_CAUSE_POOL_TO_GO_OUT_OF_RANGE(); error REQUEST_IS_NOT_WITHIN_ACCEPTED_RANGE(); error REWARD_WITHDRAWAL_TYPE_C_ERROR(string); error ACTION_WOULD_TAKE_POOL_REWARDS_BELOW_CONVERSATION_LIMIT(); error LIQUIDITY_IS_CURRENTLY_BELOW_CONVERSATION_LIMIT(); error LIQUIDITY_RATIO_DURING_RESET_OF_OPTIMAL_RATIO_CANNOT_BE_GREATER_THAN_THE_OPTIMAL_RATIO(); error REQESTOR_IS_NOT_THE_OWNER_OF_THIS_POSITION(); error CANNOT_WITHDRAW_ZERO_ASSET_FROM_POOL(); error INSUFFICENT_POSITION_BALANCE(); error ACCOUNT_IS_ALREADY_POOL_MANAGER(); error ACCOUNT_IS_NOT_A_POOL_MANAGER(); error BOUNTY_DEPOSIT_NOT_RECOGNIZED(); error REWARD_IS_NOT_BOUNTY_REWARD(); error INSUFFICIENT_BOUNTY_REWARD(); error BRAND_DOES_NOT_EXIST(); error BRAND_ALREADY_EXISTS(); error REWARD_DOES_NOT_EXIST(); error REWARD_ALREADY_EXISTS(); error REWARD_ALREADY_OPEN(); error REWARD_IS_NOT_OPEN(); error ACCOUNT_IS_NOT_TIED_TO_ANY_BRAND(); error REQUESTOR_IS_NOT_REWARD_ISSUER(); error REWARD_DOES_NOT_SUPPORT_BOUNTIES(); error REWARD_ALREADY_SUPPORT_BOUNTIES(); error INSUFFICIENT_BOUNTY_REWARD_BALANCE(); error INSUFFICIENT_TREASURY_REWARD_BALANCE(); error INSUFFICIENT_BRAND_ME_TREASURY_BALANCE(); error ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST(); error ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_BOUNTY_REQUEST(); error ACCOUNT_ALREADY_HAS_ACCESS(); error REQUESTOR_IS_NOT_ADMIN_FOR_THIS_ACCESS_KEY(); error ACCESS_KEY_ALREADY_EXISTS_PLEASE_CHANGE_INSTEAD(); error ACCOUNT_DOES_NOT_HAVE_ACCESS(); error REWARDS_TRANSFER_FAILED(); error REWARDS_PERMIT_FAILED(); error BOUNTY_POOL_IS_CURRENTLY_BUSY(); error BOTH_DEPOSITS_CAN_NOT_BE_ZERO(); error TREASURY_DEPOSIT_NOT_RECOGNIZED(); error BRAND_ID_CANNOT_BE_EMPTY(); error BOTH_WITHDRAWALS_CANNOT_BE_ZERO(); error INSUFFICIENT_TREASURY_ME_BALANCE(); error TREASURY_IS_CURRENTLY_BUSY(); error BOTH_TOP_UPS_CANNOT_BE_ZERO(); error SEEDS_ARE_TOO_MUCH(); error INCOHERENT_TARGET_AND_SEED_LENGTH(); error PLEASE_READ_TERMS_AND_CONDITIONS(); error REWARD_NAME_CANNOT_BE_EMPTY(); error REWARD_SYMBOL_CANNOT_BE_EMPTY(); error ACCOUNT_IS_NOT_REGISTERED_AS_A_BRAND(); error INVALID_POSITION(); error INSUFFICIENT_REWARD_POSITION(); error INSUFFICIENT_ME_POSITION(); error REQUESTOR_IS_NOT_OWNER_OF_POSITION(); error CONVERSATION_WILL_CAUSE_OPEN_REWARDS_TO_GO_OUT_OF_RANGE(); error ACTION_WILL_TAKE_POOL_ME_TOKENS_BELOW_CONVERSATION_LIMIT(); error INSUFFICENT_REWARD_AMOUNT_DEPOSITED_FOR_CONVERSATION(); error R_OPTIMAL_CANNOT_BE_ZERO(); error REQUESTOR_HAS_NO_POSITION(); error POSITIONS_ARE_MORE_THAN_TWENTY_TRY_GETTING_THEM_ONE_AT_A_TIME(); error REQUEST_NOT_WITHIN_SLIPPAGE_RANGE(); error POOL_IS_BUSY(); error INVALID_POSITION_INDEX(); error REQUESTOR_DOES_NOT_IMPLEMENT_OPEN_REWARDS(); error CONVERSATION_FAILED(); error NOT_OPEN_REWARDS_CONVERSATION(); error INSUFFICIENT_DEPOSIT(); error INSUFFICIENT_REWARD(); error ALREADY_INITIALIZED(); error REWARDS_APPROVAL_FAILED(); error ACCOUNT_IS_ALREADY_REGISTERED_AS_A_BRAND(); error NOT_AUTHORIZED_TO_MANAGER_RUNTIME(); error BATCH_PROOF_ALREADY_SET(); error VAULT_SIGNATURE_USED(); error VAULT_INVALID_SIGNATURE(); error VAULT_INVALID_ALLOWEE(); error SIGNER_IS_NOT_RUNTIME(); error VAULT_INVALID_HASH(); error BRAND_ID_IS_ALREADY_TAKEN(); error PERMIT_DEADLINE_EXPIRED(); error ME_AMOUNT_CAN_NOT_BE_EQUAL_TO_PERMIT_AMOUNT(); error VAULT_EXPIRED_SIGNATURE(); error INVALID_INPUT(); error OPEN_REWARDS_ALREADY_INITIALIZED(); // Main (diamonds) errors string public constant CALLER_IS_NOT_CONTRACT_OWNER = "1"; string public constant INCORRECT_UPGRADE_ACTION = "2"; string public constant NO_SELECTOR_IN_SPECIFIED_MODULE = "3"; string public constant ZERO_ADDRESS_NOT_ALLOWED = "4"; string public constant MODULE_ALREADY_EXISTS = "5"; string public constant MODULE_IS_SAME_AS_THAT_TO_BE_REPLACED = "6"; string public constant REMOVE_MODULE_ADDRESS_MUST_BE_ZERO_ADDRESS = "7"; string public constant SERVICE_OR_PROVIDER_DOES_NOT_EXIST = "8"; string public constant CAN_NOT_REMOVE_THIS_SERVICE_OR_PROVIDER = "9"; string public constant INIT_ADDRESS_HAS_NO_CODE = "10"; string public constant MODULE_DOES_NOT_EXIST = "11"; string public constant DELEGATE_CALL_NOT_ALLOWED = "12"; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Errors} from "./errors.sol"; library Validator { function ensureAddressIsNotZeroAddress(address _addr) internal pure { if (_addr == address(0)) { revert Errors.ADDRESS_ZERO_NOT_ALLOWED(); } } function ensureValueIsNotZero(uint256 _value) internal pure { if (_value == 0) { revert Errors.ZERO_NOT_ALLOWED(); } } function ensureInputIsNotEmpty(string memory _stringOpt) internal pure { if (bytes(_stringOpt).length == 0) { revert Errors.EMPTY_STRING_NOT_ALLOWED(); } } function ensureReasonIsNotEmpty(bytes32 input) internal pure { if (input == bytes32(0)) revert Errors.EMPTY_REASON_NOT_ALLOWED(); } function ensureBrandIdIsNotEmpty(bytes10 brandId) internal pure { if (brandId == bytes10(0)) { revert Errors.BRAND_ID_CANNOT_BE_EMPTY(); } } function ensureRIsWithinAcceptableRange(uint256 r, uint256 rMaxLimit) internal pure { if (r > rMaxLimit) { revert Errors.CONVERSATION_WILL_CAUSE_POOL_TO_GO_OUT_OF_RANGE(); } } function isEmpty(string memory _data) internal pure returns (bool) { return bytes(_data).length == 0; } function isEmpty(bytes10 brandId) internal pure returns (bool) { return brandId == bytes10(0); } function isEmptyB(bytes32 brandId) internal pure returns (bool) { return brandId == bytes32(0); } function isEmpty(uint256[] memory myArray) internal pure returns (bool) { return myArray.length == 0; } function isZero(uint256 _data) internal pure returns (bool) { return _data == 0; } function isFalse(bool _data) internal pure returns (bool) { return _data == false; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; library Constants { uint256 constant PRECISION = 1000000; uint256 constant GOLDEN_RATIO_IN_PRECISION = (1618 * PRECISION) / 100; uint256 constant EXCHANGE_SLOPE = GOLDEN_RATIO_IN_PRECISION / 2; uint256 constant STARTING_SEED = 1; uint256 constant EMPTY_POSITION = 0; bytes10 constant DEFAULT_BRAND_ID = bytes10(0); bytes32 constant EMPTY_ACCESS_KEY = bytes32(0); bytes32 constant CAI = keccak256("customer acquisition incentives"); bytes32 constant PROTOCOL_FEES = keccak256("protocol fees"); bytes32 constant GAS_COSTS = keccak256("gas costs"); uint256 constant PERCENTAGE = 100; bytes32 constant NORMAL = keccak256("normal"); bytes32 constant WITH_REWARDS_IF_NEED_BE = keccak256("with rewards"); bytes32 constant WITHDRAWABLE = keccak256("withdrawable"); bytes32 constant FORCED = keccak256("forced"); string constant ME_PROTOCOL = "me protocol"; string constant ME_P = "MeP"; bytes4 constant OPEN_REWARDS = bytes4(keccak256("openrewards secret")); uint8 constant FUNGIBLE_TYPE_A = 1; string constant EMPTY_STRING = ""; uint256 constant EMPTY_AMOUNT = 0; address constant ME_DISPENSER = 0x1111111111111111111111111111111111111111; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; interface FungibleController { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); event Transfer(address indexed from, address indexed to, 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); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; library Params { ///Brands struct EditableBrandDetails { string name; string onlinePresence; } struct EditableBrandConfig { bool enableBountyRewards; bool enableCais; bool payIncomingGasFees; bool payOutgoingGasFees; } ///Rewards struct EditableRewardDetails { string name; string symbol; string descriptionLink; } struct EditableRewardConfig { bool specificException; bool bountyEnables; bool caiEnabled; uint256 bountyTriggerLimit; uint256 bountyContributionInPrecision; bool payIncomingGasFee; bool payOutgoingGasFee; } //Protocol struct EditableProtocolConfig { uint256 defaultMinimumMeForConversation; uint256 defaultMinimumRewardForConversationInPercent; uint256 defaultMaximumRLimitForConversationInPrecision; uint256 defaultRewardNotifyThresholdInPercent; uint256 defaultNotifyMeAmount; uint256 defaultNotifyRewardAmountInPercent; uint256 caiInMe; uint256 protocolFee; uint256 bountyContributionInPrecision; uint256 conversationSlippageInPrecision; uint256 informationSlippageInPrecision; } struct EditableProtocolRecords { address meId; address bountyId; address treasuryId; address vaultId; bytes10 adminId; } ///Treasury struct EditableTreasuryRecords { address meId; uint256 meNofityLimit; } ///Pool struct ConfigForTypeAOpenRewards { uint256 rOptimal; uint256 maximumRLimit; uint256 minimumRewardAmountForConversation; uint256 minimumMeAmountForConversation; uint256 notifyRewardAmount; uint256 notifyMeAmount; uint256 defaultSlippageInPrecision; bool allowSwaps; } struct EditableConfigForTypeAOpenRewards { uint256 maximumRLimit; uint256 minimumRewardAmountForConversation; uint256 minimumMeAmountForConversation; uint256 notifyRewardAmount; uint256 notifyMeAmount; uint256 defaultSlippageInPrecision; bool allowSwaps; } struct CurrentStateOfTypeAOpenRewards { bool started; bool active; address initiator; address reward; address meToken; uint256 lastRewardAmount; uint256 lastMeAmount; uint256 meTokensFromProtocolTeam; uint256 setupMeAmount; uint40 lastTransactionTime; } struct LiquidityInfo { uint256 position; uint256 rewardAmount; uint256 meAmount; address requestor; address to; } struct ExtendedLiquidityInfo { uint256 rewardAmount; uint256 meAmount; uint256 currentRewardAmount; uint256 currentMeAmount; uint256 minimumRewardAmountForConversation; uint256 minimumMeAmountForConversation; uint256 meTokensFromProtocolTeam; uint256 rOptimal; } struct OutgoingConversationInfo { uint256 rewardAmountIn; uint256 expectedAmountOfOutputReward; address listener; uint256 listenerROptimal; address requestor; address outputRewardReceiver; } struct spendingInfo { address rewardAtHand; address targettedReward; uint256 amountOfRewardAtHand; uint256 expectedAmountOfTargetedReward; } struct PermitParam { uint256 _deadline; uint8 _v; bytes32 _r; bytes32 _s; } struct VaultPermitParams { address owner; address spender; address reward; uint256 value; uint256 count; bytes32 prefixedHash; bytes32 globalHash; uint8 v; bytes32 r; bytes32 s; } struct InitialSupplyParams { address vaultAddress; address treasuryAddress; uint256 initialSupplyVaultAmount; uint256 initialSupplyTreasuryAmount; } struct InitialSupplyGenericParams { uint256 amountOne; uint256 amountTwo; address recipientOne; address recipientTwo; } struct TreasuryPermitParams { address owner; // brand address spender; // reward uint256 value; uint256 deadline; uint8 v; bytes32 r; bytes32 s; } struct RoleParams { bytes32 role; address account; } struct InitiateConversationReturnType { uint256 currentAmountOfMeTokensrewardOne; uint256 currentAmountOfRewardTokensrewardOne; uint256 notifyRewardAmountrewardOne; uint256 notifyMeTokenAmountrewardOne; uint256 currentAmountOfMeTokensRewardTwo; uint256 currentAmountOfRewardTokensRewardTwo; uint256 notifyRewardAmountRewardTwo; uint256 notifyMeTokenAmountRewardTwo; uint256 outputRewardsAmount; uint256 currentDepositNonceRewardOne; uint256 currentDepositNonceRewardTwo; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Errors} from "./errors.sol"; import {Validator} from "./validators.sol"; import {Params} from "./params.sol"; import {Constants} from "./constants.sol"; import {RoleGuard, Roles} from "./roleguard.sol"; library Database { bytes32 constant MAIN_STORAGE_POSITION = keccak256("me.protocol.pool.main.storage"); bytes32 constant BRAND_RECORDS = keccak256("me.protocol.brand.records"); bytes32 constant REWARD_RECORDS = keccak256("me.protocol.rewards.records"); bytes32 constant BOUNTY_RECORDS = keccak256("me.protocol.bounty.records"); bytes32 constant PROTOCOL_RECORDS = keccak256("me.protocol.protocol.records"); bytes32 constant PROTOCOL_CONFIGS = keccak256("me.protocol.protocol.configs"); bytes32 constant CONTEXT_RECORD = keccak256("me.protocol.protocol.context"); bytes32 constant TREASURY_RECORDS = keccak256("me.protocol.treasury.records"); bytes32 constant ACCESS_RECORDS = keccak256("me.protocol.access.records"); bytes32 constant VAULT_RECORDS = keccak256("me.protocol.vault.records"); bytes32 constant OPEN_REWARDS_STATE_TYPE_A = keccak256("me.protocol.openrewards.state.type.a"); bytes32 constant OPEN_REWARDS_CONFIG_TYPE_A = keccak256("me.protocol.openrewards.config.type.a"); bytes32 constant OPEN_REWARDS_POSITIONS_TYPE_A = keccak256("me.protocol.openrewards.positions.type.a"); bytes32 constant RUNTIME_STORAGE_POSITION = keccak256("me.protocol.pool.runtime.storage"); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; library Positions { struct Position { mapping(uint256 => PositionMetadata) positionMetadata; uint256 lastPosition; } struct PositionMetadata { uint256 rewardPosition; uint256 mePosition; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; library Roles { // protocol based roles bytes32 internal constant PROTOCOL = keccak256("PROTOCOL"); bytes32 internal constant PROTOCOL_ADMIN = keccak256("PROTOCOL_ADMIN"); bytes32 internal constant LIQUIDITY_MANAGER = keccak256("LIQUIDITY_MANAGER"); bytes32 internal constant ONBOARDING_MANAGER = keccak256("ONBOARDING_MANAGER"); // brand based roles bytes32 internal constant BRAND = keccak256("BRAND"); bytes32 internal constant BRAND_ACCOUNT_MANAGER = keccak256("BRAND_ACCOUNT_MANAGER"); bytes32 internal constant BOUNTY_MANAGER = keccak256("BOUNTY_MANAGER"); bytes32 internal constant TREASURY_MANAGER = keccak256("TREASURY_MANAGER"); // pool based roles bytes32 internal constant OPEN_REWARDS_MANAGER = keccak256("OPEN_REWARDS_MANAGER"); // reward based roles bytes32 internal constant REWARD_MANAGER = keccak256("REWARD_MANAGER"); // auto top-up based roles bytes32 internal constant AUTO_TOP_UP_MANAGER = keccak256("AUTO_TOP_UP_MANAGER"); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {Compatible} from "./compatible.sol"; interface NonFungibleController is Compatible { function balanceOf(address owner) external view returns (uint256 balance); function ownerOf(uint256 tokenId) external view returns (address owner); function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; function safeTransferFrom(address from, address to, uint256 tokenId) external; function transferFrom(address from, address to, uint256 tokenId) external; function approve(address to, uint256 tokenId) external; function setApprovalForAll(address operator, bool approved) external; function getApproved(uint256 tokenId) external view returns (address operator); function isApprovedForAll(address owner, address operator) external view returns (bool); function totalSupply() external view returns (uint256); function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); function tokenByIndex(uint256 index) external view returns (uint256); function ensureRequestorIsPositionOwner(uint256 position, address requestor) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ 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); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; interface Compatible { function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ 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; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. 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); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ 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); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 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; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ 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); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 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; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ 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); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ 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; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } }
{ "remappings": [ "@openzeppelin/=lib/openzeppelin-contracts/", "ds-test/=lib/forge-std/lib/ds-test/src/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "@openzeppelin/=lib/openzeppelin-contracts/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "libraries": {} }
[{"inputs":[{"internalType":"address","name":"reward","type":"address"},{"internalType":"address","name":"meToken","type":"address"},{"components":[{"internalType":"uint256","name":"rOptimal","type":"uint256"},{"internalType":"uint256","name":"maximumRLimit","type":"uint256"},{"internalType":"uint256","name":"minimumRewardAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"minimumMeAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmount","type":"uint256"},{"internalType":"uint256","name":"notifyMeAmount","type":"uint256"},{"internalType":"uint256","name":"defaultSlippageInPrecision","type":"uint256"},{"internalType":"bool","name":"allowSwaps","type":"bool"}],"internalType":"struct Params.ConfigForTypeAOpenRewards","name":"config","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ACCESS_KEY_ALREADY_EXISTS_PLEASE_CHANGE_INSTEAD","type":"error"},{"inputs":[],"name":"ACCOUNT_ALREADY_HAS_ACCESS","type":"error"},{"inputs":[],"name":"ACCOUNT_DOES_NOT_HAVE_ACCESS","type":"error"},{"inputs":[],"name":"ACCOUNT_IS_NOT_AUTHORIZED_TO_MAKE_THIS_REQUEST","type":"error"},{"inputs":[],"name":"ACTION_WILL_TAKE_POOL_ME_TOKENS_BELOW_CONVERSATION_LIMIT","type":"error"},{"inputs":[],"name":"ACTION_WOULD_TAKE_POOL_REWARDS_BELOW_CONVERSATION_LIMIT","type":"error"},{"inputs":[],"name":"ADDRESS_ZERO_NOT_ALLOWED","type":"error"},{"inputs":[],"name":"BOTH_WITHDRAWALS_CANNOT_BE_ZERO","type":"error"},{"inputs":[],"name":"CONVERSATION_FAILED","type":"error"},{"inputs":[],"name":"CONVERSATION_WILL_CAUSE_OPEN_REWARDS_TO_GO_OUT_OF_RANGE","type":"error"},{"inputs":[],"name":"CONVERSATION_WILL_CAUSE_POOL_TO_GO_OUT_OF_RANGE","type":"error"},{"inputs":[],"name":"EXPECTED_PROTOCOL_ME_OFFSET_EXCEEDS_ACTUAL_ME_OFFSET","type":"error"},{"inputs":[],"name":"INSUFFICENT_REWARD_AMOUNT_DEPOSITED_FOR_CONVERSATION","type":"error"},{"inputs":[],"name":"INSUFFICIENT_ME_POSITION","type":"error"},{"inputs":[],"name":"INSUFFICIENT_REWARD_POSITION","type":"error"},{"inputs":[],"name":"INVALID_POSITION","type":"error"},{"inputs":[],"name":"INVALID_POSITION_INDEX","type":"error"},{"inputs":[],"name":"LIQUIDITY_IS_CURRENTLY_BELOW_CONVERSATION_LIMIT","type":"error"},{"inputs":[],"name":"LIQUIDITY_RATIO_DURING_RESET_OF_OPTIMAL_RATIO_CANNOT_BE_GREATER_THAN_THE_OPTIMAL_RATIO","type":"error"},{"inputs":[],"name":"MAXIMUM_REWARD_RATIO_CANNOT_BE_LESS_THAN_THE_OPTIMAL_RATIO","type":"error"},{"inputs":[],"name":"NOT_OPEN_REWARDS_CONVERSATION","type":"error"},{"inputs":[],"name":"OPEN_REWARDS_ALREADY_INITIALIZED","type":"error"},{"inputs":[],"name":"OPEN_REWARDS_ALREADY_STARTED","type":"error"},{"inputs":[],"name":"OPEN_REWARDS_IS_ACTIVE","type":"error"},{"inputs":[],"name":"OPEN_REWARDS_IS_NOT_ACTIVE","type":"error"},{"inputs":[],"name":"OPEN_REWARDS_SHOULD_START_AT_R_OPTIMAL_OR_LESS","type":"error"},{"inputs":[],"name":"OPTIMAL_REWARD_RATIO_CANNOT_BE_ZERO","type":"error"},{"inputs":[],"name":"POOL_IS_BUSY","type":"error"},{"inputs":[],"name":"POSITIONS_ARE_MORE_THAN_TWENTY_TRY_GETTING_THEM_ONE_AT_A_TIME","type":"error"},{"inputs":[],"name":"REQUESTOR_IS_NOT_ADMIN_FOR_THIS_ACCESS_KEY","type":"error"},{"inputs":[],"name":"REQUESTOR_IS_NOT_OWNER_OF_POSITION","type":"error"},{"inputs":[],"name":"REQUEST_IS_NOT_WITHIN_ACCEPTED_RANGE","type":"error"},{"inputs":[],"name":"REWARDS_TRANSFER_FAILED","type":"error"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"REWARD_WITHDRAWAL_TYPE_C_ERROR","type":"error"},{"inputs":[],"name":"R_OPTIMAL_CANNOT_BE_ZERO","type":"error"},{"inputs":[],"name":"SEEDS_ARE_TOO_MUCH","type":"error"},{"inputs":[],"name":"ZERO_NOT_ALLOWED","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"inputReward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"outputReward","type":"uint256"},{"indexed":false,"internalType":"address","name":"outputOpenRewardsId","type":"address"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"conversationMade","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"liqudityManagerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"meAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"}],"name":"liqudityWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"liqudityManager","type":"address"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"liquidityManagerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"meAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"}],"name":"liquidityProvided","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"meAmount","type":"uint256"},{"indexed":false,"internalType":"uint40","name":"timestamp","type":"uint40"}],"name":"liquidityUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"meTokensProvidedByProtocolTeam","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"meTokensRemovedByProtocolTeam","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"maximumRLimit","type":"uint256"},{"internalType":"uint256","name":"minimumRewardAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"minimumMeAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmount","type":"uint256"},{"internalType":"uint256","name":"notifyMeAmount","type":"uint256"},{"internalType":"uint256","name":"defaultSlippageInPrecision","type":"uint256"},{"internalType":"bool","name":"allowSwaps","type":"bool"}],"indexed":false,"internalType":"struct Params.EditableConfigForTypeAOpenRewards","name":"editableConfig","type":"tuple"},{"indexed":false,"internalType":"bool","name":"ignoreDefault","type":"bool"}],"name":"openRewardsConfigChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOpenRewardsManager","type":"address"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"openRewardsManagerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"openRewardsManager","type":"address"},{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"openRewardsManagerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"openRewardsPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"requestor","type":"address"}],"name":"openRewardsResumed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"requestor","type":"address"},{"indexed":false,"internalType":"uint256","name":"optimalRatioInPrecision","type":"uint256"}],"name":"openRewardsStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldRatio","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newRatio","type":"uint256"}],"name":"optimalRatioChanged","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addLiquidityManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addOpenRewardsManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"maximumRLimit","type":"uint256"},{"internalType":"uint256","name":"minimumRewardAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"minimumMeAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmount","type":"uint256"},{"internalType":"uint256","name":"notifyMeAmount","type":"uint256"},{"internalType":"uint256","name":"defaultSlippageInPrecision","type":"uint256"},{"internalType":"bool","name":"allowSwaps","type":"bool"}],"internalType":"struct Params.EditableConfigForTypeAOpenRewards","name":"editableConfig","type":"tuple"},{"internalType":"bool","name":"ignoreDefault","type":"bool"}],"name":"changeConfigExceptOptimalRatio","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newOptimalRatio","type":"uint256"}],"name":"changeOptimalRatio","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_outputRewardAmount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"engageIncomingConversation","outputs":[{"internalType":"uint256","name":"outputRewardAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"position","type":"uint256"},{"internalType":"address","name":"requestor","type":"address"}],"name":"ensureRequestorIsPositionOwner","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAllLiquidityPositionForAccount","outputs":[{"internalType":"uint256[]","name":"positions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"getIncomingConversationInsight","outputs":[{"internalType":"uint256","name":"optimalMeAmount","type":"uint256"},{"internalType":"uint256","name":"lastRewardAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLiquidityIds","outputs":[{"internalType":"address","name":"initiator","type":"address"},{"internalType":"address","name":"reward","type":"address"},{"internalType":"address","name":"meToken","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"getLiquidityPositionByIndex","outputs":[{"internalType":"uint256","name":"position","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLiquidityRatios","outputs":[{"internalType":"uint256","name":"rOptimalInPrecision","type":"uint256"},{"internalType":"uint256","name":"rlastInPrecision","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOpenRewardsConfigurations","outputs":[{"components":[{"internalType":"uint256","name":"rOptimal","type":"uint256"},{"internalType":"uint256","name":"maximumRLimit","type":"uint256"},{"internalType":"uint256","name":"minimumRewardAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"minimumMeAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmount","type":"uint256"},{"internalType":"uint256","name":"notifyMeAmount","type":"uint256"},{"internalType":"uint256","name":"defaultSlippageInPrecision","type":"uint256"},{"internalType":"bool","name":"allowSwaps","type":"bool"}],"internalType":"struct OpenRewardsData.Config","name":"config","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getOpenRewardsState","outputs":[{"components":[{"internalType":"bool","name":"initialized","type":"bool"},{"internalType":"bool","name":"started","type":"bool"},{"internalType":"bool","name":"active","type":"bool"},{"internalType":"bool","name":"busy","type":"bool"},{"internalType":"address","name":"initiator","type":"address"},{"internalType":"address","name":"reward","type":"address"},{"internalType":"address","name":"meToken","type":"address"},{"internalType":"uint256","name":"lastRewardAmount","type":"uint256"},{"internalType":"uint256","name":"lastMeAmount","type":"uint256"},{"internalType":"uint256","name":"meTokensFromProtocolTeam","type":"uint256"},{"internalType":"uint256","name":"depositNonce","type":"uint256"},{"internalType":"uint40","name":"lastTransactionTime","type":"uint40"}],"internalType":"struct OpenRewardsData.State","name":"state","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getOptimalRatio","outputs":[{"internalType":"uint256","name":"r","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"meAmount","type":"uint256"},{"internalType":"uint256","name":"slippageInPrecision","type":"uint256"}],"name":"getOutgoingConversationInsight","outputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"internalType":"uint256","name":"lastRewardAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_positionId","type":"uint256"}],"name":"getPositionData","outputs":[{"components":[{"internalType":"uint256","name":"rewardPosition","type":"uint256"},{"internalType":"uint256","name":"mePosition","type":"uint256"}],"internalType":"struct Positions.PositionMetadata","name":"data","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"reward","type":"address"},{"internalType":"address","name":"meToken","type":"address"},{"components":[{"internalType":"uint256","name":"rOptimal","type":"uint256"},{"internalType":"uint256","name":"maximumRLimit","type":"uint256"},{"internalType":"uint256","name":"minimumRewardAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"minimumMeAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmount","type":"uint256"},{"internalType":"uint256","name":"notifyMeAmount","type":"uint256"},{"internalType":"uint256","name":"defaultSlippageInPrecision","type":"uint256"},{"internalType":"bool","name":"allowSwaps","type":"bool"}],"internalType":"struct Params.ConfigForTypeAOpenRewards","name":"config","type":"tuple"}],"name":"initialize","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"rewardAmountIn","type":"uint256"},{"internalType":"uint256","name":"expectedAmountOfOutputReward","type":"uint256"},{"internalType":"address","name":"listener","type":"address"},{"internalType":"uint256","name":"listenerROptimal","type":"uint256"},{"internalType":"address","name":"requestor","type":"address"},{"internalType":"address","name":"outputRewardReceiver","type":"address"}],"internalType":"struct Params.OutgoingConversationInfo","name":"info","type":"tuple"}],"name":"initiateOutgoingConversation","outputs":[{"components":[{"internalType":"uint256","name":"currentAmountOfMeTokensrewardOne","type":"uint256"},{"internalType":"uint256","name":"currentAmountOfRewardTokensrewardOne","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmountrewardOne","type":"uint256"},{"internalType":"uint256","name":"notifyMeTokenAmountrewardOne","type":"uint256"},{"internalType":"uint256","name":"currentAmountOfMeTokensRewardTwo","type":"uint256"},{"internalType":"uint256","name":"currentAmountOfRewardTokensRewardTwo","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmountRewardTwo","type":"uint256"},{"internalType":"uint256","name":"notifyMeTokenAmountRewardTwo","type":"uint256"},{"internalType":"uint256","name":"outputRewardsAmount","type":"uint256"},{"internalType":"uint256","name":"currentDepositNonceRewardOne","type":"uint256"},{"internalType":"uint256","name":"currentDepositNonceRewardTwo","type":"uint256"}],"internalType":"struct Params.InitiateConversationReturnType","name":"conversionDigest","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"leverageIncomingConversationInsight","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"meAmount","type":"uint256"},{"internalType":"uint256","name":"slippageInPrecision","type":"uint256"}],"name":"leverageOutgoingConversationInsight","outputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseOpenRewards","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"position","type":"uint256"},{"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"internalType":"uint256","name":"meAmount","type":"uint256"},{"internalType":"address","name":"requestor","type":"address"},{"internalType":"address","name":"to","type":"address"}],"internalType":"struct Params.LiquidityInfo","name":"info","type":"tuple"}],"name":"recordLiquidityProvided","outputs":[{"internalType":"uint256","name":"position","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recordMeTokensProvidedByProtocolTeam","outputs":[{"internalType":"uint256","name":"recordedAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes32","name":"releaseType","type":"bytes32"}],"name":"releaseMeTokensProvidedByProtocolTeam","outputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"internalType":"uint256","name":"meAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeLiquidityManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeOpenRewardsManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resumeOpenRewards","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setBusy","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"rOptimal","type":"uint256"},{"internalType":"uint256","name":"maximumRLimit","type":"uint256"},{"internalType":"uint256","name":"minimumRewardAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"minimumMeAmountForConversation","type":"uint256"},{"internalType":"uint256","name":"notifyRewardAmount","type":"uint256"},{"internalType":"uint256","name":"notifyMeAmount","type":"uint256"},{"internalType":"uint256","name":"defaultSlippageInPrecision","type":"uint256"},{"internalType":"bool","name":"allowSwaps","type":"bool"}],"internalType":"struct Params.ConfigForTypeAOpenRewards","name":"_config","type":"tuple"}],"name":"setUpConfig","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startOpenRewards","outputs":[{"internalType":"uint256","name":"optimalRatioInPrecision","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"position","type":"uint256"},{"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"internalType":"uint256","name":"meAmount","type":"uint256"},{"internalType":"address","name":"requestor","type":"address"},{"internalType":"address","name":"to","type":"address"}],"internalType":"struct Params.LiquidityInfo","name":"info","type":"tuple"}],"name":"withdrawLiquidity","outputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"internalType":"uint256","name":"meAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000005c919bcdda25447c168c87252326a43c709ecdbd00000000000000000000000047dfb1d5aa71466685f33d918666d534821083a50000000000000000000000000000000000000000000000000000000000186a00000000000000000000000000000000000000000000000000000000000019f0a00000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004c4b400000000000000000000000000000000000000000000000000000000000000001
-----Decoded View---------------
Arg [0] : reward (address): 0x5c919BCddA25447C168C87252326A43C709ECdBD
Arg [1] : meToken (address): 0x47DfB1D5AA71466685F33D918666D534821083A5
Arg [2] : config (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 0000000000000000000000005c919bcdda25447c168c87252326a43c709ecdbd
Arg [1] : 00000000000000000000000047dfb1d5aa71466685f33d918666d534821083a5
Arg [2] : 0000000000000000000000000000000000000000000000000000000000186a00
Arg [3] : 000000000000000000000000000000000000000000000000000000000019f0a0
Arg [4] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [5] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [8] : 00000000000000000000000000000000000000000000000000000000004c4b40
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000001
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.