Forward Marketplace

rFlow turns future on-chain yield into a tradable asset. LSTs, lending receipts, and Meteora LP positions become forward contracts that anyone on Solana can buy or sell — settled trustlessly by the program.

Overview#

A forward is an agreement between two parties to exchange an asset at a future date for a price agreed today. In traditional finance, forwards are used to lock in interest rates, fuel prices, and FX exposure. rFlow brings the same primitive to Solana DeFi — for yield.

When you stake SOL, lend USDC, or LP in Meteora, your principal stays locked and your yield accrues in the background. The Forward Marketplace unbundles those two streams: sellers monetize their future yield for immediate USDC, while buyers lock in a known return on a clearly-priced position — no liquidation risk, no slippage, no APY guesswork.

How It Works#

The marketplace runs entirely on-chain through the rFlow Anchor program. Five steps from listing to settlement:

For Sellers#

Anyone holding a yield-bearing position on Solana can list it. The marketplace is permissionless for whitelisted mints — no KYC, no approval, no waiting list.

Pricing a listing

The selling price is the seller's call. Most listings price below the expected yield to leave room for buyer profit. A reasonable starting point:

1// Reference pricing formula
2const expectedYield = principalUsdc * apy * (durationDays / 365);
3
4// 10–25% discount creates predictable buyer demand
5const sellingPrice = expectedYield * (1 - discountRate);
6
7// Example: $10,000 mSOL position, 7% APY, 90 days
8//   expectedYield = 10_000 * 0.07 * (90/365)  = $172.60
9//   sellingPrice   = 172.60 * (1 - 0.15)       = $146.71

For Buyers#

Buyers acquire a claim on future yield without ever touching the underlying protocol. You don't stake, you don't lend, you don't LP — you pay USDC, you wait, the program pays you out at maturity.

Settlement#

Settlement is the moment the deal collapses back into its two parts. The program reads the current value of the locked position, splits the receipt tokens between buyer and seller, and closes the vault.

Yield deal settlement math

1// 1. Read current LST value via Pyth (mainnet) or oracle param (devnet)
2const currentValue = oracleValue ?? currentTokenValueParam;
3
4// 2. Yield is the appreciation since lock
5const actualYield = currentValue - principalValueAtLock;
6
7// 3. Split the locked receipt tokens proportionally
8const yieldTokens = receiptTokensAmount * actualYield / currentValue;
9const principalTokens = receiptTokensAmount - yieldTokens;
10
11// 4. Transfer
12//    yieldTokens  -> buyer (their profit, denominated in receipt tokens)
13//    principalTokens -> seller (their principal, denominated in receipt tokens)

The buyer receives receipt tokens, not USDC. They can hold, redeem at the source protocol, or swap. The seller receives their principal back in the same token they locked.

Meteora LP settlement

Meteora deals work a little differently because fees accrue in two tokens and must be claimed from the pool. During the active deal, the buyer can call claim_meteora_fees any number of times to harvest accumulated fees from the locked position. At ends_at, the Position NFT returns to the seller, who can then withdraw_meteora_liquidity if they want to unwind.

Integration#

The marketplace is a public good — any frontend, aggregator, or structured-product protocol can plug into it. There is one program, one IDL, and one canonical SDK.

Three integration paths

• Listings UI — Fetch getAvailableDeals() from the SDK and render a marketplace. See SDK reference.
• One-click create — Bundle a stake/lend transaction with createDeal so users instantly tokenize their yield as soon as they deposit.
• Structured products — Buy a basket of deals on behalf of users. Settlement is permissionless, so payout requires no off-chain coordination.

Listening for activity

The reference frontend syncs deal state via Helius webhooks pointed at the program ID 2woLsnG7zvKdyd7geH9GAFgKSt6NLrnLDDMmFBUdDjFU. Each create / buy / settle emits a transaction the webhook handler parses and writes to your indexer.

1// Subscribe to program logs in any RPC client
2import { Connection, PublicKey } from "@solana/web3.js";
3import { PROGRAM_ID } from "@rflowdapp/rflow";
4
5const connection = new Connection("wss://your-rpc-endpoint");
6
7connection.onLogs(PROGRAM_ID, (logInfo) => {
8  // logInfo.signature, logInfo.logs[]
9  // Parse with the SDK's parsePayFlowTransactions helper
10});