A crate to interact with the Credix program via CPI
NOTE: This crate was generated with the help of the Anchor generated IDL and adds a few extra functions in addition to the generated code. To know certain pda seeds or which accounts are mutable, please refer back to the Credix program IDL. It is available for each environment in the source of this crate.
crdRi38zEhQdzpsxnKur73WHBM9BSvXMSfGcbLyJCdP.credix-marketplace on pre-mainnet should be targeted for testing without withdraw epochs.withdraw-epochs on pre-mainnet should be targeted for testing with withdraw epochs.To target our pre-mainnet environment you can enable the pre-mainnet feature
toml
credix_client = { version="0.8.0", features = ["pre-mainnet"], default-features = false }
CRDx2YkdtYtGZXGHZ59wNv1EwKHQndnRc1gT4p8i2vPXNote: To use any market on any Credix environment, you will need an active Credix pass with certain permissions set. Contact Credix to have one issued.
To target our mainnet environment you can enable the mainnet feature
toml
credix_client = { version="0.8.0", features = ["mainnet"], default-features = false }
When creating a local setup it's advised to grab the pre-mainnet binary from the Solana devnet cluster when preparing for upcoming Credix mainnet releases. This can be done using following command:
sh
solana program dump -u d crdRi38zEhQdzpsxnKur73WHBM9BSvXMSfGcbLyJCdP ./credix.so
Day to day stable testing can be done by grabbing the mainnet binary using following command:
```sh solana program dump -u m CRDx2YkdtYtGZXGHZ59wNv1EwKHQndnRc1gT4p8i2vPX ./credix.so
```
To get to a working local environment certain instructions have to be called to set up everything. The following instructions should be called in the same order.
You can find more cargo docs information for each instruction.
You can find more cargo docs information for each account.
initialize_program_stateInitializes the ProgramState account that is shared across the entire Credix ecosystem for management purposes. This will allow you to create markets.
initialize_marketCreates a market.
issue_credix_passThis gives permissions to any participant in the market. It can only be issued by either a key that is listed as a pass issuer in the MarketAdmins account or by the multisig specified in the ProgramState.
Any user interaction with a market requires an active Credix pass.
deposit_fundsThis deposits funds into the pool in exchange for LP tokens.
create_withdraw_epochCreates a withdraw epoch. This needs to happen before anyone can participate in an epoch. The epoch needs to be created when the previous one is completely over.
create_withdraw_requestCreates a withdraw request. This is where you request a certain amount to withdraw. Depending on the amounts requested by other participants in the epoch and the money available in the market pool, a certain amount will be made available in a first instance. Then a second round happens where amounts that weren't withdrawn become available to the rest of the participants. The duration of the different phases and other parameters are specified on the market level.
redeem_requestHere we actually withdraw funds during either the redeem phase or the free for all phase.
So far no interest repayments have happened so no change in the LP price has occurred. To include this scenario in your tests you need to do a few steps. Again, following instructions need to be done in order and before the withdraw epoch setup to see the effect and more information can be found in the same places as described before.
For convenience's sake we will provide some basic configurations to use to be able to trigger an interest repayment.
create_dealCreates a deal.
rust
max_funding_duration: 255,
deal_name: "Simple Deal",
arrangement_fees: 0,
arrangement_fee_percentage: Fraction::new(0,100),
migrated: false,
set_repayment_scheduleSets the repayment schedule. This defines when repayments need to happen and according to what waterfall they need to be processed.
```rust let now = system_time::now(); // now will contain the current unix timestamp in ms. let principal = 1000000;
let configforinstruction= RepaymentScheduleConfig { periods: vec![ RepaymentPeriodInput { waterfallindex: 0, accrualindays: 30, principalexpected: None, timeframe: TimeFrame { start: now, end: now + 30 * SECONDSINDAY - 1, }, }, RepaymentPeriodInput { waterfallindex: 1, accrualindays: 30, principalexpected: Some(principal), timeframe: TimeFrame { start: now + 30 * SECONDSINDAY, end: now + 60 * SECONDSINDAY - 1, }, } ], startts: now, daycountconvention: DaycountConvention::Act360, waterfalldefinitions: vec![ DistributionWaterfall { waterfalltype: DistributionWaterfallType::Revolving, tiers: vec![ WaterfallTier { allocations: vec![RepaymentAllocation::Interest], trancheindices: vec![0], charge: true, slash: false, }, ], }, DistributionWaterfall { waterfalltype: DistributionWaterfallType::Amortization, tiers: vec![ WaterfallTier { allocations: vec![ RepaymentAllocation::Principal, RepaymentAllocation::Interest ], tranche_indices: vec![0], charge: true, slash: false, } ], }, ], }; ```
set_tranchesHere we define the composition of the deal in tranches. Tranches are the investment opportunities of a deal.
This includes a tranche that is funded by the pool. This means that when the deal is activated, money will flow from the market's liquidity pool towards the deal.
rust
vec![
TrancheConfig {
index: 0,
max_deposit_percentage: Fraction::new(1, 1).unwrap(),
early_withdrawal_principal: true,
funded_by_liquidity_pool: true,
name: "A".to_string(),
size: principal, // the variable we declared earlier
interest: Fraction::new(12, 10).unwrap(),
interest_performance_fee: Fraction::new(1, 10).unwrap(),
principal_performance_fee: Fraction::new(0, 1).unwrap(),
membership_fee: Fraction::new(1, 10).unwrap(),
late_interest: Fraction::new(1, 10).unwrap(),
early_principal: Fraction::new(1, 10).unwrap(),
late_principal: Fraction::new(1, 10).unwrap(),
},
],
open_dealOnce a deal has been fully configured, we have to change it's status to allow investors to invest into it. This opens the deal for funding.
activate_dealOnce a deal has been fully funded (which is automatically the case using the configs we provided), a deal needs to be activated. This marks the moment funds move from the liquidity pool towards the deal to fund the pool funded tranches. The actual borrowed amount becomes available to the borrower.
repay_dealThis allows the borrower to repay the deal. At this point interest will flow towards the pool and the LP price should rise and your investment should have RoI.
The LP token price is the TVL divided by the total supply of LP tokens. The TVL is equal to the total outstanding credit and the funds in the liquidity pool token account.
It can be found on-chain using following calculation:
```rust let poolliquidity = liquiditypooltokenaccount.amount; let outstandingcredit = globalmarketstate.pooloutstandingcredit; let tvl = poolliquidity + outstanding_credit;
let lpsupply = lptoken_mint.supply;
let lpprice = tvl / lpsupply; ```
This is an example rust program made with anchor, here we have CPI for deposit, withdraw, create withdraw request and redeem withdraw request.
```Rust use anchorlang::prelude::*; use credixclient::cpi::accounts::{ CreateWithdrawRequest, DepositFunds, RedeemWithdrawRequest, WithdrawFunds, }; use credixclient::cpi::{ createwithdrawrequest, depositfunds, redeemwithdrawrequest, withdraw_funds, };
declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");
pub mod integrator { use super::*;
pub fn deposit_cpi(ctx: Context<DepositFundsCpi>, amount: u64) -> Result<()> {
let cpi_context = CpiContext::new(
ctx.accounts.credix_program.to_account_info(),
DepositFunds {
investor: ctx.accounts.investor.to_account_info(),
global_market_state: ctx.accounts.global_market_state.to_account_info(),
signing_authority: ctx.accounts.signing_authority.to_account_info(),
investor_token_account: ctx.accounts.investor_token_account.to_account_info(),
credix_pass: ctx.accounts.credix_pass.to_account_info(),
investor_lp_token_account: ctx.accounts.investor_lp_token_account.to_account_info(),
liquidity_pool_token_account: ctx
.accounts
.liquidity_pool_token_account
.to_account_info(),
lp_token_mint: ctx.accounts.lp_token_mint.to_account_info(),
rent: ctx.accounts.rent.to_account_info(),
system_program: ctx.accounts.system_program.to_account_info(),
token_program: ctx.accounts.token_program.to_account_info(),
associated_token_program: ctx.accounts.associated_token_program.to_account_info(),
base_token_mint: ctx.accounts.base_token_mint.to_account_info(),
},
);
deposit_funds(cpi_context, amount)?;
Ok(())
}
pub fn withdraw_cpi(ctx: Context<WithdrawFundsCpi>, amount: u64) -> Result<()> {
let cpi_context = CpiContext::new(
ctx.accounts.credix_program.to_account_info(),
WithdrawFunds {
investor: ctx.accounts.investor.to_account_info(),
global_market_state: ctx.accounts.global_market_state.to_account_info(),
signing_authority: ctx.accounts.signing_authority.to_account_info(),
investor_lp_token_account: ctx.accounts.investor_lp_token_account.to_account_info(),
investor_token_account: ctx.accounts.investor_token_account.to_account_info(),
liquidity_pool_token_account: ctx
.accounts
.liquidity_pool_token_account
.to_account_info(),
lp_token_mint: ctx.accounts.lp_token_mint.to_account_info(),
program_state: ctx.accounts.program_state.to_account_info(),
credix_treasury: ctx.accounts.credix_treasury.to_account_info(),
credix_treasury_token_account: ctx
.accounts
.credix_treasury_token_account
.to_account_info(),
treasury_pool_token_account: ctx
.accounts
.treasury_pool_token_account
.to_account_info(),
credix_pass: ctx.accounts.credix_pass.to_account_info(),
base_token_mint: ctx.accounts.base_token_mint.to_account_info(),
associated_token_program: ctx.accounts.associated_token_program.to_account_info(),
token_program: ctx.accounts.token_program.to_account_info(),
rent: ctx.accounts.rent.to_account_info(),
system_program: ctx.accounts.system_program.to_account_info(),
},
);
withdraw_funds(cpi_context, amount)?;
Ok(())
}
pub fn create_withdraw_request_cpi(
ctx: Context<WithdrawRequestCpi>,
amount: u64,
) -> Result<()> {
let accounts = ctx.accounts;
let cpi_context = CpiContext::new(
accounts.credix.to_account_info(),
CreateWithdrawRequest {
payer: accounts.payer.to_account_info(),
investor: accounts.investor.to_account_info(),
credix_pass: accounts.credix_pass.to_account_info(),
global_market_state: accounts.global_market_state.to_account_info(),
investor_lp_token_account: accounts.investor_lp_token_account.to_account_info(),
liquidity_pool_token_account: accounts
.liquidity_pool_token_account
.to_account_info(),
lp_token_mint: accounts.lp_token_mint.to_account_info(),
signing_authority: accounts.signing_authority.to_account_info(),
system_program: accounts.system_program.to_account_info(),
withdraw_epoch: accounts.withdraw_epoch.to_account_info(),
},
);
create_withdraw_request(cpi_context, amount)
}
pub fn redeem_request_cpi(ctx: Context<RedeemRequestCpi>, amount: u64) -> Result<()> {
let accounts = ctx.accounts;
let cpi_context = CpiContext::new(
accounts.credix.to_account_info(),
RedeemWithdrawRequest {
investor: accounts.investor.to_account_info(),
credix_pass: accounts.credix_pass.to_account_info(),
global_market_state: accounts.global_market_state.to_account_info(),
investor_lp_token_account: accounts.investor_lp_token_account.to_account_info(),
liquidity_pool_token_account: accounts
.liquidity_pool_token_account
.to_account_info(),
lp_token_mint: accounts.lp_token_mint.to_account_info(),
signing_authority: accounts.signing_authority.to_account_info(),
system_program: accounts.system_program.to_account_info(),
withdraw_epoch: accounts.withdraw_epoch.to_account_info(),
associated_token_program: accounts.associated_token_program.to_account_info(),
base_token_mint: accounts.base_token_mint.to_account_info(),
credix_treasury: accounts.credix_treasury.to_account_info(),
credix_treasury_token_account: accounts
.credix_treasury_token_account
.to_account_info(),
program_state: accounts.program_state.to_account_info(),
investor_token_account: accounts.investor_token_account.to_account_info(),
rent: accounts.rent.to_account_info(),
token_program: accounts.token_program.to_account_info(),
treasury_pool_token_account: accounts.treasury_pool_token_account.to_account_info(),
},
);
redeem_withdraw_request(cpi_context, amount)
}
}
pub struct DepositFundsCpi<'info> { #[account(mut)] pub investor: Signer<'info>, pub credixprogram: Program<'info, Credix>, /// CHECK: test program pub globalmarketstate: AccountInfo<'info>, /// CHECK: test program pub signingauthority: AccountInfo<'info>, /// CHECK: test program #[account(mut)] pub investortokenaccount: AccountInfo<'info>, /// CHECK: test program #[account(mut)] pub liquiditypooltokenaccount: AccountInfo<'info>, /// CHECK: test program #[account(mut)] pub lptokenmint: AccountInfo<'info>, /// CHECK: test program #[account(mut)] pub investorlptokenaccount: AccountInfo<'info>, /// CHECK: test program pub credixpass: AccountInfo<'info>, /// CHECK: test program pub basetokenmint: AccountInfo<'info>, /// CHECK: test program pub associatedtokenprogram: AccountInfo<'info>, pub rent: Sysvar<'info, Rent>, /// CHECK: test program pub tokenprogram: AccountInfo<'info>, pub system_program: Program<'info, System>, }
pub struct WithdrawFundsCpi<'info> { #[account(mut)] pub investor: Signer<'info>, pub credixprogram: Program<'info, Credix>, #[account(mut)] /// CHECK: test program pub globalmarketstate: AccountInfo<'info>, /// CHECK: test program pub programstate: AccountInfo<'info>, /// CHECK: test program pub signingauthority: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub investorlptokenaccount: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub investortokenaccount: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub liquiditypooltokenaccount: AccountInfo<'info>, /// CHECK: test program pub credixtreasury: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub credixtreasurytokenaccount: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub treasurypooltokenaccount: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub lptokenmint: AccountInfo<'info>, #[account(mut)] /// CHECK: test program pub credixpass: AccountInfo<'info>, /// CHECK: test program pub basetokenmint: AccountInfo<'info>, /// CHECK: test program pub associatedtokenprogram: AccountInfo<'info>, /// CHECK: test program pub tokenprogram: AccountInfo<'info>, pub rent: Sysvar<'info, Rent>, pub system_program: Program<'info, System>, }
pub struct WithdrawRequestCpi<'info> { #[account(mut)] pub payer: Signer<'info>, #[account(mut)] pub investor: Signer<'info>, /// CHECK: pub globalmarketstate: AccountInfo<'info>, /// CHECK: pub signingauthority: AccountInfo<'info>, /// CHECK: #[account()] pub credixpass: AccountInfo<'info>, /// CHECK: #[account(mut)] pub withdrawepoch: AccountInfo<'info>, /// CHECK: #[account()] pub investorlptokenaccount: AccountInfo<'info>, /// CHECK: #[account()] pub liquiditypooltokenaccount: AccountInfo<'info>, /// CHECK: #[account()] pub lptokenmint: AccountInfo<'info>, pub credix: Program<'info, Credix>, pub systemprogram: Program<'info, System>, }
pub struct RedeemRequestCpi<'info> { #[account(mut)] pub investor: Signer<'info>, /// CHECK: #[account(mut)] pub globalmarketstate: AccountInfo<'info>, /// CHECK: #[account(mut)] pub withdrawepoch: AccountInfo<'info>, /// CHECK: #[account()] pub programstate: AccountInfo<'info>, /// CHECK: The check happens when verifying the PDA address. #[account()] pub signingauthority: AccountInfo<'info>, /// CHECK: #[account(mut)] pub investorlptokenaccount: AccountInfo<'info>, /// CHECK: #[account(mut)] pub investortokenaccount: AccountInfo<'info>, /// CHECK: #[account(mut)] pub liquiditypooltokenaccount: AccountInfo<'info>, /// CHECK: The address of account is known. #[account()] pub credixtreasury: AccountInfo<'info>, /// CHECK: #[account(mut)] pub credixtreasurytokenaccount: AccountInfo<'info>, /// CHECK: #[account(mut)] pub treasurypooltokenaccount: AccountInfo<'info>, /// CHECK: #[account(mut)] pub lptokenmint: AccountInfo<'info>, /// CHECK: #[account(mut)] pub credixpass: AccountInfo<'info>, /// CHECK: #[account()] pub basetokenmint: AccountInfo<'info>, /// CHECK: pub associatedtokenprogram: AccountInfo<'info>, /// CHECK: pub tokenprogram: AccountInfo<'info>, pub rent: Sysvar<'info, Rent>, pub system_program: Program<'info, System>, pub credix: Program<'info, Credix>, }
```
For off-chain development we provide a Typescript client to help with gathering different accounts. See the README of that package to get started with it.
```typescript ... const marketName = "credix-marketplace"; const market = await client.fetchMarket(marketName); Our client can help you with finding the keys of following accounts const globalMarketState = market.address; const programState = (await client.fetchProgramState()).address; const signingAuthority = (await market.generateSigningAuthorityPDA())[0]; const investorLpTokenAccount = await market.findLPTokenAccount(investor); const investorTokenAccount = await market.findBaseTokenAccount(investor); const liquidityPoolTokenAccount = await market.findLiquidityPoolTokenAccount(); const credixTreasury = (await client.fetchProgramState()).credixTreasury; const credixTreasuryTokenAccount = await market.findBaseTokenAccount(credixTreasury); const treasuryPoolTokenAccount = market.treasury; const lpTokenMint = market.lpMintPK; const credixPass = (await market.fetchCredixPass(investor)).address const baseTokenMint = await market.baseMintPK;
// Withdraw Epoch related accounts const market = await client.fetchMarket(marketName); const withdrawEpochAddress = WithdrawEpoch.generatePDA(market, market.latestWithdrawEpochIdx); ... ```
This crate also provides functions to help generate PDA's. See the Rust docs
These examples are provided as is. Do not blindly copy paste for use in production.