How Protocol-Owned Liquidity Changes Pool Dynamics

Detailed Instructions

Design the bonding mechanism which allows users to sell assets to the protocol treasury in exchange for discounted protocol tokens. This creates a non-dilutive funding source for liquidity.

• Sub-step 1: Define bondable assets: Common choices include LP tokens for the protocol's own pools (e.g., TOKEN/ETH SLP) or stablecoins like DAI.
• Sub-step 2: Set vesting schedule: Determine the linear vesting period (e.g., 5 days) for the discounted tokens to manage sell pressure.
• Sub-step 3: Configure bond terms: Calculate the bond discount rate (e.g., 2% below market) and the bond capacity per asset to control treasury exposure.

solidityCopy
// Example bond configuration parameters
struct BondTerms {
    address principal; // Address of bondable asset (e.g., DAI)
    uint256 discount; // Basis points, e.g., 200 for 2%
    uint256 vestingTerm; // In seconds, e.g., 432000 for 5 days
    uint256 maxPayout; // Maximum tokens issued for this bond
}

Tip: Use a bond control variable to algorithmically adjust discounts based on demand, helping to stabilize token price.

Detailed Instructions

Deploy the automated market maker (AMM) pool and a staking contract to direct fees and rewards.

• Sub-step 1: Create the liquidity pool: On a DEX like Uniswap V2, create a TOKEN/ETH pair. The initial seed can come from the team or a bonding round.
• Sub-step 2: Deploy the staking contract: This contract will hold the protocol-owned LP tokens. Users can stake their own LP tokens here to earn protocol token rewards.
• Sub-step 3: Configure reward emissions: Set the reward rate (e.g., 0.5 TOKEN per block) and ensure the staking contract has a sufficient token allocation.

solidityCopy
// Simplified staking contract snippet
function stake(uint256 _amount) external {
    lpToken.safeTransferFrom(msg.sender, address(this), _amount);
    _stakeFor(msg.sender, _amount);
}

function _stakeFor(address _user, uint256 _amount) internal {
    userStake[_user] += _amount;
    totalStaked += _amount;
    emit Staked(_user, _amount);
}

Tip: Use a reward distributor contract to manage complex emission schedules and multi-token rewards, separating logic from the core staker.

Detailed Instructions

Initiate bond sales to exchange treasury assets for liquidity pool tokens, building the POL base.

• Sub-step 1: Approve bond terms: Governance or a multisig must approve the specific bond terms (asset, discount, limit) before sales begin.
• Sub-step 2: Users deposit assets: A user calls deposit() on the bond contract, sending 100 DAI. The contract mints a bond receipt NFT representing the claim.
• Sub-step 3: Treasury receives principal: The 100 DAI is sent to the protocol treasury. In return, the user is owed 102 TOKEN (with a 2% discount), vested linearly.
• Sub-step 4: Treasury uses DAI to mint LP: The treasury's smart contract logic automatically uses the acquired DAI and an equal value of protocol tokens to add liquidity to the TOKEN/DAI pool, receiving LP tokens in return.

Tip: Monitor the bond debt ratio, which is the total tokens owed to bonders divided by treasury revenue. A ratio above 30% may indicate excessive future dilution.

Detailed Instructions

Transfer the protocol-owned LP tokens from the treasury to the staking contract to start earning fees and controlling rewards.

• Sub-step 1: Transfer LP tokens: The treasury contract calls transfer() to send the newly minted LP tokens to the staking contract address.
• Sub-step 2: Stake the tokens internally: The staking contract's owner (the treasury) calls an internal _stakeFor() function, crediting the treasury's stake balance without a public transaction.
• Sub-step 3: Verify ownership and rewards: Query the staking contract's balanceOf() for the treasury address to confirm the stake. Check that the treasury is accruing its share of the trading fees from the AMM pool and any emitted reward tokens.

solidityCopy
// Treasury contract excerpt for depositing LP
function depositLPTokensToStaker(address _stakingContract, uint256 _amount) external onlyPolicy {
    IERC20(lpTokenAddress).approve(_stakingContract, _amount);
    IStakingContract(_stakingContract).stake(_amount);
    emit LPDeposited(_stakingContract, _amount);
}

Tip: The protocol's stake should be large enough to influence gauge voting on emissions if the pool is on a vote-escrow DEX like Curve, giving the protocol direct control over liquidity incentives.

Detailed Instructions

Actively manage the treasury's portfolio of assets and LP positions to sustain the protocol-owned liquidity model.

• Sub-step 1: Harvest and compound rewards: Regularly call getReward() on the staking contract to claim accrued protocol tokens and trading fees. These can be auto-compounded back into the LP.
• Sub-step 2: Execute liquidity management policies: Based on governance, this may include zapping reward tokens directly into more LP, selling a portion of rewards for stablecoins to fund operations, or adjusting bond terms.
• Sub-step 3: Monitor key metrics: Track the Protocol Owned Liquidity Ratio (POL / Total Liquidity), treasury asset diversity, and the health of the bonding curve. Use this data to inform parameter adjustments via governance proposals.

Tip: Implement a treasury manager contract with keeper-triggered functions for automated reward harvesting and compounding, reducing operational overhead and ensuring efficiency.