Overview
S Balance
0 SS Value
-More Info
Private Name Tags
ContractCreator
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
Latest 1 internal transaction
| Parent Transaction Hash | Block | From | To | |||
|---|---|---|---|---|---|---|
| 1355259 | 8 days ago | Contract Creation | 0 S |
Loading...
Loading
Contract Name:
AlgebraCommunityVault
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/** *Submitted for verification at SonicScan.org on 2024-12-26 */ // Sources flattened with hardhat v2.19.5 https://hardhat.org // SPDX-License-Identifier: BUSL-1.1 AND GPL-2.0-or-later AND MIT pragma abicoder v2; // File @openzeppelin/contracts/utils/[email protected] // Original license: 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; } } // File @openzeppelin/contracts/access/[email protected] // Original license: SPDX_License_Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/access/[email protected] // Original license: SPDX_License_Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership} and {acceptOwnership}. * * This module is used through inheritance. It will make available all functions * from parent (Ownable). */ abstract contract Ownable2Step is Ownable { address private _pendingOwner; event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner); /** * @dev Returns the address of the pending owner. */ function pendingOwner() public view virtual returns (address) { return _pendingOwner; } /** * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override onlyOwner { _pendingOwner = newOwner; emit OwnershipTransferStarted(owner(), newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner. * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual override { delete _pendingOwner; super._transferOwnership(newOwner); } /** * @dev The new owner accepts the ownership transfer. */ function acceptOwnership() public virtual { address sender = _msgSender(); require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner"); _transferOwnership(sender); } } // File contracts/interfaces/plugin/IAlgebraPluginFactory.sol // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.5.0; /// @title An interface for a contract that is capable of deploying Algebra plugins /// @dev Such a factory is needed if the plugin should be automatically created and connected to each new pool interface IAlgebraPluginFactory { /// @notice Deploys new plugin contract for pool /// @param pool The address of the pool for which the new plugin will be created /// @param token0 First token of the pool /// @param token1 Second token of the pool /// @return New plugin address function createPlugin(address pool, address token0, address token1) external returns (address); } // File contracts/interfaces/vault/IAlgebraVaultFactory.sol // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.5.0; /// @title The interface for the Algebra Vault Factory /// @notice This contract can be used for automatic vaults creation /// @dev Version: Algebra Integral interface IAlgebraVaultFactory { /// @notice returns address of the community fee vault for the pool /// @param pool the address of Algebra Integral pool /// @return communityFeeVault the address of community fee vault function getVaultForPool(address pool) external view returns (address communityFeeVault); /// @notice creates the community fee vault for the pool if needed /// @param pool the address of Algebra Integral pool /// @return communityFeeVault the address of community fee vault function createVaultForPool(address pool) external returns (address communityFeeVault); } // File contracts/interfaces/IAlgebraFactory.sol // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.5.0; // Original pragma directive: pragma abicoder v2 /// @title The interface for the Algebra Factory /// @dev Credit to Uniswap Labs under GPL-2.0-or-later license: /// https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces interface IAlgebraFactory { /// @notice Emitted when a process of ownership renounce is started /// @param timestamp The timestamp of event /// @param finishTimestamp The timestamp when ownership renounce will be possible to finish event RenounceOwnershipStart(uint256 timestamp, uint256 finishTimestamp); /// @notice Emitted when a process of ownership renounce cancelled /// @param timestamp The timestamp of event event RenounceOwnershipStop(uint256 timestamp); /// @notice Emitted when a process of ownership renounce finished /// @param timestamp The timestamp of ownership renouncement event RenounceOwnershipFinish(uint256 timestamp); /// @notice Emitted when a pool is created /// @param token0 The first token of the pool by address sort order /// @param token1 The second token of the pool by address sort order /// @param pool The address of the created pool event Pool(address indexed token0, address indexed token1, address pool); /// @notice Emitted when the default community fee is changed /// @param newDefaultCommunityFee The new default community fee value event DefaultCommunityFee(uint16 newDefaultCommunityFee); /// @notice Emitted when the default tickspacing is changed /// @param newDefaultTickspacing The new default tickspacing value event DefaultTickspacing(int24 newDefaultTickspacing); /// @notice Emitted when the default fee is changed /// @param newDefaultFee The new default fee value event DefaultFee(uint16 newDefaultFee); /// @notice Emitted when the defaultPluginFactory address is changed /// @param defaultPluginFactoryAddress The new defaultPluginFactory address event DefaultPluginFactory(address defaultPluginFactoryAddress); /// @notice Emitted when the vaultFactory address is changed /// @param newVaultFactory The new vaultFactory address event VaultFactory(address newVaultFactory); /// @notice role that can change communityFee and tickspacing in pools /// @return The hash corresponding to this role function POOLS_ADMINISTRATOR_ROLE() external view returns (bytes32); /// @notice Returns `true` if `account` has been granted `role` or `account` is owner. /// @param role The hash corresponding to the role /// @param account The address for which the role is checked /// @return bool Whether the address has this role or the owner role or not function hasRoleOrOwner(bytes32 role, address account) external view returns (bool); /// @notice Returns the current owner of the factory /// @dev Can be changed by the current owner via transferOwnership(address newOwner) /// @return The address of the factory owner function owner() external view returns (address); /// @notice Returns the current poolDeployerAddress /// @return The address of the poolDeployer function poolDeployer() external view returns (address); /// @notice Returns the default community fee /// @return Fee which will be set at the creation of the pool function defaultCommunityFee() external view returns (uint16); /// @notice Returns the default fee /// @return Fee which will be set at the creation of the pool function defaultFee() external view returns (uint16); /// @notice Returns the default tickspacing /// @return Tickspacing which will be set at the creation of the pool function defaultTickspacing() external view returns (int24); /// @notice Return the current pluginFactory address /// @dev This contract is used to automatically set a plugin address in new liquidity pools /// @return Algebra plugin factory function defaultPluginFactory() external view returns (IAlgebraPluginFactory); /// @notice Return the current vaultFactory address /// @dev This contract is used to automatically set a vault address in new liquidity pools /// @return Algebra vault factory function vaultFactory() external view returns (IAlgebraVaultFactory); /// @notice Returns the default communityFee, tickspacing, fee and communityFeeVault for pool /// @param pool the address of liquidity pool /// @return communityFee which will be set at the creation of the pool /// @return tickSpacing which will be set at the creation of the pool /// @return fee which will be set at the creation of the pool /// @return communityFeeVault the address of communityFeeVault function defaultConfigurationForPool( address pool ) external view returns (uint16 communityFee, int24 tickSpacing, uint16 fee, address communityFeeVault); /// @notice Deterministically computes the pool address given the token0 and token1 /// @dev The method does not check if such a pool has been created /// @param token0 first token /// @param token1 second token /// @return pool The contract address of the Algebra pool function computePoolAddress(address token0, address token1) external view returns (address pool); /// @notice Returns the pool address for a given pair of tokens, or address 0 if it does not exist /// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order /// @param tokenA The contract address of either token0 or token1 /// @param tokenB The contract address of the other token /// @return pool The pool address function poolByPair(address tokenA, address tokenB) external view returns (address pool); /// @notice returns keccak256 of AlgebraPool init bytecode. /// @dev the hash value changes with any change in the pool bytecode /// @return Keccak256 hash of AlgebraPool contract init bytecode function POOL_INIT_CODE_HASH() external view returns (bytes32); /// @return timestamp The timestamp of the beginning of the renounceOwnership process function renounceOwnershipStartTimestamp() external view returns (uint256 timestamp); /// @notice Creates a pool for the given two tokens /// @param tokenA One of the two tokens in the desired pool /// @param tokenB The other of the two tokens in the desired pool /// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. /// The call will revert if the pool already exists or the token arguments are invalid. /// @return pool The address of the newly created pool function createPool(address tokenA, address tokenB) external returns (address pool); /// @dev updates default community fee for new pools /// @param newDefaultCommunityFee The new community fee, _must_ be <= MAX_COMMUNITY_FEE function setDefaultCommunityFee(uint16 newDefaultCommunityFee) external; /// @dev updates default fee for new pools /// @param newDefaultFee The new fee, _must_ be <= MAX_DEFAULT_FEE function setDefaultFee(uint16 newDefaultFee) external; /// @dev updates default tickspacing for new pools /// @param newDefaultTickspacing The new tickspacing, _must_ be <= MAX_TICK_SPACING and >= MIN_TICK_SPACING function setDefaultTickspacing(int24 newDefaultTickspacing) external; /// @dev updates pluginFactory address /// @param newDefaultPluginFactory address of new plugin factory function setDefaultPluginFactory(address newDefaultPluginFactory) external; /// @dev updates vaultFactory address /// @param newVaultFactory address of new vault factory function setVaultFactory(address newVaultFactory) external; /// @notice Starts process of renounceOwnership. After that, a certain period /// of time must pass before the ownership renounce can be completed. function startRenounceOwnership() external; /// @notice Stops process of renounceOwnership and removes timer. function stopRenounceOwnership() external; } // File contracts/interfaces/vault/IAlgebraCommunityVault.sol // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.5.0; /// @title The interface for the Algebra community fee vault /// @notice Community fee from pools is sent here, if it is enabled /// @dev Version: Algebra Integral interface IAlgebraCommunityVault { /// @notice Event emitted when a fees has been claimed /// @param token The address of token fee /// @param to The address where claimed rewards were sent to /// @param amount The amount of fees tokens claimed by communityFeeReceiver event TokensWithdrawal(address indexed token, address indexed to, uint256 amount); /// @notice Event emitted when a fees has been claimed /// @param token The address of token fee /// @param to The address where claimed rewards were sent to /// @param amount The amount of fees tokens claimed by Algebra event AlgebraTokensWithdrawal(address indexed token, address indexed to, uint256 amount); /// @notice Emitted when a AlgebraFeeReceiver address changed /// @param newAlgebraFeeReceiver New Algebra fee receiver address event AlgebraFeeReceiver(address newAlgebraFeeReceiver); /// @notice Emitted when a AlgebraFeeManager address change proposed /// @param pendingAlgebraFeeManager New pending Algebra fee manager address event PendingAlgebraFeeManager(address pendingAlgebraFeeManager); /// @notice Emitted when a new Algebra fee value proposed /// @param proposedNewAlgebraFee The new proposed Algebra fee value event AlgebraFeeProposal(uint16 proposedNewAlgebraFee); /// @notice Emitted when a Algebra fee proposal canceled event CancelAlgebraFeeProposal(); /// @notice Emitted when a AlgebraFeeManager address changed /// @param newAlgebraFeeManager New Algebra fee manager address event AlgebraFeeManager(address newAlgebraFeeManager); /// @notice Emitted when the Algebra fee is changed /// @param newAlgebraFee The new Algebra fee value event AlgebraFee(uint16 newAlgebraFee); /// @notice Emitted when a CommunityFeeReceiver address changed /// @param newCommunityFeeReceiver New fee receiver address event CommunityFeeReceiver(address newCommunityFeeReceiver); /// @notice Withdraw protocol fees from vault /// @dev Can only be called by algebraFeeManager or communityFeeReceiver /// @param token The token address /// @param amount The amount of token function withdraw(address token, uint256 amount) external; struct WithdrawTokensParams { address token; uint256 amount; } /// @notice Withdraw protocol fees from vault. Used to claim fees for multiple tokens /// @dev Can be called by algebraFeeManager or communityFeeReceiver /// @param params Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw function withdrawTokens(WithdrawTokensParams[] calldata params) external; // ### algebra factory owner permissioned actions ### /// @notice Accepts the proposed new Algebra fee /// @dev Can only be called by the factory owner. /// The new value will also be used for previously accumulated tokens that have not yet been withdrawn /// @param newAlgebraFee New Algebra fee value function acceptAlgebraFeeChangeProposal(uint16 newAlgebraFee) external; /// @notice Change community fee receiver address /// @dev Can only be called by the factory owner /// @param newCommunityFeeReceiver New community fee receiver address function changeCommunityFeeReceiver(address newCommunityFeeReceiver) external; // ### algebra fee manager permissioned actions ### /// @notice Transfers Algebra fee manager role /// @param _newAlgebraFeeManager new Algebra fee manager address function transferAlgebraFeeManagerRole(address _newAlgebraFeeManager) external; /// @notice accept Algebra FeeManager role function acceptAlgebraFeeManagerRole() external; /// @notice Proposes new Algebra fee value for protocol /// @dev the new value will also be used for previously accumulated tokens that have not yet been withdrawn /// @param newAlgebraFee new Algebra fee value function proposeAlgebraFeeChange(uint16 newAlgebraFee) external; /// @notice Cancels Algebra fee change proposal function cancelAlgebraFeeChangeProposal() external; /// @notice Change Algebra community fee part receiver /// @param newAlgebraFeeReceiver The address of new Algebra fee receiver function changeAlgebraFeeReceiver(address newAlgebraFeeReceiver) external; } // File contracts/libraries/FullMath.sol // Original license: SPDX_License_Identifier: MIT pragma solidity ^0.8.0; /// @title Contains 512-bit math functions /// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision /// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits library FullMath { /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return result The 256-bit result /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = a * b // Compute the product mod 2**256 and mod 2**256 - 1 // then 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 = a * b; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(a, b, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Make sure the result is less than 2**256. // Also prevents denominator == 0 require(denominator > prod1); // Handle non-overflow cases, 256 by 256 division if (prod1 == 0) { assembly { result := div(prod0, denominator) } return result; } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0] // Compute remainder using mulmod // Subtract 256 bit remainder from 512 bit number assembly { let remainder := mulmod(a, b, denominator) prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator // Compute largest power of two divisor of denominator. // Always >= 1. uint256 twos = (0 - denominator) & denominator; // Divide denominator by power of two assembly { denominator := div(denominator, twos) } // Divide [prod1 prod0] by the factors of two assembly { prod0 := div(prod0, twos) } // Shift in bits from prod1 into prod0. For this we need // to flip `twos` such that it is 2**256 / twos. // If twos is zero, then it becomes one assembly { twos := add(div(sub(0, twos), twos), 1) } 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 // correct for four bits. That is, denominator * inv = 1 mod 2**4 uint256 inv = (3 * denominator) ^ 2; // Now use 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. inv *= 2 - denominator * inv; // inverse mod 2**8 inv *= 2 - denominator * inv; // inverse mod 2**16 inv *= 2 - denominator * inv; // inverse mod 2**32 inv *= 2 - denominator * inv; // inverse mod 2**64 inv *= 2 - denominator * inv; // inverse mod 2**128 inv *= 2 - denominator * inv; // 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 * inv; return result; } } /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return result The 256-bit result function mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) { unchecked { if (a == 0 || ((result = a * b) / a == b)) { require(denominator > 0); assembly { result := add(div(result, denominator), gt(mod(result, denominator), 0)) } } else { result = mulDiv(a, b, denominator); if (mulmod(a, b, denominator) > 0) { require(result < type(uint256).max); result++; } } } } /// @notice Returns ceil(x / y) /// @dev division by 0 has unspecified behavior, and must be checked externally /// @param x The dividend /// @param y The divisor /// @return z The quotient, ceil(x / y) function unsafeDivRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) { assembly { z := add(div(x, y), gt(mod(x, y), 0)) } } } // File contracts/interfaces/pool/IAlgebraPoolErrors.sol // Original license: SPDX_License_Identifier: GPL-2.0-or-later pragma solidity >=0.8.4; /// @title Errors emitted by a pool /// @notice Contains custom errors emitted by the pool /// @dev Custom errors are separated from the common pool interface for compatibility with older versions of Solidity interface IAlgebraPoolErrors { // #### pool errors #### /// @notice Emitted by the reentrancy guard error locked(); /// @notice Emitted if arithmetic error occurred error arithmeticError(); /// @notice Emitted if an attempt is made to initialize the pool twice error alreadyInitialized(); /// @notice Emitted if an attempt is made to mint or swap in uninitialized pool error notInitialized(); /// @notice Emitted if 0 is passed as amountRequired to swap function error zeroAmountRequired(); /// @notice Emitted if invalid amount is passed as amountRequired to swap function error invalidAmountRequired(); /// @notice Emitted if the pool received fewer tokens than it should have error insufficientInputAmount(); /// @notice Emitted if there was an attempt to mint zero liquidity error zeroLiquidityDesired(); /// @notice Emitted if actual amount of liquidity is zero (due to insufficient amount of tokens received) error zeroLiquidityActual(); /// @notice Emitted if the pool received fewer tokens0 after flash than it should have error flashInsufficientPaid0(); /// @notice Emitted if the pool received fewer tokens1 after flash than it should have error flashInsufficientPaid1(); /// @notice Emitted if limitSqrtPrice param is incorrect error invalidLimitSqrtPrice(); /// @notice Tick must be divisible by tickspacing error tickIsNotSpaced(); /// @notice Emitted if a method is called that is accessible only to the factory owner or dedicated role error notAllowed(); /// @notice Emitted if new tick spacing exceeds max allowed value error invalidNewTickSpacing(); /// @notice Emitted if new community fee exceeds max allowed value error invalidNewCommunityFee(); /// @notice Emitted if an attempt is made to manually change the fee value, but dynamic fee is enabled error dynamicFeeActive(); /// @notice Emitted if an attempt is made by plugin to change the fee value, but dynamic fee is disabled error dynamicFeeDisabled(); /// @notice Emitted if an attempt is made to change the plugin configuration, but the plugin is not connected error pluginIsNotConnected(); /// @notice Emitted if a plugin returns invalid selector after hook call /// @param expectedSelector The expected selector error invalidHookResponse(bytes4 expectedSelector); // #### LiquidityMath errors #### /// @notice Emitted if liquidity underflows error liquiditySub(); /// @notice Emitted if liquidity overflows error liquidityAdd(); // #### TickManagement errors #### /// @notice Emitted if the topTick param not greater then the bottomTick param error topTickLowerOrEqBottomTick(); /// @notice Emitted if the bottomTick param is lower than min allowed value error bottomTickLowerThanMIN(); /// @notice Emitted if the topTick param is greater than max allowed value error topTickAboveMAX(); /// @notice Emitted if the liquidity value associated with the tick exceeds MAX_LIQUIDITY_PER_TICK error liquidityOverflow(); /// @notice Emitted if an attempt is made to interact with an uninitialized tick error tickIsNotInitialized(); /// @notice Emitted if there is an attempt to insert a new tick into the list of ticks with incorrect indexes of the previous and next ticks error tickInvalidLinks(); // #### SafeTransfer errors #### /// @notice Emitted if token transfer failed internally error transferFailed(); // #### TickMath errors #### /// @notice Emitted if tick is greater than the maximum or less than the minimum allowed value error tickOutOfRange(); /// @notice Emitted if price is greater than the maximum or less than the minimum allowed value error priceOutOfRange(); } // File contracts/libraries/SafeTransfer.sol // Original license: SPDX_License_Identifier: MIT pragma solidity >=0.8.4 <0.9.0; /// @title SafeTransfer /// @notice Safe ERC20 transfer library that gracefully handles missing return values. /// @dev Credit to Solmate under MIT license: https://github.com/transmissions11/solmate/blob/ed67feda67b24fdeff8ad1032360f0ee6047ba0a/src/utils/SafeTransferLib.sol /// @dev Please note that this library does not check if the token has a code! That responsibility is delegated to the caller. library SafeTransfer { /// @notice Transfers tokens to a recipient /// @dev Calls transfer on token contract, errors with transferFailed() if transfer fails /// @param token The contract address of the token which will be transferred /// @param to The recipient of the transfer /// @param amount The amount of the token to transfer function safeTransfer(address token, address to, uint256 amount) internal { bool success; assembly { let freeMemoryPointer := mload(0x40) // we will need to restore 0x40 slot mstore(0x00, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) // "transfer(address,uint256)" selector mstore(0x04, and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // append cleaned "to" address mstore(0x24, amount) // now we use 0x00 - 0x44 bytes (68), freeMemoryPointer is dirty success := call(gas(), token, 0, 0, 0x44, 0, 0x20) success := and( // set success to true if call isn't reverted and returned exactly 1 (can't just be non-zero data) or nothing or(and(eq(mload(0), 1), eq(returndatasize(), 32)), iszero(returndatasize())), success ) mstore(0x40, freeMemoryPointer) // restore the freeMemoryPointer } if (!success) revert IAlgebraPoolErrors.transferFailed(); } } // File contracts/AlgebraCommunityVault.sol // Original license: SPDX_License_Identifier: BUSL-1.1 pragma solidity =0.8.20; /// @title Algebra community fee vault /// @notice Community fee from pools is sent here, if it is enabled /// @dev Role system is used to withdraw tokens /// @dev Version: Algebra Integral 1.0 contract AlgebraCommunityVault is IAlgebraCommunityVault { /// @dev The role can be granted in AlgebraFactory bytes32 public constant COMMUNITY_FEE_WITHDRAWER_ROLE = keccak256('COMMUNITY_FEE_WITHDRAWER'); /// @dev The role can be granted in AlgebraFactory bytes32 public constant COMMUNITY_FEE_VAULT_ADMINISTRATOR = keccak256('COMMUNITY_FEE_VAULT_ADMINISTRATOR'); address private immutable factory; /// @notice Address to which community fees are sent from vault address public communityFeeReceiver; /// @notice The percentage of the protocol fee that Algebra will receive /// @dev Value in thousandths,i.e. 1e-3 uint16 public algebraFee; /// @notice Represents whether there is a new Algebra fee proposal or not bool public hasNewAlgebraFeeProposal; /// @notice Suggested Algebra fee value uint16 public proposedNewAlgebraFee; /// @notice Address of recipient Algebra part of community fee address public algebraFeeReceiver; /// @notice Address of Algebra fee manager address public algebraFeeManager; address private _pendingAlgebraFeeManager; uint16 private constant ALGEBRA_FEE_DENOMINATOR = 1000; modifier onlyAdministrator() { require(IAlgebraFactory(factory).hasRoleOrOwner(COMMUNITY_FEE_VAULT_ADMINISTRATOR, msg.sender), 'only administrator'); _; } modifier onlyWithdrawer() { require(msg.sender == algebraFeeManager || IAlgebraFactory(factory).hasRoleOrOwner(COMMUNITY_FEE_WITHDRAWER_ROLE, msg.sender), 'only withdrawer'); _; } modifier onlyAlgebraFeeManager() { require(msg.sender == algebraFeeManager, 'only algebra fee manager'); _; } constructor(address _factory, address _algebraFeeManager) { (factory, algebraFeeManager) = (_factory, _algebraFeeManager); } /// @inheritdoc IAlgebraCommunityVault function withdraw(address token, uint256 amount) external override onlyWithdrawer { (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) = _readAndVerifyWithdrawSettings(); _withdraw(token, _communityFeeReceiver, amount, _algebraFee, _algebraFeeReceiver); } /// @inheritdoc IAlgebraCommunityVault function withdrawTokens(WithdrawTokensParams[] calldata params) external override onlyWithdrawer { uint256 paramsLength = params.length; (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) = _readAndVerifyWithdrawSettings(); unchecked { for (uint256 i; i < paramsLength; ++i) _withdraw(params[i].token, _communityFeeReceiver, params[i].amount, _algebraFee, _algebraFeeReceiver); } } function _readAndVerifyWithdrawSettings() private view returns (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) { (_algebraFee, _algebraFeeReceiver, _communityFeeReceiver) = (algebraFee, algebraFeeReceiver, communityFeeReceiver); if (_algebraFee != 0) require(_algebraFeeReceiver != address(0), 'invalid algebra fee receiver'); require(_communityFeeReceiver != address(0), 'invalid receiver'); } function _withdraw(address token, address to, uint256 amount, uint16 _algebraFee, address _algebraFeeReceiver) private { uint256 withdrawAmount = amount; if (_algebraFee != 0) { uint256 algebraFeeAmount = FullMath.mulDivRoundingUp(withdrawAmount, _algebraFee, ALGEBRA_FEE_DENOMINATOR); withdrawAmount -= algebraFeeAmount; SafeTransfer.safeTransfer(token, _algebraFeeReceiver, algebraFeeAmount); emit AlgebraTokensWithdrawal(token, _algebraFeeReceiver, algebraFeeAmount); } SafeTransfer.safeTransfer(token, to, withdrawAmount); emit TokensWithdrawal(token, to, withdrawAmount); } // ### algebra factory owner permissioned actions ### /// @inheritdoc IAlgebraCommunityVault function acceptAlgebraFeeChangeProposal(uint16 newAlgebraFee) external override onlyAdministrator { require(hasNewAlgebraFeeProposal, 'not proposed'); require(newAlgebraFee == proposedNewAlgebraFee, 'invalid new fee'); // note that the new value will be used for previously accumulated tokens that have not yet been withdrawn algebraFee = newAlgebraFee; (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (0, false); emit AlgebraFee(newAlgebraFee); } /// @inheritdoc IAlgebraCommunityVault function changeCommunityFeeReceiver(address newCommunityFeeReceiver) external override onlyAdministrator { require(newCommunityFeeReceiver != address(0)); require(newCommunityFeeReceiver != communityFeeReceiver); communityFeeReceiver = newCommunityFeeReceiver; emit CommunityFeeReceiver(newCommunityFeeReceiver); } // ### algebra fee manager permissioned actions ### /// @inheritdoc IAlgebraCommunityVault function transferAlgebraFeeManagerRole(address _newAlgebraFeeManager) external override onlyAlgebraFeeManager { _pendingAlgebraFeeManager = _newAlgebraFeeManager; emit PendingAlgebraFeeManager(_newAlgebraFeeManager); } /// @inheritdoc IAlgebraCommunityVault function acceptAlgebraFeeManagerRole() external override { require(msg.sender == _pendingAlgebraFeeManager); (_pendingAlgebraFeeManager, algebraFeeManager) = (address(0), msg.sender); emit AlgebraFeeManager(msg.sender); } /// @inheritdoc IAlgebraCommunityVault function proposeAlgebraFeeChange(uint16 newAlgebraFee) external override onlyAlgebraFeeManager { require(newAlgebraFee <= ALGEBRA_FEE_DENOMINATOR); require(newAlgebraFee != proposedNewAlgebraFee && newAlgebraFee != algebraFee); (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (newAlgebraFee, true); emit AlgebraFeeProposal(newAlgebraFee); } /// @inheritdoc IAlgebraCommunityVault function cancelAlgebraFeeChangeProposal() external override onlyAlgebraFeeManager { (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (0, false); emit CancelAlgebraFeeProposal(); } /// @inheritdoc IAlgebraCommunityVault function changeAlgebraFeeReceiver(address newAlgebraFeeReceiver) external override onlyAlgebraFeeManager { require(newAlgebraFeeReceiver != address(0)); require(newAlgebraFeeReceiver != algebraFeeReceiver); algebraFeeReceiver = newAlgebraFeeReceiver; emit AlgebraFeeReceiver(newAlgebraFeeReceiver); } } // File contracts/AlgebraVaultFactory.sol // Original license: SPDX_License_Identifier: BUSL-1.1 // pragma solidity =0.8.20; // Original pragma directive: pragma abicoder v1 /// @title Algebra vault factory /// @notice This contract is used to set AlgebraCommunityVault as communityVault in new pools contract AlgebraVaultFactory is IAlgebraVaultFactory, Ownable2Step { address private immutable factory; mapping(address => address) private vaultForPool; constructor(address _factory) { require(_factory != address(0)); factory = _factory; } /// @inheritdoc IAlgebraVaultFactory function getVaultForPool(address pool) external view override returns (address) { return vaultForPool[pool]; } /// @inheritdoc IAlgebraVaultFactory function createVaultForPool(address pool) external override returns (address) { require(msg.sender == factory); address vault = address(new AlgebraCommunityVault(factory, owner())); vaultForPool[pool] = vault; return vault; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_algebraFeeManager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"transferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"newAlgebraFee","type":"uint16"}],"name":"AlgebraFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newAlgebraFeeManager","type":"address"}],"name":"AlgebraFeeManager","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"proposedNewAlgebraFee","type":"uint16"}],"name":"AlgebraFeeProposal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newAlgebraFeeReceiver","type":"address"}],"name":"AlgebraFeeReceiver","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AlgebraTokensWithdrawal","type":"event"},{"anonymous":false,"inputs":[],"name":"CancelAlgebraFeeProposal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newCommunityFeeReceiver","type":"address"}],"name":"CommunityFeeReceiver","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pendingAlgebraFeeManager","type":"address"}],"name":"PendingAlgebraFeeManager","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensWithdrawal","type":"event"},{"inputs":[],"name":"COMMUNITY_FEE_VAULT_ADMINISTRATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"COMMUNITY_FEE_WITHDRAWER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"newAlgebraFee","type":"uint16"}],"name":"acceptAlgebraFeeChangeProposal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"acceptAlgebraFeeManagerRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"algebraFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"algebraFeeManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"algebraFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelAlgebraFeeChangeProposal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAlgebraFeeReceiver","type":"address"}],"name":"changeAlgebraFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newCommunityFeeReceiver","type":"address"}],"name":"changeCommunityFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"communityFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasNewAlgebraFeeProposal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"newAlgebraFee","type":"uint16"}],"name":"proposeAlgebraFeeChange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proposedNewAlgebraFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newAlgebraFeeManager","type":"address"}],"name":"transferAlgebraFeeManagerRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IAlgebraCommunityVault.WithdrawTokensParams[]","name":"params","type":"tuple[]"}],"name":"withdrawTokens","outputs":[],"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)
0000000000000000000000005fb88ceea225109add778f83196fb57ba2fb54bc0000000000000000000000004d5bcfc14282d930ee09bee96d3a7d5f338251c6
-----Decoded View---------------
Arg [0] : _factory (address): 0x5fb88CeEA225109aDd778F83196fb57bA2Fb54BC
Arg [1] : _algebraFeeManager (address): 0x4D5bCfc14282d930eE09bee96D3a7D5F338251C6
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005fb88ceea225109add778f83196fb57ba2fb54bc
Arg [1] : 0000000000000000000000004d5bcfc14282d930ee09bee96d3a7d5f338251c6
Deployed Bytecode Sourcemap
32301:6365:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32417:93;;32473:37;32417:93;;;;;160:25:1;;;148:2;133:18;32417:93:0;;;;;;;;32787:35;;;;;-1:-1:-1;;;;;32787:35:0;;;;;;-1:-1:-1;;;;;360:55:1;;;342:74;;330:2;315:18;32787:35:0;196:226:1;33242:33:0;;;;;-1:-1:-1;;;;;33242:33:0;;;38340:323;;;;;;:::i;:::-;;:::i;:::-;;37116:231;;;;;;:::i;:::-;;:::i;33136:35::-;;;;;-1:-1:-1;;;33136:35:0;;;;;;;;;993:6:1;981:19;;;963:38;;951:2;936:18;33136:35:0;819:188:1;33326:32:0;;;;;-1:-1:-1;;;;;33326:32:0;;;32946:24;;;;;-1:-1:-1;;;32946:24:0;;;;;;37395:239;;;:::i;36674:337::-;;;;;;:::i;:::-;;:::i;32569:106::-;;32629:46;32569:106;;33052:36;;;;;-1:-1:-1;;;33052:36:0;;;;;;;;;1177:14:1;;1170:22;1152:41;;1140:2;1125:18;33052:36:0;1012:187:1;38097:195:0;;;:::i;37682:367::-;;;;;;:::i;:::-;;:::i;34497:443::-;;;;;;:::i;:::-;;:::i;34151:298::-;;;;;;:::i;:::-;;:::i;36140:486::-;;;;;;:::i;:::-;;:::i;38340:323::-;33905:17;;-1:-1:-1;;;;;33905:17:0;33891:10;:31;33883:68;;;;-1:-1:-1;;;33883:68:0;;2601:2:1;33883:68:0;;;2583:21:1;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;33883:68:0;;;;;;;;;-1:-1:-1;;;;;38460:35:0;::::1;38452:44;;;::::0;::::1;;38536:18;::::0;-1:-1:-1;;;;;38536:18:0;;::::1;38511:43:::0;;::::1;::::0;38503:52:::1;;;::::0;::::1;;38562:18;:42:::0;;-1:-1:-1;;;;;;38562:42:0::1;-1:-1:-1::0;;;;;38562:42:0;::::1;::::0;;::::1;::::0;;;38616:41:::1;::::0;342:74:1;;;38616:41:0::1;::::0;330:2:1;315:18;38616:41:0::1;;;;;;;;38340:323:::0;:::o;37116:231::-;33905:17;;-1:-1:-1;;;;;33905:17:0;33891:10;:31;33883:68;;;;-1:-1:-1;;;33883:68:0;;2601:2:1;33883:68:0;;;2583:21:1;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;33883:68:0;2399:348:1;33883:68:0;37233:25:::1;:49:::0;;-1:-1:-1;;;;;;37233:49:0::1;-1:-1:-1::0;;;;;37233:49:0;::::1;::::0;;::::1;::::0;;;37294:47:::1;::::0;342:74:1;;;37294:47:0::1;::::0;330:2:1;315:18;37294:47:0::1;196:226:1::0;37395:239:0;37481:25;;-1:-1:-1;;;;;37481:25:0;37467:10;:39;37459:48;;;;;;37542:17;37514:73;;37576:10;-1:-1:-1;;;;;;37514:73:0;;;;;;;;37515:25;37514:73;;;;;;;37599:29;;342:74:1;;;37599:29:0;;330:2:1;315:18;37599:29:0;;;;;;;37395:239::o;36674:337::-;33516:86;;-1:-1:-1;;;33516:86:0;;32629:46;33516:86;;;2926:25:1;33591:10:0;2967:18:1;;;2960:83;33532:7:0;-1:-1:-1;;;;;33516:39:0;;;;2899:18:1;;33516:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33508:117;;;;-1:-1:-1;;;33508:117:0;;3538:2:1;33508:117:0;;;3520:21:1;3577:2;3557:18;;;3550:30;3616:20;3596:18;;;3589:48;3654:18;;33508:117:0;3336:342:1;33508:117:0;-1:-1:-1;;;;;36794:37:0;::::1;36786:46;;;::::0;::::1;;36874:20;::::0;-1:-1:-1;;;;;36874:20:0;;::::1;36847:47:::0;;::::1;::::0;36839:56:::1;;;::::0;::::1;;36902:20;:46:::0;;-1:-1:-1;;;;;;36902:46:0::1;-1:-1:-1::0;;;;;36902:46:0;::::1;::::0;;::::1;::::0;;;36960:45:::1;::::0;342:74:1;;;36960:45:0::1;::::0;330:2:1;315:18;36960:45:0::1;196:226:1::0;38097:195:0;33905:17;;-1:-1:-1;;;;;33905:17:0;33891:10;:31;33883:68;;;;-1:-1:-1;;;33883:68:0;;2601:2:1;33883:68:0;;;2583:21:1;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;33883:68:0;2399:348:1;33883:68:0;38239:1:::1;38186:62:::0;;-1:-1:-1;;;;38186:62:0;;;38260:26:::1;::::0;::::1;::::0;38239:1;38260:26:::1;38097:195::o:0;37682:367::-;33905:17;;-1:-1:-1;;;;;33905:17:0;33891:10;:31;33883:68;;;;-1:-1:-1;;;33883:68:0;;2601:2:1;33883:68:0;;;2583:21:1;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;33883:68:0;2399:348:1;33883:68:0;33461:4:::1;37792:40;::::0;::::1;;;37784:49;;;::::0;::::1;;37865:21;::::0;::::1;37848:38:::0;;::::1;-1:-1:-1::0;;;37865:21:0;;::::1;;37848:38;::::0;::::1;::::0;:69:::1;;-1:-1:-1::0;37907:10:0::1;::::0;::::1;37890:27:::0;;::::1;-1:-1:-1::0;;;37907:10:0;;::::1;;37890:27;;37848:69;37840:78;;;::::0;::::1;;37926:21;37925:73:::0;;::::1;::::0;::::1;-1:-1:-1::0;;;37925:73:0::1;-1:-1:-1::0;;;;37925:73:0;;;;-1:-1:-1;;;37925:73:0;;;38010:33:::1;::::0;::::1;::::0;::::1;::::0;37978:13;;993:6:1;981:19;;;;963:38;;951:2;936:18;;819:188;34497:443:0;33700:17;;-1:-1:-1;;;;;33700:17:0;33686:10;:31;;:117;;-1:-1:-1;33721:82:0;;-1:-1:-1;;;33721:82:0;;32473:37;33721:82;;;2926:25:1;33792:10:0;2967:18:1;;;2960:83;33737:7:0;-1:-1:-1;;;;;33721:39:0;;;;2899:18:1;;33721:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33678:145;;;;-1:-1:-1;;;33678:145:0;;3885:2:1;33678:145:0;;;3867:21:1;3924:2;3904:18;;;3897:30;-1:-1:-1;;;3943:18:1;;;3936:45;3998:18;;33678:145:0;3683:339:1;33678:145:0;34624:6;34601:20:::1;::::0;;34727:32:::1;:30;:32::i;:::-;34644:115;;;;;;34792:9;34787:140;34807:12;34803:1;:16;34787:140;;;34826:101;34836:6;;34843:1;34836:9;;;;;;;:::i;:::-;:15;::::0;::::1;:9;::::0;;::::1;;:15:::0;;::::1;::::0;-1:-1:-1;34836:15:0::1;:::i;:::-;34853:21;34876:6;;34883:1;34876:9;;;;;;;:::i;:::-;;;;;;:16;;;34894:11;34907:19;34826:9;:101::i;:::-;34821:3;;34787:140;;;;34594:346;;;;34497:443:::0;;:::o;34151:298::-;33700:17;;-1:-1:-1;;;;;33700:17:0;33686:10;:31;;:117;;-1:-1:-1;33721:82:0;;-1:-1:-1;;;33721:82:0;;32473:37;33721:82;;;2926:25:1;33792:10:0;2967:18:1;;;2960:83;33737:7:0;-1:-1:-1;;;;;33721:39:0;;;;2899:18:1;;33721:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33678:145;;;;-1:-1:-1;;;33678:145:0;;3885:2:1;33678:145:0;;;3867:21:1;3924:2;3904:18;;;3897:30;-1:-1:-1;;;3943:18:1;;;3936:45;3998:18;;33678:145:0;3683:339:1;33678:145:0;34241:18:::1;34261:27:::0;34290:29:::1;34323:32;:30;:32::i;:::-;34240:115;;;;;;34362:81;34372:5;34379:21;34402:6;34410:11;34423:19;34362:9;:81::i;:::-;34233:216;;;34151:298:::0;;:::o;36140:486::-;33516:86;;-1:-1:-1;;;33516:86:0;;32629:46;33516:86;;;2926:25:1;33591:10:0;2967:18:1;;;2960:83;33532:7:0;-1:-1:-1;;;;;33516:39:0;;;;2899:18:1;;33516:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33508:117;;;;-1:-1:-1;;;33508:117:0;;3538:2:1;33508:117:0;;;3520:21:1;3577:2;3557:18;;;3550:30;3616:20;3596:18;;;3589:48;3654:18;;33508:117:0;3336:342:1;33508:117:0;36253:24:::1;::::0;-1:-1:-1;;;36253:24:0;::::1;;;36245:49;;;::::0;-1:-1:-1;;;36245:49:0;;4361:2:1;36245:49:0::1;::::0;::::1;4343:21:1::0;4400:2;4380:18;;;4373:30;4439:14;4419:18;;;4412:42;4471:18;;36245:49:0::1;4159:336:1::0;36245:49:0::1;36326:21;::::0;::::1;36309:38:::0;;::::1;-1:-1:-1::0;;;36326:21:0;;::::1;;36309:38;36301:66;;;::::0;-1:-1:-1;;;36301:66:0;;4702:2:1;36301:66:0::1;::::0;::::1;4684:21:1::0;4741:2;4721:18;;;4714:30;4780:17;4760:18;;;4753:45;4815:18;;36301:66:0::1;4500:339:1::0;36301:66:0::1;36488:10;:26:::0;;36521:62;;-1:-1:-1;;;36488:26:0::1;::::0;::::1;::::0;;::::1;-1:-1:-1::0;;;;36521:62:0;;;;;;;;36595:25:::1;::::0;963:38:1;;;36595:25:0::1;::::0;951:2:1;936:18;36595:25:0::1;819:188:1::0;34946:445:0;35010:18;35158:10;35170:18;;35158:10;-1:-1:-1;;;35158:10:0;;;;-1:-1:-1;;;;;35170:18:0;;;;35190:20;35222:16;;35218:96;;-1:-1:-1;;;;;35248:33:0;;35240:74;;;;-1:-1:-1;;;35240:74:0;;5046:2:1;35240:74:0;;;5028:21:1;5085:2;5065:18;;;5058:30;5124;5104:18;;;5097:58;5172:18;;35240:74:0;4844:352:1;35240:74:0;-1:-1:-1;;;;;35329:35:0;;35321:64;;;;-1:-1:-1;;;35321:64:0;;5403:2:1;35321:64:0;;;5385:21:1;5442:2;5422:18;;;5415:30;5481:18;5461;;;5454:46;5517:18;;35321:64:0;5201:340:1;35321:64:0;34946:445;;;:::o;35397:636::-;35548:6;35565:16;;;;35561:351;;35592:24;35619:79;35645:14;35619:79;;;33461:4;35619:25;:79::i;:::-;35592:106;-1:-1:-1;35707:34:0;35592:106;35707:34;;:::i;:::-;;;35750:71;35776:5;35783:19;35804:16;35750:25;:71::i;:::-;35866:19;-1:-1:-1;;;;;35835:69:0;35859:5;-1:-1:-1;;;;;35835:69:0;;35887:16;35835:69;;;;160:25:1;;148:2;133:18;;14:177;35835:69:0;;;;;;;;35583:329;35561:351;35920:52;35946:5;35953:2;35957:14;35920:25;:52::i;:::-;36008:2;-1:-1:-1;;;;;35984:43:0;36001:5;-1:-1:-1;;;;;35984:43:0;;36012:14;35984:43;;;;160:25:1;;148:2;133:18;;14:177;35984:43:0;;;;;;;;35516:517;35397:636;;;;;:::o;24973:536::-;25065:14;25111:6;;;:37;;-1:-1:-1;;25132:5:0;;;25146:1;25141;25132:5;25141:1;25122:20;;;;:::i;:::-;;:25;25111:37;25107:390;;;25183:1;25169:11;:15;25161:24;;;;;;25232;;;25261;;;;25258:31;;25228:62;25107:390;;;25336:25;25343:1;25346;25349:11;25336:6;:25::i;:::-;25327:34;;25404:1;25389:11;25376:25;;;;;:::i;:::-;25386:1;25383;25376:25;:29;25372:116;;;-1:-1:-1;;25428:6:0;:26;25420:35;;;;;;25468:8;;25372:116;24973:536;;;;;:::o;30974:985::-;31055:12;31123:4;31117:11;-1:-1:-1;;;31180:4:0;31173:80;-1:-1:-1;;;;;31318:2:0;31314:51;31308:4;31301:65;31418:6;31412:4;31405:20;31550:4;31547:1;31541:4;31538:1;31535;31528:5;31521;31516:39;31505:50;;31794:7;31765:16;31758:24;31752:2;31734:16;31731:24;31727:1;31723;31717:8;31714:15;31710:46;31707:76;31574:236;31563:247;;31831:17;31825:4;31818:31;;31902:7;31897:56;;31918:35;;-1:-1:-1;;;31918:35:0;;;;;;;;;;;31897:56;31048:911;30974:985;;;:::o;21123:3573::-;21205:14;21561:5;;;21205:14;-1:-1:-1;;21565:1:0;21561;21716:20;21782:5;21778:2;21775:13;21767:5;21763:2;21759:14;21755:34;21746:43;;;21923:5;21909:11;:19;21901:28;;;;;;22001:5;22010:1;22001:10;21997:126;;-1:-1:-1;22056:23:0;;;;-1:-1:-1;22100:13:0;;21997:126;22502:11;22499:1;22496;22489:25;22760:12;22776:15;;;22775:31;;22895:22;;;;;23678:1;23659;:15;;23658:21;;23901:17;;;23897:21;;23890:28;23958:17;;;23954:21;;23947:28;24016:17;;;24012:21;;24005:28;24074:17;;;24070:21;;24063:28;24132:17;;;24128:21;;24121:28;24191:17;;;24187:21;;;24180:28;23254:12;;;;23250:23;;;23275:1;23246:31;22544:20;;;22533:32;;;23303:12;;;;22584:21;;;;23018:16;;;;23294:21;24650:11;;-1:-1:-1;21123:3573:0;;;;;:::o;427:196:1:-;495:20;;-1:-1:-1;;;;;544:54:1;;534:65;;524:93;;613:1;610;603:12;524:93;427:196;;;:::o;628:186::-;687:6;740:2;728:9;719:7;715:23;711:32;708:52;;;756:1;753;746:12;708:52;779:29;798:9;779:29;:::i;1204:272::-;1262:6;1315:2;1303:9;1294:7;1290:23;1286:32;1283:52;;;1331:1;1328;1321:12;1283:52;1370:9;1357:23;1420:6;1413:5;1409:18;1402:5;1399:29;1389:57;;1442:1;1439;1432:12;1481:654;1606:6;1614;1667:2;1655:9;1646:7;1642:23;1638:32;1635:52;;;1683:1;1680;1673:12;1635:52;1723:9;1710:23;1752:18;1793:2;1785:6;1782:14;1779:34;;;1809:1;1806;1799:12;1779:34;1847:6;1836:9;1832:22;1822:32;;1892:7;1885:4;1881:2;1877:13;1873:27;1863:55;;1914:1;1911;1904:12;1863:55;1954:2;1941:16;1980:2;1972:6;1969:14;1966:34;;;1996:1;1993;1986:12;1966:34;2049:7;2044:2;2034:6;2031:1;2027:14;2023:2;2019:23;2015:32;2012:45;2009:65;;;2070:1;2067;2060:12;2009:65;2101:2;2093:11;;;;;2123:6;;-1:-1:-1;1481:654:1;;-1:-1:-1;;;;1481:654:1:o;2140:254::-;2208:6;2216;2269:2;2257:9;2248:7;2244:23;2240:32;2237:52;;;2285:1;2282;2275:12;2237:52;2308:29;2327:9;2308:29;:::i;:::-;2298:39;2384:2;2369:18;;;;2356:32;;-1:-1:-1;;;2140:254:1:o;3054:277::-;3121:6;3174:2;3162:9;3153:7;3149:23;3145:32;3142:52;;;3190:1;3187;3180:12;3142:52;3222:9;3216:16;3275:5;3268:13;3261:21;3254:5;3251:32;3241:60;;3297:1;3294;3287:12;4027:127;4088:10;4083:3;4079:20;4076:1;4069:31;4119:4;4116:1;4109:15;4143:4;4140:1;4133:15;5546:225;5613:9;;;5634:11;;;5631:134;;;5687:10;5682:3;5678:20;5675:1;5668:31;5722:4;5719:1;5712:15;5750:4;5747:1;5740:15;5631:134;5546:225;;;;:::o;5958:127::-;6019:10;6014:3;6010:20;6007:1;6000:31;6050:4;6047:1;6040:15;6074:4;6071:1;6064:15
Swarm Source
ipfs://65ed562b37526a147501e57b008a31b119f25e399c106ed7b5535360cfd68c5e
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
[ Download: CSV Export ]
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.