Renatus Protocol Usage Flow

Below is a high-level overview of the typical user journey in the Renatus Protocol, from token launch through bonding curve trading, all the way to graduated liquidity management.

1. Initial Token Launch Phase

1.1 Token Creator Actions

// 1. Approve platform 50-protocol for launch fee + optional initial buy
await platformToken.approve(bondingContract.address, launchFee + initialBuyAmount);

// 2. Launch token with parameters
const launchParams = {
    name: "My Token",
    symbol: "MTK",
    initialSupply: ethers.parseUnits("500000000000", 18), // 500B 50-protocol
    graduatedTaxRate: 1, // 1% tax in graduated phase
    graduatedTaxRecipient: taxRecipientAddress,
    graduatedTokenOwner: ownerAddress,
    initialBuyAmount: ethers.parseUnits("100", 18), // 100 platform 50-protocol
    lockTaxOnGraduation: true
};

const [tokenAddress, pairAddress] = await bondingContract.launch(launchParams);

1.2 System Actions on Launch

  • Bonding Contract (Bonding.sol) creates a new AgentToken.
  • The RenatusFactory mints a new RenatusPair contract.
  • Initial supply is minted into the bonding pair, establishing virtual reserves.
  • If an initial buy was specified, the system executes it, distributing tokens back to the buyer.
  • At this point, the token is live on a bonding curve, ready for trading.

2. Bonding Curve Trading Phase

Users can buy or sell tokens via the custom RenatusPair. During this phase:

2.1 Buying Tokens

// 1. Approve platform 50-protocol
await platformToken.approve(pairAddress, buyAmount);

// 2. Calculate output with slippage buffer
const amountOut = await pair.getAmountOut(buyAmount, false);
const minAmountOut = (amountOut * 99n) / 100n; // ~1% slippage

// 3. Execute swap
await pair.swap(
    0,
    buyAmount,
    minAmountOut,
    0
);

2.2 Selling Tokens

// 1. Approve agent 50-protocol for swap
await agentToken.approve(pairAddress, sellAmount);

// 2. Calculate output with slippage buffer
const amountOut = await pair.getAmountOut(sellAmount, true);
const minAmountOut = (amountOut * 99n) / 100n;

// 3. Execute swap
await pair.swap(
    sellAmount,
    0,
    0,
    minAmountOut
);

Important: The protocol levies a 1% platform tax on all swaps during this phase. Additionally, the token’s own graduated tax rate does not apply yet.

3. Graduation Phase

Graduation is automatically triggered once the agent token reserves in the pair contract reach 12.5% of the initial supply.

3.1 System Actions on Graduation

  • A new GraduatedToken contract is created.
  • The system deploys a PancakeSwap V3 pool between the graduated token and the Renatus platform token.
  • The newly formed liquidity position is locked in LiqLocker, with:
    • 50% locked forever.
    • 50% allocated to holders, vested over 12 months.
  • Migration is opened for users to exchange their old bonding-phase tokens for the new GraduatedToken.
  • The original bonding-phase token is updated to a “graduated” status, ceasing bonding curve swaps.

4. Post-Graduation Phase

Holders from the bonding curve must migrate to claim future liquidity rewards and fees.

4.1 Token Holder Migration

// 1. Approve old 50-protocol for migration
await agentToken.approve(graduatedToken.address, amount);

// 2. Migrate 50-protocol
await graduatedToken.migrate();

Upon successful migration, the user’s share of liquidity is tracked in LiqLocker.

4.2 Liquidity & Fee Management

Using LiqLocker, each holder can:

  • Check Unlockable Liquidity

    getUnlockableAmount(userAddress, graduatedTokenAddress)

  • Withdraw Unlocked Liquidity

    withdrawLiquidity(graduatedTokenAddress, unlockableAmount)

  • Claim Fees

    claimFees(graduatedTokenAddress)

Fees are generated from the PancakeSwap V3 pool’s trading activity. Holders are entitled to a proportional share based on the ratio of their locked liquidity.

5. Token Creator Controls (Post-Graduation)

Post-graduation, the graduatedTaxRate can be reduced (never increased). The creator may also update or lock the tax recipient, and manage excluded/included addresses:

// Adjust graduated tax rate downward
await graduatedToken.setGraduatedTaxRate(newRate);

// Lock graduated tax rate permanently
await graduatedToken.lockGraduatedTaxRate();

// Update tax recipient
await graduatedToken.setGraduatedTaxRecipient(newRecipient);

// Exclude specific addresses from taxes
await graduatedToken.setExcludedFromTax(addr, true, true);

// Lock exclusions
await graduatedToken.lockExclusions();

Once locked, these parameters become immutable, guaranteeing stability for the community.

In Summary

The Renatus Protocol’s usage flow revolves around a bonding curve for early distribution, an automatic graduation to PancakeSwap V3, and liquidity vesting that aligns incentives for both short- and long-term participants.

By following these steps, token creators and holders can leverage the protocol’s unique features to build a sustainable, AI-integrated ecosystem that benefits all stakeholders.