Integration Guide

1import { RFlowClient, PROGRAM_ID } from "@rflowdapp/rflow";
2import { Connection } from "@solana/web3.js";
3
4export function makeClient(walletLike?: AnchorWalletLike) {
5  const connection = new Connection(
6    process.env.NEXT_PUBLIC_RPC_URL ?? "https://api.mainnet-beta.solana.com",
7    "confirmed"
8  );
9  return walletLike
10    ? new RFlowClient({ connection, wallet: walletLike })
11    : RFlowClient.readOnly(connection);
12}
13
14export { PROGRAM_ID };

1import { RFlowClient } from "@rflowdapp/rflow";
2
3const config = await client.getConfig();
4const isAllowed = config?.allowedMints.some((m) => m.equals(myReceiptMint));
5if (!isAllowed) throw new Error("Mint not whitelisted yet");
6
7const paymentAllowed = config?.allowedPaymentMints.some((m) => m.equals(usdcMint));
8if (!paymentAllowed) throw new Error("Payment mint not whitelisted");
9if (config?.isPaused) throw new Error("Protocol is paused");

1import {
2  RFlowClient,
3  SourceProtocol,
4  KNOWN_MINTS,
5} from "@rflowdapp/rflow";
6import {
7  Connection,
8  Transaction,
9  sendAndConfirmTransaction,
10} from "@solana/web3.js";
11import { getAssociatedTokenAddress } from "@solana/spl-token";
12
13const connection = new Connection(process.env.RPC_URL!);
14const client = new RFlowClient({ connection, wallet });
15
16// 1. Create
17const createIxs = await client.yieldDeals.createDeal({
18  receiptTokenMint:     KNOWN_MINTS.MSOL,
19  receiptTokensAmount:  10_000_000_000n,
20  principalValueAtLock: 1_180_000_000n,
21  expectedYield:        17_000_000n,
22  sellingPrice:         14_000_000n,
23  durationDays:         90,
24  sourceProtocol:       SourceProtocol.Marinade,
25  exchangeRateAtLock:   1_180_000n,
26  // priceUpdate: msolUsdPriceUpdate,  // mainnet only
27});
28await send(createIxs);
29
30// 2. Buy
31const dealId = (await client.getConfig())!.dealCounter - 1n;
32const deal   = await client.yieldDeals.getDeal(dealId);
33const seller = await getAssociatedTokenAddress(deal!.paymentMint, deal!.seller);
34const treas  = await getAssociatedTokenAddress(
35  deal!.paymentMint,
36  (await client.getConfig())!.treasury
37);
38await send(await client.yieldDeals.buyDeal(dealId, seller, treas));
39
40// 3. Settle (after ends_at, anyone)
41await send(
42  await client.yieldDeals.settleDeal(dealId, currentTokenValue, priceUpdate)
43);
44
45async function send(ixs: TransactionInstruction[]) {
46  const tx = new Transaction().add(...ixs);
47  return sendAndConfirmTransaction(connection, tx, [signerKeypair]);
48}

1import { Connection, PublicKey } from "@solana/web3.js";
2import { PROGRAM_ID } from "@rflowdapp/rflow";
3
4const connection = new Connection("wss://your-rpc", "confirmed");
5
6// All program accounts — for full indexing on startup
7const accounts = await connection.getProgramAccounts(PROGRAM_ID);
8
9// Stream live updates on the program logs
10const subId = connection.onLogs(PROGRAM_ID, (logInfo) => {
11  // logInfo.signature -> fetch the parsed tx, sync the touched deal
12});
13
14// Or subscribe to a specific deal PDA
15const dealSubId = connection.onAccountChange(dealPda, (info) => {
16  // info.data is the YieldDeal — decode with the SDK's IDL
17});

1// 1. Configure a Helius enhanced webhook
2//    Trigger: program ID 2woLsnG7zvKdyd7geH9GAFgKSt6NLrnLDDMmFBUdDjFU
3//    Type: enhanced transactions
4//    Auth: Bearer secret in the Authorization header
5
6// 2. POST handler
7export async function POST(req: Request) {
8  const auth = req.headers.get("authorization");
9  if (auth !== `Bearer ${process.env.HELIUS_WEBHOOK_SECRET}`) {
10    return new Response("Unauthorized", { status: 401 });
11  }
12
13  const transactions = await req.json();
14
15  for (const tx of transactions) {
16    const instructions = parseRFlowInstructions(tx);   // your own parser
17    for (const ix of instructions) {
18      switch (ix.action) {
19        case "create_deal":           // refetch + upsert
20        case "create_meteora_deal":
21        case "update_to_active":      // -> status: 'active'
22        case "update_to_settled":     // -> status: 'settled'
23        case "update_to_cancelled":   // -> status: 'cancelled'
24        case "update_to_bought_back": // -> status: 'bought_back'
25      }
26    }
27  }
28
29  return Response.json({ ok: true });
30}

1import { RFlowClient, DealStatus } from "@rflowdapp/rflow";
2
3async function tick() {
4  const active = (await client.yieldDeals.getAllDeals({ status: DealStatus.Active }))
5    .filter((d) => d.endsAt && d.endsAt.getTime() <= Date.now());
6
7  for (const deal of active) {
8    try {
9      const currentValue = await fetchOracleValue(deal);  // your code
10      const ixs = await client.yieldDeals.settleDeal(
11        deal.dealId,
12        currentValue,
13        getPythPriceUpdate(deal.receiptTokenMint)
14      );
15      const tx = new Transaction().add(...ixs);
16      await sendAndConfirmTransaction(connection, tx, [keeperKeypair]);
17      console.log("Settled deal", deal.dealId);
18    } catch (err) {
19      console.warn("Settle failed for", deal.dealId, err);
20    }
21  }
22}
23
24setInterval(tick, 60_000);