# OnRe Smart Contract Integration ### Quick Start
PropertyValue
Program IDonreuGhHHgVzMWSkj2oQDLDtvvGvoepBPkqyaubFcwe
NetworkSolana Mainnet
Anchor Version0.31.1
Githubhttps://github.com/onre-finance/onre-sol
### Overview The OnRe program enables token exchanges through **offers**. Each offer represents a trading pair (e.g., USDC → ONyc) with dynamic pricing based on time-based APR growth. #### Key Concepts: * **Offer**: A PDA account identified by a token pair `(token_in_mint, token_out_mint)` * **Token In**: The token users pay (e.g., USDC, USDG) * **Token Out**: The token users receive (e.g., ONyc) * **Pricing Vectors**: Time-based price schedules with APR-driven growth ### Choosing Your Integration Path `take_offer` vs `take_offer_permissionless` | Feature | take\_offer | take\_offer\_permissionless | | -------------------------- | ------------------------------ | -------------------------------------------------- | | Token Routing | Direct user-to-boss transfers | Routes through program-owned intermediary accounts | | Smart Contract Integration | Works well | Simpler setup (recommended) | | Approval Message | Optional (when offer requires) | Optional (when offer requires) | | Pricing | Same | Same | | Fees | Same | Same | | Account Setup | Fewer accounts needed | More accounts, but program-controlled | #### Recommendation Use `take_offer_permissionless` for most integrations: * Simpler integration – no direct user-to-boss token account relationships needed * Atomic routing through program-controlled PDAs * Better for smart contract CPI calls ### PDA Seeds Reference All PDAs are derived from the program ID: `onreuGhHHgVzMWSkj2oQDLDtvvGvoepBPkqyaubFcwe`
PDASeedDescription
State"state"Program state (contains boss, kill switch, approvers)
Offer"offer" + token_in_mint + token_out_mintOffer account for a token pair
Vault Authority"offer_vault_authority"Authority for vault token accounts
Permissionless Authority"permissionless-1"Authority for intermediary token routing
Mint Authority"mint_authority"Authority for mint operations
```typespec import { PublicKey } from "@solana/web3.js"; const PROGRAM_ID = new PublicKey("onreuGhHHgVzMWSkj2oQDLDtvvGvoepBPkqyaubFcwe"); // All PDAs you'll need - compute these once at initialization const pdas = { state: PublicKey.findProgramAddressSync( [Buffer.from("state")], PROGRAM_ID )[0], vaultAuthority: PublicKey.findProgramAddressSync( [Buffer.from("offer_vault_authority")], PROGRAM_ID )[0], permissionlessAuthority: PublicKey.findProgramAddressSync( [Buffer.from("permissionless-1")], PROGRAM_ID )[0], mintAuthority: PublicKey.findProgramAddressSync( [Buffer.from("mint_authority")], PROGRAM_ID )[0], }; // Offer PDA for a specific token pair function getOfferPda(tokenInMint: PublicKey, tokenOutMint: PublicKey): PublicKey { return PublicKey.findProgramAddressSync( [Buffer.from("offer"), tokenInMint.toBuffer(), tokenOutMint.toBuffer()], PROGRAM_ID )[0]; } ``` ### Integration: `take_offer_permissionless` This is the **recommended** integration path for most use cases. #### Instruction Discriminator `[37, 190, 224, 77, 197, 39, 203, 230]` #### Arguments | Name | Type | Description | | ------------------ | ------------------------- | ------------------------------------------------------- | | `token_in_amount` | `u64` | Amount of token\_in the user is paying (including fees) | | `approval_message` | `Option` | Pass `null` for permissionless offers | #### Using Anchor Client (Recommended) ```typescript import { Program, AnchorProvider, BN } from "@coral-xyz/anchor"; import { PublicKey, Keypair } from "@solana/web3.js"; import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token"; import { Onreapp } from "./types/onreapp"; import idl from "./idl/onreapp.json"; const PROGRAM_ID = new PublicKey("onreuGhHHgVzMWSkj2oQDLDtvvGvoepBPkqyaubFcwe"); // Pre-compute PDAs once at initialization const pdas = { state: PublicKey.findProgramAddressSync([Buffer.from("state")], PROGRAM_ID)[0], vaultAuthority: PublicKey.findProgramAddressSync([Buffer.from("offer_vault_authority")], PROGRAM_ID)[0], permissionlessAuthority: PublicKey.findProgramAddressSync([Buffer.from("permissionless-1")], PROGRAM_ID)[0], mintAuthority: PublicKey.findProgramAddressSync([Buffer.from("mint_authority")], PROGRAM_ID)[0], }; async function takeOfferPermissionless( program: Program, tokenInMint: PublicKey, // e.g., USDC mint tokenOutMint: PublicKey, // e.g., ONyc mint tokenInAmount: number, // Amount in base units (1 USDC = 1_000_000) user: Keypair, boss: PublicKey, // Get from state account tokenInProgram: PublicKey = TOKEN_PROGRAM_ID, tokenOutProgram: PublicKey = TOKEN_PROGRAM_ID ) { const tx = await program.methods .takeOfferPermissionless(new BN(tokenInAmount), null) .accounts({ tokenInMint, tokenOutMint, user: user.publicKey, tokenInProgram, tokenOutProgram, boss, vaultAuthority: pdas.vaultAuthority, permissionlessAuthority: pdas.permissionlessAuthority, mintAuthority: pdas.mintAuthority, }) .signers([user]) .rpc(); console.log("Transaction signature:", tx); return tx; } // Usage Example async function main() { const connection = new Connection("https://api.mainnet-beta.solana.com"); const wallet = /* your wallet */; const provider = new AnchorProvider(connection, wallet, {}); const program = new Program(idl, provider); // Token mints const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); const ONYC_MINT = new PublicKey("..."); // ONyc mint address // Get boss from state const state = await program.account.state.fetch(pdas.state); const boss = state.boss; // Execute: swap 100 USDC for ONyc await takeOfferPermissionless( program, USDC_MINT, ONYC_MINT, 100_000_000, // 100 USDC (6 decimals) userKeypair, boss ); } ``` #### Building Transaction Manually (Low-Level) Use this approach when building transactions without Anchor or for CPI. ```typescript import { TransactionInstruction, PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, } from "@solana/web3.js"; import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, } from "@solana/spl-token"; const PROGRAM_ID = new PublicKey("onreuGhHHgVzMWSkj2oQDLDtvvGvoepBPkqyaubFcwe"); const DISCRIMINATOR = Buffer.from([37, 190, 224, 77, 197, 39, 203, 230]); function buildTakeOfferPermissionlessInstruction( tokenInMint: PublicKey, tokenOutMint: PublicKey, tokenInAmount: bigint, user: PublicKey, boss: PublicKey, tokenInProgram: PublicKey = TOKEN_PROGRAM_ID, tokenOutProgram: PublicKey = TOKEN_PROGRAM_ID ): TransactionInstruction { // Derive PDAs const [statePda] = PublicKey.findProgramAddressSync( [Buffer.from("state")], PROGRAM_ID ); const [offerPda] = PublicKey.findProgramAddressSync( [Buffer.from("offer"), tokenInMint.toBuffer(), tokenOutMint.toBuffer()], PROGRAM_ID ); const [vaultAuthorityPda] = PublicKey.findProgramAddressSync( [Buffer.from("offer_vault_authority")], PROGRAM_ID ); const [permissionlessAuthorityPda] = PublicKey.findProgramAddressSync( [Buffer.from("permissionless-1")], PROGRAM_ID ); const [mintAuthorityPda] = PublicKey.findProgramAddressSync( [Buffer.from("mint_authority")], PROGRAM_ID ); // Derive ATAs const vaultTokenInAccount = getAssociatedTokenAddressSync( tokenInMint, vaultAuthorityPda, true, tokenInProgram ); const vaultTokenOutAccount = getAssociatedTokenAddressSync( tokenOutMint, vaultAuthorityPda, true, tokenOutProgram ); const permissionlessTokenInAccount = getAssociatedTokenAddressSync( tokenInMint, permissionlessAuthorityPda, true, tokenInProgram ); const permissionlessTokenOutAccount = getAssociatedTokenAddressSync( tokenOutMint, permissionlessAuthorityPda, true, tokenOutProgram ); const userTokenInAccount = getAssociatedTokenAddressSync( tokenInMint, user, false, tokenInProgram ); const userTokenOutAccount = getAssociatedTokenAddressSync( tokenOutMint, user, false, tokenOutProgram ); const bossTokenInAccount = getAssociatedTokenAddressSync( tokenInMint, boss, false, tokenInProgram ); // Build instruction data // Format: discriminator (8 bytes) + token_in_amount (8 bytes) + approval_message (1 byte for None) const data = Buffer.alloc(8 + 8 + 1); DISCRIMINATOR.copy(data, 0); data.writeBigUInt64LE(tokenInAmount, 8); data.writeUInt8(0, 16); // 0 = None for Option const keys = [ { pubkey: offerPda, isSigner: false, isWritable: true }, { pubkey: statePda, isSigner: false, isWritable: false }, { pubkey: boss, isSigner: false, isWritable: false }, { pubkey: vaultAuthorityPda, isSigner: false, isWritable: false }, { pubkey: vaultTokenInAccount, isSigner: false, isWritable: true }, { pubkey: vaultTokenOutAccount, isSigner: false, isWritable: true }, { pubkey: permissionlessAuthorityPda, isSigner: false, isWritable: false }, { pubkey: permissionlessTokenInAccount, isSigner: false, isWritable: true }, { pubkey: permissionlessTokenOutAccount, isSigner: false, isWritable: true }, { pubkey: tokenInMint, isSigner: false, isWritable: true }, { pubkey: tokenInProgram, isSigner: false, isWritable: false }, { pubkey: tokenOutMint, isSigner: false, isWritable: true }, { pubkey: tokenOutProgram, isSigner: false, isWritable: false }, { pubkey: userTokenInAccount, isSigner: false, isWritable: true }, { pubkey: userTokenOutAccount, isSigner: false, isWritable: true }, { pubkey: bossTokenInAccount, isSigner: false, isWritable: true }, { pubkey: mintAuthorityPda, isSigner: false, isWritable: false }, { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false }, { pubkey: user, isSigner: true, isWritable: true }, { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }, ]; return new TransactionInstruction({ programId: PROGRAM_ID, keys, data, }); } ``` ### Integration: `take_offer` The direct flow requires fewer accounts but uses direct user-to-boss transfers. #### Instruction Discriminator `[137, 6, 172, 191, 222, 117, 178, 131]` #### Using Anchor Client ```typescript async function takeOffer( program: Program, tokenInMint: PublicKey, tokenOutMint: PublicKey, tokenInAmount: number, user: Keypair, tokenInProgram: PublicKey = TOKEN_PROGRAM_ID, tokenOutProgram: PublicKey = TOKEN_PROGRAM_ID ) { // Anchor automatically resolves most accounts const tx = await program.methods .takeOffer(new BN(tokenInAmount), null) .accounts({ tokenInMint, tokenOutMint, user: user.publicKey, tokenInProgram, tokenOutProgram, }) .signers([user]) .rpc(); return tx; } ``` ### Fetching Market Data #### Get Boss Address ```typescript async function getBoss(program: Program): Promise { const [statePda] = PublicKey.findProgramAddressSync( [Buffer.from("state")], PROGRAM_ID ); const state = await program.account.state.fetch(statePda); return state.boss; } ``` #### Check Offer Configuration ```typescript async function getOfferInfo( program: Program, tokenInMint: PublicKey, tokenOutMint: PublicKey ) { const [offerPda] = PublicKey.findProgramAddressSync( [Buffer.from("offer"), tokenInMint.toBuffer(), tokenOutMint.toBuffer()], PROGRAM_ID ); const offer = await program.account.offer.fetch(offerPda); return { feeBasisPoints: offer.feeBasisPoints, // Fee in basis points (100 = 1%) needsApproval: offer.needsApproval !== 0, // Whether offer requires approval allowPermissionless: offer.allowPermissionless !== 0, vectors: offer.vectors.filter(v => v.startTime !== 0), // Active pricing vectors }; } ``` #### Get Current NAV (Price) ```typescript async function getCurrentNav( program: Program, tokenInMint: PublicKey, tokenOutMint: PublicKey ): Promise { const nav = await program.methods .getNav() .accounts({ tokenInMint, tokenOutMint, }) .view(); // NAV is a u64 with 9 decimal precision // 1.0 = 1_000_000_000 return Number(nav) / 1e9; } ``` #### Get Current APY ```typescript async function getCurrentApy( program: Program, tokenInMint: PublicKey, tokenOutMint: PublicKey ): Promise { const apy = await program.methods .getApy() .accounts({ tokenInMint, tokenOutMint, }) .view(); // APY is scaled by 1_000_000 (1_000_000 = 1%) return Number(apy) / 1_000_000; } ``` #### Calculate Expected Output ```typescript function calculateExpectedOutput( tokenInAmount: number, // Amount user wants to pay (base units) tokenInDecimals: number, // e.g., 6 for USDC tokenOutDecimals: number, // e.g., 9 for ONyc currentNav: number, // From getNav(), already divided by 1e9 feeBasisPoints: number // From offer account ): bigint { // Calculate fee const feeAmount = Math.floor(tokenInAmount * feeBasisPoints / 10000); const netAmount = tokenInAmount - feeAmount; // Calculate output // Formula: token_out = (net_amount * 10^(token_out_decimals + 9)) / (nav * 10^token_in_decimals) const navWithScale = BigInt(Math.floor(currentNav * 1e9)); const tokenOutAmount = (BigInt(netAmount) * BigInt(10 ** (tokenOutDecimals + 9))) / (navWithScale * BigInt(10 ** tokenInDecimals)); return tokenOutAmount; } // Example: Calculate how much ONyc for 100 USDC const usdcAmount = 100_000_000; // 100 USDC (6 decimals) const nav = await getCurrentNav(program, USDC_MINT, ONYC_MINT); const offer = await getOfferInfo(program, USDC_MINT, ONYC_MINT); const expectedOnyc = calculateExpectedOutput( usdcAmount, 6, // USDC decimals 9, // ONyc decimals nav, offer.feeBasisPoints ); console.log(`Expected ONyc: ${Number(expectedOnyc) / 1e9}`); ``` ### Pricing Model The OnRe program uses a **discrete interval pricing model** with APR-based growth. #### How Price is Calculated 1. Find Active Vector: The program finds the pricing vector with the latest `start_time` ≤ current time 2. Calculate Interval: `interval = floor((current_time - base_time) / price_fix_duration)` 3. Calculate Effective Time: `effective_time = (interval + 1) * price_fix_duration` 4. Calculate Price: `price = base_price * (1 + apr * effective_time / SECONDS_IN_YEAR)` **Constants:** * `base_price` has 9 decimal precision (1.0 = 1,000,000,000) * `apr` is scaled by 1,000,000 (1% APR = 1,000,000) * `SECONDS_IN_YEAR` = 31,536,000 #### Example Price Calculation ```typescript const SECONDS_IN_YEAR = 31_536_000; const APR_SCALE = 1_000_000; function calculatePrice( basePrice: number, // e.g., 1_000_000_000 for $1.00 apr: number, // e.g., 36_500 for 3.65% APR baseTime: number, // Unix timestamp priceFixDuration: number, // e.g., 86400 for daily intervals currentTime: number // Current Unix timestamp ): number { const elapsedSinceBase = currentTime - baseTime; const currentStep = Math.floor(elapsedSinceBase / priceFixDuration); const effectiveTime = (currentStep + 1) * priceFixDuration; // price = base_price * (1 + apr * effective_time / SECONDS_IN_YEAR) const factor = 1 + (apr / APR_SCALE) * (effectiveTime / SECONDS_IN_YEAR); return Math.floor(basePrice * factor); } ``` ### Error Handling #### Common Error Codes | Error | Code | Description | | -------------------------- | ---- | ------------------------------------------- | | `NoActiveVector` | 6001 | No pricing vector is active at current time | | `KillSwitchActivated` | 6002 | Program operations are halted | | `PermissionlessNotAllowed` | 6003 | Offer doesn't allow permissionless access | | `InvalidBoss` | 6004 | Boss account doesn't match state | | `ApprovalRequired` | 6005 | Offer requires approval message | | `InvalidTokenInMint` | 6006 | Token in mint doesn't match offer | | `InvalidTokenOutMint` | 6007 | Token out mint doesn't match offer | | `OverflowError` | 6008 | Arithmetic overflow in calculations | #### Error Handling Example ```typescript try { await takeOfferPermissionless(/* params */); } catch (error) { if (error.message.includes("No active vector")) { console.error("No pricing vector is currently active. Check offer configuration."); } else if (error.message.includes("Kill switch is activated")) { console.error("Program is temporarily halted. Try again later."); } else if (error.message.includes("Permissionless take offer not allowed")) { console.error("This offer requires the direct take_offer instruction."); } else if (error.message.includes("insufficient funds")) { console.error("Insufficient token balance or vault liquidity."); } throw error; } ``` ### CPI from Rust Programs For calling `take_offer_permissionless` from another Solana program via CPI: ```rust use anchor_lang::prelude::*; // OnRe program ID pub const ONRE_PROGRAM_ID: Pubkey = pubkey!("onreuGhHHgVzMWSkj2oQDLDtvvGvoepBPkqyaubFcwe"); // Instruction discriminator for take_offer_permissionless pub const TAKE_OFFER_PERMISSIONLESS_DISCRIMINATOR: [u8; 8] = [37, 190, 224, 77, 197, 39, 203, 230]; #[derive(AnchorSerialize, AnchorDeserialize)] pub struct TakeOfferPermissionlessArgs { pub token_in_amount: u64, pub approval_message: Option, } #[derive(AnchorSerialize, AnchorDeserialize, Clone)] pub struct ApprovalMessage { pub program_id: Pubkey, pub user_pubkey: Pubkey, pub expiry_unix: u64, } pub fn cpi_take_offer_permissionless<'info>( onre_program: AccountInfo<'info>, offer: AccountInfo<'info>, state: AccountInfo<'info>, boss: AccountInfo<'info>, vault_authority: AccountInfo<'info>, vault_token_in_account: AccountInfo<'info>, vault_token_out_account: AccountInfo<'info>, permissionless_authority: AccountInfo<'info>, permissionless_token_in_account: AccountInfo<'info>, permissionless_token_out_account: AccountInfo<'info>, token_in_mint: AccountInfo<'info>, token_in_program: AccountInfo<'info>, token_out_mint: AccountInfo<'info>, token_out_program: AccountInfo<'info>, user_token_in_account: AccountInfo<'info>, user_token_out_account: AccountInfo<'info>, boss_token_in_account: AccountInfo<'info>, mint_authority: AccountInfo<'info>, instructions_sysvar: AccountInfo<'info>, user: AccountInfo<'info>, associated_token_program: AccountInfo<'info>, system_program: AccountInfo<'info>, token_in_amount: u64, signer_seeds: Option<&[&[&[u8]]]>, ) -> Result<()> { let args = TakeOfferPermissionlessArgs { token_in_amount, approval_message: None, // Always None for permissionless }; let mutdata = TAKE_OFFER_PERMISSIONLESS_DISCRIMINATOR.to_vec(); args.serialize(&mut data)?; let accounts = vec![ AccountMeta::new(offer.key(), false), AccountMeta::new_readonly(state.key(), false), AccountMeta::new_readonly(boss.key(), false), AccountMeta::new_readonly(vault_authority.key(), false), AccountMeta::new(vault_token_in_account.key(), false), AccountMeta::new(vault_token_out_account.key(), false), AccountMeta::new_readonly(permissionless_authority.key(), false), AccountMeta::new(permissionless_token_in_account.key(), false), AccountMeta::new(permissionless_token_out_account.key(), false), AccountMeta::new(token_in_mint.key(), false), AccountMeta::new_readonly(token_in_program.key(), false), AccountMeta::new(token_out_mint.key(), false), AccountMeta::new_readonly(token_out_program.key(), false), AccountMeta::new(user_token_in_account.key(), false), AccountMeta::new(user_token_out_account.key(), false), AccountMeta::new(boss_token_in_account.key(), false), AccountMeta::new_readonly(mint_authority.key(), false), AccountMeta::new_readonly(instructions_sysvar.key(), false), AccountMeta::new(user.key(), true), AccountMeta::new_readonly(associated_token_program.key(), false), AccountMeta::new_readonly(system_program.key(), false), ]; let ix = solana_program::instruction::Instruction { program_id: ONRE_PROGRAM_ID, accounts, data, }; let account_infos = vec![ offer, state, boss, vault_authority, vault_token_in_account, vault_token_out_account, permissionless_authority, permissionless_token_in_account, permissionless_token_out_account, token_in_mint, token_in_program, token_out_mint, token_out_program, user_token_in_account, user_token_out_account, boss_token_in_account, mint_authority, instructions_sysvar, user, associated_token_program, system_program, onre_program, ]; match signer_seeds { Some(seeds) => solana_program::program::invoke_signed(&ix, &account_infos, seeds), None => solana_program::program::invoke(&ix, &account_infos), }?; Ok(()) } ``` #### Rust PDA Derivation ```rust use anchor_lang::prelude::*; let program_id = &onreapp::ID; // State PDA let (state_pda, _) = Pubkey::find_program_address(&[b"state"], program_id); // Offer PDA let (offer_pda, _) = Pubkey::find_program_address( &[b"offer", token_in_mint.as_ref(), token_out_mint.as_ref()], program_id ); // Vault Authority PDA let (vault_authority_pda, _) = Pubkey::find_program_address( &[b"offer_vault_authority"], program_id ); // Permissionless Authority PDA let (permissionless_authority_pda, _) = Pubkey::find_program_address( &[b"permissionless-1"], program_id ); // Mint Authority PDA let (mint_authority_pda, _) = Pubkey::find_program_address( &[b"mint_authority"], program_id ); ``` ### Support * GitHub: * Telegram / Email: * Theodore Georgas: @tgeorgas / * Nuno Carvalho: @nmcarv / * Aleksandar Marinkovic: @mankoxyz /