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프로젝트로 돌아가기