Olympus 백서

Olympus

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 16쪽 중 1쪽

Skip to main content Welcome to the Olympus Docs Overview What is Olympus Protocol? Governance An overview of Olympus Governance Technical Technical information and documentation Getting Started What is Olympus Protocol? An overview of the Olympus protocol What is Range Bound Stability? An overview of the RBS What is Cooler Loans? An overview of Cooler Loans Developer Links olympus-v3 olympus-contracts (OLD) olympus-frontend protocol-metrics-subgraph Discord Join the Olympus community on discord Forum Discuss governance and more. GitHub View all Olympus repositories. ## /main/overview/intro On this page What is Olympus? The Olympus protocol is a decentralized financial (DeFi) system that supports OHM, a treasury backed, liquidity-enabling token on the Ethereum network. Olympus leverages the mechanisms of Protocol Owned Liquidity (POL), Range Bound Stability (RBS) and Cooler Loans to create a robust, flexible, censorship-resistant, and smart money. The goal of Olympus is to build a programmatic policy-controlled money that: Preserves purchasing power via long-term price predictability. Maintains reliable liquidity across decentralized exchanges. Is used as a unit of account (e.g., by being paired against many other decentralized assets) Is utilized as a trusted asset (e.g., to collateralize other assets or deposited into protocols’ treasuries). Is fully decentralized and controlled by the community Is financially flexible, allowing users to borrow the backing against their money Why do we need Olympus in the first place? ​ Fiat-pegged stablecoins have become an essential part of crypto due to their lack of volatility as compared to tokens such as Bitcoin and Ether. Users are comfortable with transacting stablecoins knowing they hold the same amount of purchasing power today vs. tomorrow. Unfortunately, this is a fallacy. Fiat dollars are controlled by centralized government monetary policy and always decrease in purchasing power (inflation). This depreciation of the dollar also means a depreciation of these stablecoins. Olympus provides an alternative to Web3’s reliance on centralized, censorable stablecoin assets. Why do we need Olympus in the first place? ## /main/governance/governance On this page Governance at Olympus info Olympus Governance is transitioning from multisig management to on-chain governanc, per OIP-152 . OIP-166 was the first deployment of these changes. The Olympus protocol is governed and upgraded by tokenholders using three components: gOHM token (Governance OHM) Governor Bravo Multisig Together, these components enable the community to propose, vote on, and implement changes to the Olympus V3 system. Proposals can modify system parameters, activate or deactivate policies, and install or upgrade modules, effectively allowing the addition of new features and the mutation of the protocol. gOHM ​ gOHM, or Governance OHM, is an ERC-20 token used for proposing upgrades to Olympus protocol. gOHM can be obtained by wrapping OHM, and vice versa. The only use cases of gOHM today is for voting and as Cooler Loans collateral. Delegation ​ gOHM allows the owner to delegate voting rights to any address, including their own. There's a few considerations to keep in mind when delegating: Users can delegate to only one address at a time The entire gOHM balance of the delegator is added to the delegatee’s vote count Changes to the delegator's token balance automatically adjust the voting rights of the delegatee Votes are delegated from the current block and onward, until the delegator delegates again or transfers all their gOHM gOHM sitting in Cooler Loans qualifies for delegation Delegation can be achieved by calling the delegate() function or via a valid off-chain signature using delegateBySig() . Olympus provides a frontend for managing delegations here . info You must delegate your gOHM in Cooler Loans to be eligible to vote in both Snapshot and Governor Bravo. Visit Olympus Govern page for more information. Voting eligibility ​ The following table outlines what gOHM supply is eligible to vote in both Snapshot and Governor Bravo: gOHM type Snapshot eligibility Governor Bravo eligibility gOHM ✅ ❗ (requires delegation) gOHM in Cooler Loans ❗ (requires delegation) ❗ (requires delegation) tokemak gOHM ✅ ❌ Arbitrum gOHM ✅ ❌ AVAX gOHM ✅ ❌ Polygon gOHM ✅ ❌ Fantom gOHM ✅ ❌ Optimism gOHM ✅ ❌ Governor Bravo ​ Olympus implements a modified version of Compound’s Governor Bravo with the following key changes: Percent-based submission threshold - The minimum amount of votes required by the proposer to submit the proposal. Set to 0.017% of the total gOHM supply, at time of proposal submission. Checked again during proposal queueing and execution. Percent-based quorum threshold - The minimum amount of FOR votes required for a proposal to qualify to pass. Set to 20% of the gOHM supply at time of proposal activation. Net votes approval threshold - OCG introduces the concept of net votes, which is the margin of votes between FOR and NO in order for a proposal to qualify to pass. Specifically, the percentage of voting supply voting FOR must be 60%, or greater. The decision to introduce these changes stem from elasticity in the gOHM supply. Percent-based thresholds ensure that requirements (in absolute gOHM terms) for proposing and executing proposals scale/shrink with the token supply. Today, Governor Bravo's Timelock is responsible for the following roles: Role Responsibility Systems affected admin Single address permission: Assign roles to any policy Kernel Per OIP-152 , additional roles will be transfered from multisig management to Governor Bravo's Timelock. OIP-166 was the first deployment of these changes. Parameters ​ Variable Description Value proposalThreshold % of total supply required in order for a voter to become a proposer 0.017% of supply quorumPct minimum % of total supply voting FOR in order for a proposal to qualify to pass 20% highRiskQuorum Same as quorumPct but specific to a high risk module in the Default system 20% approvalThresholdPct minimum % of voting supply voting FOR in order for a proposal to qualify to pass 60% proposalMaxOperations The maximum number of actions that can be included in a proposal 15 actions votingDelay The delay before voting on a proposal may take place, once proposed, in blocks 3 days votingPeriod The duration of voting on a proposal, in blocks 7 days activationGracePeriod The amount of time once a proposal is eligible for activation that it can be activated before considered expired 1 day GRACE_PERIOD How long after a proposal is eligible for execution it can still be executed before it is considered expired 1 day delay (execution delay) The time a proposal must be queued for before it can be executed 1 day vetoGuardian Address which has veto power over all proposals Emergency MS MIN_GOHM_SUPPLY The minimum level of gOHM supply acceptable for OCG operations 1000 gOHM Shared Roles ​ Multisigs may perform protocol upgrades for roles that are not yet fully under Governor Bravo's Timelock control. The multisigs may queue and execute on-chain actions that are approved by the community through Snapshot , an off-chain governance client. Today, the following roles are under shared Timelock and multisig control: Role Responsibility Systems affected Multisig price_admin Calculates price metrics to use for RBS RBS DAO MS + Timelock operator_admin Initialize RBS operator RBS DAO MS + Timelock operator_policy Manages RBS ranges RBS DAO MS + Timelock callback_admin Callback to interface with Bond system RBS DAO MS + Timelock heart_admin Manages heartbeats RBS and Staking DAO MS + Timelock custodian Treasury custodian that can approve, remove assets from TRSY TRSRY DAO MS + Timelock bridge_admin Creates/manages bridges Cross Chain DAO MS + Timelock loop_daddy Administrative role for YRF YRF DAO MS + Timelock cooler_overseer Activats, reactivate, and defund Clearinghouse Coolers DAO MS + Timelock emergency_restart Restart MINTR, TRSRY All systems DAO MS + Timelock emergency_admin Emergency shutdown for BLV All systems Emergency MS + Timelock emergency_shutdown Shutdown MINTR, TRSRY All systems Emergency MS + Timelock Multisig ​ Multisigs perform protocol upgrades for roles that are not yet under Governor Bravo's Timelock control. The multisigs queue and execute on-chain actions that are approved by the community through Snapshot , an off-chain governance client. Today, the following roles are under multisig control: Role Responsibility Systems affected Multisig executor Single address permission: Ability to install modules and policies on Kernel Kernel DAO MS operator_operate Triggers heartbeat RBS updates RBS DAO MS operator_reporter Records a bond purchase and updates capacity accordingly. Limited to the BondCallback contract. RBS DAO MS bondmanager_admin Create and manage new bond markets OHM and other non-RBS managed bonds DAO MS Per OIP-152 , additional roles will be transfered from multisig management to Governor Bravo's Timelock. OIP-166 was the first deployment of these changes. gOHM Delegation Voting eligibility Governor Bravo Parameters Shared Roles Multisig ## /main/contracts/overview On this page Overview Olympus V3 is the current and latest iteration of the Olympus protocol. It is a foundation for the future of the protocol, utilizing the Default Framework to allow extensibility at the base layer via fully onchain governance mechanisms. There are a few major pieces to V3: the core registry (Kernel), treasury, minter, governor, and finally, the range-bound stability (RBS) system. Default Framework: Kernel, Modules and Policies Summary ​ Olympus V3 uses the Default Framework to configure the protocol’s smart contracts and authorized addresses within the system. In this framework, all contract dependencies and authorizations are managed via “Actions” in the Kernel.sol contract. These actions are as follows: Installing a Module Upgrading a Module Activating a Policy Deactivating a Policy Changing the Executor Executor is the address able to call major Kernel functions Migrating the Kernel All non-Kernel smart contracts in the protocol are either Module Contracts or Policy Contracts , which you can think of as the protocol's "back-end” and “front-end” logic, respectively. In some ways, this shares similarities to the "core" vs. "periphery" design pattern used by protocols like Uniswap: core contracts (Modules) define the core system capabilities, while periphery contracts (Policies) expose the interfaces that enable EOAs to interact with the protocol's various features. Ownership Model: The Executor ​ While most protocols have ownership defined at the contract level, Default's philosophy is to define ownership at the protocol level, within the Kernel. This is the function of the Kernel's Executor—it is the address that has the ability to execute actions within the Kernel. In Default, the executor defaults to the Deployer, but this can be set to any address using the Kernel Action ChangeExecutor : it's entirely possible to have a Kernel managed by a single wallet, or a multisig, but it can also be a contract. In Olympus V3, the Kernel's owner will be the Governance (Policy) contract. Kernel Migration ​ The last and final action that can be performed by the Kernel is MigrateKernel . This action is particularly sensitive and should only be done with the utmost care and attention to detail. In Default, any contract that is installed or configured in a Kernel.sol needs to have an internal variable that points to the address of the Kernel instance it is intended for. As a result, the same instance of a Module or a Policy cannot be reused across other Kernels. However, there may be circumstances in the future where new changes are made to the Kernel, like new Actions that are developed, gas optimizations found, or security improvements made that warrant porting the protocol contracts to a new instance of a Kernel without redeploying the contracts. The MigrateKernel Action reconfigures the internal variable for each contract registered in the Kernel, which will brick it. There are no foreseeable plans to use this action in Olympus V3, but it's important to be aware of its existence. Modules ​ Modules are internal-facing smart contracts that store shared state across the protocol, and are used as dependencies for Policies within the protocol. A module is a mix of a microservice and a data model: each Module is responsible for managing a particular data model within the system. Modules should have no dependencies of their own, and their logic should be limited to modifying their own internal state: in other words, a Module contract should not read from or the modify state of an external contract. By and large, EOAs should never call module contracts directly — if ever. In Default protocols, Module contracts are referenced internally as a 5 byte uppercase KEYCODE representing their underlying data models. For example, an ERC20 token module might have the keycode TOKEN , while a Treasury module might have the keycode TRSRY . This abstraction is intended to help clarify and distinguish where side effects occur when the protocol experiences external interactions, which should simplify both reading, writing and auditing its business logic. In Olympus V3, we have the following Modules: MINTR — The Minter Module, a wrapper for the OHM ERC20 contract. Used for minting and burning OHM. A wrapper is used to allow the legacy ERC20 to fit in the Default architecture. TRSRY — The Treasury Module, used for depositing and withdrawing assets within the protocol. Also manages token debt allocated to policies. PRICE — Resolves prices for OHM and configured protocol assets using multiple oracle feeds where available. PRICE v1.2 keeps the v1-style OHM price functions used by existing policies, while adding granular asset-specific accessors such as getPrice() for future integrations. RANGE — Stores range information for the RBS system. INSTR — The Instructions Module, used for storing batched Kernel instructions for convenient proposal execution in the Parthenon policy. ROLES — The Roles module is for allowing policies to define roles, assign addresses to those roles, and for the designated rolesAdmin to manage those roles. DLGTE — The DLGTE module is for allowing governance delegation of gOHM and Coolered gOHM positions. In addition, Modules have a VERSION() and optional initialization logic INIT() that is called when the Module is integrated into the Kernel, which is mainly used when an existing module is upgraded and its state needs to be migrated. Modules often have permissioned functions which should only be called by authorized Policy contracts, such as minting tokens or withdrawing treasury funds. These functions include a permissioned modifier to ensure only authorized Policy contracts can call them. Policies ​ While Module contracts define where protocol side effects occur, Policy contracts define how they occur. Policy contracts are external-facing contracts that intercept inbound calls to the protocol, then compose & route all the changes made in the protocol to the corresponding Modules. As a result, Policy contracts do have external dependencies, which are the Kernel Modules that they read and write from. In Default protocols, Policies must declare their dependencies to the Kernel as part of the contracts state. You will notice that each Policy contract has two functions configureDependencies() , which return a list of Kernel modules by their Keycode, and requestPermissions() , which are the function selectors of the privileged functions they need to call from within the contract logic. Policies are not "stateless": they can store their own state. However, unlike Modules, the state in Policies should only be used internally, and never as part of another contract's logic. One mental model you can use is that Policies store local state in the protocol, while Modules store global state: if you find that any state is re-used across multiple Policies, it should most likely be abstracted into a Module. The following Policies are included in Olympus V3: Range-Bound Stability (RBS) policies: Operator.sol — Main policy for the Range-Bound Stability system. Inputs market orders, spins up bond markets and facilitates swaps with the treasury in line with the RBS spec (#Range-Bound Stability (RBS) system). BondCallback.sol — Used as a callback for bond markets. Allows bond markets to mint OHM for payouts. Heart.sol — Contract to allow easy access for keepers to call RBS keeper functions. PriceConfig.sol — Used for a specified role to adjust parameters in the PRICE module PriceConfig.v2.sol — Used to configure PRICE v1.2 assets, price feeds, submodules, strategies, and moving-average settings. PriceCache.sol — Caches PRICE v1.2 asset/quote pair snapshots for oracle adapters and integrations that need pair-specific freshness checks. ChainlinkOracleFactory.sol , MorphoOracleFactory.sol , and ERC7726OracleFactory.sol — Create and manage oracle adapter clones that expose PRICE v1.2 prices through Chainlink-compatible, Morpho, and ERC-7726 interfaces. Cooler Loans policies: MonoCooler — Core contract managing cooler loan states, lender-owned contract that manages loan workflows including fulfilling requests, and rebalancing funds to/from Olympus Treasury. LTV Oracle — Defines origination and liquidation LTVs. Treasury Borrower — Connects loan disbursement to the Olympus Treasury. Deprecated: Clearinghouse.sol — Clearinghouse is a lender-owned contract that manages loan workflows including fulfilling requests, extending maturities, claiming defaults and rebalancing funds to/from Olympus Treasury. Governance policies (NOTE: Still have not been deployed): Parthenon.sol - Governor contract specially made for Default, modeled after Proof-of-Stake. VohmVault.sol - Policy for distributing voting power to vote lockers. General protocol and management policies: TreasuryCustodian.sol — Utility policy for allowing a specified role to modify TRSRY state in abnormal circumstances. Used for granting and removing approvals and managing debt. Distributor.sol - Contract for handling rebase emissions for OHM stakers. RolesAdmin.sol - Policy for managing the ROLES module. Emergency.sol - Emergency contract to shutdown and restart core systems in special cases. Protocol Architecture ​ The following diagram represents all the active modules and policies that take part in Olympus V3. Default Framework: Kernel, Modules and Policies Summary Modules Policies Protocol Architecture ## /main/overview/range-bound On this page Range Bound Stability Overview ​ info Range Bound Stability (RBS) is currently disabled. The functionality has been replaced by: Yield Repurchase Facility handles lower bounds (buying OHM when price is low) Emissions Manager handles upper bounds (selling OHM when price is high) The Olympus Protocol automatically executes market operations to absorb volatility in the market price of OHM in relation to its reserve assets. This system is called Range-Bound Stability (RBS). The initial system design operates against individual reserve assets in isolation, and has been deployed to stabilize the price of OHM against DAI. The mechanism was originally defined in the Stabilizing Currency Through a Protocol-Enforced Range white paper by Zeus et al. RBS involves deploying treasury reserves in a downward trending market and selling OHM for reserves in an upward trending market to stabilize price. The nature of these actions causes contraction and growth of the network depending on the market environment to enforce stability. Liquidity is a key aspect of the Olympus system and the vast majority of OHM liquidity is Protocol-Owned . In addition to the market operations performed by RBS, the protocol enacts policies to balance the amount of
프로젝트로 돌아가기