# Get Earn Portfolio Source: https://docs.loopscale.com/api-reference/data/earn/get-earn-portfolio post /markets/earn/portfolio/positions Returns a wallet's positions across every Earn vault it holds, in the same shape as Get Earn Position. # Get Earn Position Source: https://docs.loopscale.com/api-reference/data/earn/get-earn-position post /markets/earn/vaults/positions Returns a wallet's position in one Earn vault: share balance, cost basis and realized PnL, plus its open withdrawal requests. Use `openWithdrawalRequests[].onChainRequestAddr` as the `requestId` for claiming or cancelling a queued withdrawal. # Get Earn Vault Source: https://docs.loopscale.com/api-reference/data/earn/get-earn-vault get /markets/earn/vaults/{address} Returns one Earn vault and its latest snapshot by on-chain vault address. `parsedAccountJson` holds the decoded provider account, including token entries, strategy positions and withdrawal configuration. # Get Earn Vault History Source: https://docs.loopscale.com/api-reference/data/earn/get-earn-vault-history post /markets/earn/vaults/history Returns snapshot history for a vault. `timeLookback` is the window in seconds back from now; `sampleIntervalSecs` optionally buckets the points (for example `3600` for hourly). # Get Earn Vaults Source: https://docs.loopscale.com/api-reference/data/earn/get-earn-vaults get /markets/earn/vaults Returns every registered Earn vault with its latest snapshot (share supply, NAV per share, AUM, realized and display APY). `status` is `0` Draft, `1` Active, `2` Paused, `3` Deprecated. `acceptedAssetMint` is the vault's underlying deposit mint and `shareMint` is its LP token. `metadataJson.tags` may include `urlAccessOnly` for vaults that are reachable by link but not listed. # Get Earn Withdrawal Queue Source: https://docs.loopscale.com/api-reference/data/earn/get-earn-withdrawal-queue post /markets/earn/vaults/queue Returns open withdrawal requests, filterable by vault (`address` or `vaultAddresses`) and `wallet`, with queue depth in shares. Set `includeClosed` to also return claimed and cancelled requests. `sortDirection` is `0` ascending, `1` descending. # Get Loop info Source: https://docs.loopscale.com/api-reference/data/loops/get-loop-info post /markets/loop/info Returns Loop vault info keyed by Loop vault identifier. You can filter by explicit vault identifiers and/or by tags. # Get best quote Source: https://docs.loopscale.com/api-reference/data/markets/get-best-quote post /markets/quote/max Returns the top quote for each specified collateral asset based on available liquidity. This endpoint is designed for minimizing rate slippage for a borrow with known inputs. # Get quotes Source: https://docs.loopscale.com/api-reference/data/markets/get-quotes post /markets/quote Returns a list of current lend orders available for the specified principal token, collateral, and target duration. Results are sorted by APY and support pagination. # Get loan info Source: https://docs.loopscale.com/api-reference/data/positions/get-loan-info post /markets/loans/info Returns a list of loans filtered by request. Results support pagination. # Get strategies Source: https://docs.loopscale.com/api-reference/data/strategies/get-strategies post /markets/strategy/infos Returns a list of strategy data matching the filters. A Strategy is the onchain capital escrow and lending ruleset that sits behind every Vault. It holds deposited capital, deploys it as advanced lending orders on the credit order book according to curator-defined parameters (eligible collateral, rates, durations), and tracks accrued interest and external yield. Use this endpoint to query strategy-level data directly — for example, when computing Vault TVL or APY from raw fields rather than pre-aggregated Vault metadata. # Get collateral holders Source: https://docs.loopscale.com/api-reference/data/user/get-collateral-holders post /markets/collateral/holders Fetches a list of users and total balances for one or more specified collateral mints. # Get historical collateral holders Source: https://docs.loopscale.com/api-reference/data/user/get-historical-collateral-holders post /markets/collateral/holders/historical Returns, for each holder, the integral of their collateral balance over the requested time window — expressed as deposit-seconds (decimal-adjusted collateral units multiplied by seconds held). Useful for time-weighted depositor rewards, retroactive incentive splits, etc. Event sources folded in: * AddCollateral (+amount, decimal-adjusted) * RemoveCollateral (−amount) * Liquidate (−sum of collateralTransfers[] matching the target mint where toLiquidator = true; the row's top-level amount is principal repaid and is ignored for collateral accounting) Events with eventTime < rangeStart are collapsed into a single bucket at rangeStart so they establish the starting balance for the window. Events at exactly rangeEnd contribute zero seconds. The mint filter is applied against loan_events_v1.asset_identifier for Add/Remove events and against per-transfer assetMint inside Liquidate metadata. For single-mint collateral these are equal; for CLP/LP collateral, asset_identifier is the pool id — callers should pass the pool id, not an underlying token mint. # Get Vault depositors Source: https://docs.loopscale.com/api-reference/data/user/get-vault-depositors post /markets/lending_vaults/deposits Fetches a list of users and total balances grouped by Vault. # Get Vaults Source: https://docs.loopscale.com/api-reference/data/vaults/get-vaults post /markets/lending_vaults/info Returns a list of raw Vault metadata and data that match filters. # Integrate Earn Vaults Source: https://docs.loopscale.com/api-reference/guides/earn-integration Earn vaults are curated strategy vaults run through external vault providers (today, [Exponent Strategy Vaults](/protocol-concepts/earn-vault-architecture)). A deposit mints vault shares (LP tokens) priced at the vault's NAV. Withdrawals redeem shares instantly from reserves or through a withdrawal queue. This guide walks through the full flow. Data lives on the markets API (`https://tars.loopscale.com/v1/markets`). Transactions are built by the Pandora API (`https://tars.loopscale.com/v1/pandora`). For how the vault works underneath, see [Earn Vault Architecture](/protocol-concepts/earn-vault-architecture) and [Earn Vault Flows](/protocol-concepts/earn-vault-flows). ## 1. Find a vault [Get Earn Vaults](/api-reference/data/earn/get-earn-vaults) lists every registered vault with its latest snapshot. That includes Draft vaults that aren't open for deposits yet, so filter on `status == 1` before offering deposits. The fields you need most: | Field | Meaning | | - | - | | `address` | Vault address, used by every other endpoint | | `status` | `0` Draft, `1` Active, `2` Paused, `3` Deprecated | | `acceptedAssetMint` | Default deposit token (the vault's underlying) | | `acceptedAssetMints` | Tokens Loopscale offers for deposit and payout, underlying first | | `shareMint` | The vault's LP token | | `queueEnabled`, `instantEnabled`, `cancelEnabled` | Which withdrawal paths the vault offers | | `requiresAcknowledgment` | Whether a wallet must accept the vault's terms before depositing | | `latestSnapshot.navPerShareE18` | Value of one share in the underlying, scaled by 1e18 | | `latestSnapshot.totalAumAssets` | Vault AUM in underlying base units | | `latestSnapshot.headlineApyBps` | The APY to display: forward APY (or 7-day realized return when there's none) plus rewards | | `latestSnapshot.displayApyBps` | Forward-looking APY from the vault's current positions | | `latestSnapshot.realizedReturnBps7d` | Annualized NAV change over 7 days (also `24h` and `30d`) | `realizedApyBps*` fields are deprecated aliases of `realizedReturnBps*`. Use the new names. > [!WARNING] > > The transaction endpoints don't check `status`, the withdrawal flags, or `requiresAcknowledgment`. They'll build a deposit for a Draft vault or a cancel on a vault with `cancelEnabled: false` (the latter then fails onchain). Gate these in your own UI, the way the Loopscale app does. [Get Earn Vault History](/api-reference/data/earn/get-earn-vault-history) returns the same snapshot fields over time for charts, newest first. Snapshots are taken every 15 minutes. ### Reading vault configuration `parsedAccountJson.exponentStrategyVault` on [Get Earn Vault](/api-reference/data/earn/get-earn-vault) is the decoded onchain vault account. Fields worth knowing: | Path | Meaning | | - | - | | `tokenEntries[]` | Tokens the vault can hold, deposit, and pay out in | | `strategyPositions[]` | Positions tracked for NAV | | `financials` | `aumInBase` (idle), `aumInBaseInPositions` (deployed), `lpBalance`, pending withdrawals, instant-window state | | `reservesConfig.reservesShareBp` | Idle reserve floor, in bps of AUM | | `reservesConfig.fastWithdrawalCutBp` | Extra fee on instant withdrawals, in bps | | `reservesConfig.managementFeeBps` | Management fee in **millionths** (`10000` = 1%/yr) | | `reservesConfig.withdrawalPeriod` | `Interval` lock time, or `WeeklySchedule` (`daysOfWeek` bitmask, bit 0 = Sunday, UTC) | | `normalWithdrawalCutBp` | Standard withdrawal fee, in bps | | `maxAumSupply` | Deposit cap | | `proposalVoteConfig` | Voting period, timelock, rejection threshold (in millionths) | | `roles` | Manager, curator, allocator, and sentinel keys | ## 2. Acknowledge the vault's terms If `requiresAcknowledgment` is `true`, show the vault's terms and call [Acknowledge Earn Vault](/api-reference/transactions/earn/acknowledge) once per wallet before its first deposit. It only records the acceptance (a timestamp on the wallet's position), so it builds no transaction. Check `acknowledgedAt` on [Get Earn Position](/api-reference/data/earn/get-earn-position) to see whether a wallet has already accepted. ## 3. Deposit Call [Deposit to Earn Vault](/api-reference/transactions/earn/deposit) with the wallet and an amount in base units. The response carries two transactions in `txBase64s`: an AUM refresh, then the deposit. Sign both with the wallet and submit them in order as one Jito bundle. ```bash theme={null} curl -X POST https://tars.loopscale.com/v1/pandora/earn/vaults/deposit/tx \ -H "Content-Type: application/json" \ -d '{ "address": "", "wallet": "", "amount": "1000000" }' ``` Pass `minLpOut` to protect against NAV moving between quote and landing. You can estimate expected shares as `amount × 1e18 / navPerShareE18`. Deposits fail onchain if they would exceed the vault's deposit cap. ### Sending the bundle The two transactions must land in the same slot, because the vault program rejects price data that wasn't refreshed in the current slot. Any Jito-compatible sender works. The action transaction already pays the tip. ```ts theme={null} import { VersionedTransaction } from "@solana/web3.js"; import bs58 from "bs58"; const { txBase64s } = await res.json(); const txs = txBase64s.map((b64: string) => VersionedTransaction.deserialize(Buffer.from(b64, "base64")) ); // Keep existing signatures (a queued request is pre-signed by its request account). const signed = await wallet.signAllTransactions(txs); await fetch("https://mainnet.block-engine.jito.wtf/api/v1/bundles", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "sendBundle", params: [signed.map((tx) => bs58.encode(tx.serialize()))], }), }); ``` Transactions carry a blockhash from build time, so sign and send promptly. If a bundle doesn't land, rebuild rather than resending, since the AUM refresh has to be current. ## 4. Track the position [Get Earn Position](/api-reference/data/earn/get-earn-position) returns a wallet's share balance, cost basis and realized PnL in one vault, plus its open withdrawal requests. [Get Earn Portfolio](/api-reference/data/earn/get-earn-portfolio) returns the same for every vault the wallet holds, including vaults where it only has open withdrawal requests. ``` position value (underlying) = (shareBalance + queuedShares) × navPerShareE18 / 1e18 ``` `shareBalance` is the wallet's live share-token balance. `queuedShares` are shares sitting in escrow behind open withdrawal requests, and they still earn until filled. Cost basis is average cost across both. `feesPaidAssets` isn't populated yet and reads `0`. ## 5. Withdraw Call [Withdraw from Earn Vault](/api-reference/transactions/earn/withdraw-request) with `mode`: * `instant` redeems from the vault's reserves right away, paying the withdrawal fee plus the instant fee, while reserves and the per-window instant cap allow. * `queued` opens a withdrawal request. The response's `requestId` identifies it. Either mode accepts `mint` to pick a payout token from `acceptedAssetMints`. Instant mode pays it out directly. For queued requests the mint is recorded as a preference: the manager chooses the payout token(s) at fill time, so check `fills` on the request for what was actually paid. ### Instant capacity Before offering instant mode, estimate capacity from the vault account: ``` reserve headroom = reservesShareBp × totalAum / 1e4 − value of pending queued shares window headroom = instant window cap − already withdrawn this window capacity = min(reserve headroom, window headroom, payout token's idle balance) ``` If a request is larger than capacity, the transaction fails onchain. Offer queued mode instead. ### Queued requests Watch a queued request with [Get Earn Withdrawal Queue](/api-reference/data/earn/get-earn-withdrawal-queue) or Get Earn Position. A request moves through `0` Pending → `1` Partial → `2` Fulfilled, or `3` Cancelled. * **Claim.** [Claim Earn Withdrawal](/api-reference/transactions/earn/claim-withdrawal) pays out everything filled so far. It succeeds only once `sharesFilled > sharesClaimed` **and** the vault's withdrawal period has unlocked (the lock interval, or the next scheduled withdrawal day). * **Cancel.** [Cancel Earn Withdrawal](/api-reference/transactions/earn/cancel-withdrawal) returns the shares. It needs `cancelEnabled`, and the vault's cancel cooldown to have passed. The Loopscale app only offers it while nothing has been filled. Every withdraw, claim and cancel response uses the same two-transaction bundle as a deposit. ## Building directly against the vault program The Pandora API is the easiest path, but you can also build transactions yourself with Exponent's TypeScript SDK (`@exponent-labs/exponent-sdk`). The Pandora endpoints use the same calls: | Action | SDK call on `ExponentVault` | | - | - | | Load vault | `ExponentVault.load({ connection, address })` | | Refresh prices + AUM | `ixsRefreshStrategyVaultPrices(...)`, `ixRefreshAum(...)` | | Deposit | `ixsDepositLiquidity(...)` | | Instant withdraw | `ixExecuteWithdrawalFromReservesWithResolvedAumAccounts(...)` | | Queue withdrawal | `ixQueueWithdrawal(...)` (returns the instruction and a new request keypair that must sign) | | Claim | `ixExecuteWithdrawalWithResolvedAumAccounts(...)` | | Cancel | `ixCancelWithdrawal(...)` | | Instant capacity | `fetchInstantWithdrawalCapacity`, `fetchUserInstantWithdrawalCapacity`, `fetchInstantWithdrawalQuote` | You're then responsible for the same-slot bundling, Kamino/Scope reserve refreshes (Scope's refresh must be the first instruction in its transaction), and lookup tables. See [Exponent's strategy vault developer docs](https://docs.exponent.finance/developer-strategy-vaults/overview). ## Common errors | Code | Name | Meaning | | - | - | - | | 6015 | `LpSupplyMaximumExceeded` | Deposit would exceed the vault's deposit cap | | 6016 | `MinLpOutNotMet` | NAV moved past your `minLpOut` | | 6025 / 6098 | `WithdrawalNotReady` / `WithdrawalLockTimeNotElapsed` | Claim before the withdrawal period unlocked | | 6058 | `WithdrawalsBlocked` | The sentinel has paused withdrawals | | 6080 | `StalePriceData` | A price wasn't refreshed in the same slot; send the bundle together, or rebuild | | 6106 | `ReservesExceeded` | Instant withdrawal would take reserves below the floor; use queued | | 6116 | `WithdrawalCancelCooldownNotElapsed` | Cancel attempted too soon after the request | | 6123 | `AumRefreshRequired` | The action was sent without the AUM refresh in front of it | | 6124 | `NavAumCircuitBreakerActive` | NAV moved more than the vault allows; actions are paused until the sentinel clears it | # Calculate Vault & Loop Metrics Source: https://docs.loopscale.com/api-reference/guides/vault-and-loop-metrics This guide walks through how to compute Vault TVL, Vault APY, rewards APY, and Loop APY using Loopscale's data endpoints. These are the key metrics for building dashboards, portfolio trackers, or any integration that displays Loopscale yield data. ## Vault Metrics Use the [Get Vaults](/api-reference/data/vaults/get-vaults) endpoint to retrieve Vault data. You can also query the [Get Vault Depositors](/api-reference/data/user/get-vault-depositors) endpoint for depositor-level breakdowns. All of the fields referenced below are located in the `vaultStrategy` object of the response. **Example request:** ```bash Example theme={null} curl -X POST https://tars.loopscale.com/v1/markets/lending_vaults/info \ -H "Content-Type: application/json" \ -d '{ "page": 0, "pageSize": 10, "includeRewards": true }' ``` ### Computing Vault TVL Sum the following fields from `vaultStrategy.strategy`: ```javascript Example theme={null} const SECONDS_PER_YEAR = 31_536_000; const vaultTvl = strategy.tokenBalance + strategy.externalYieldAmount + strategy.currentDeployedAmount + strategy.outstandingInterestAmount; ``` | Field | Description | | :- | :- | | `tokenBalance` | Idle tokens held in the Vault | | `externalYieldAmount` | Tokens deployed to external yield sources | | `currentDeployedAmount` | Tokens currently lent out through the order book | | `outstandingInterestAmount` | Accrued interest not yet repaid | ### Computing Vault APY The total Vault APY that a depositor earns is the sum of two components, the **lending APY** from order-book interest, and the **rewards APY** from any active token incentive schedules. > [tab] Lending APY > > This blends the interest earned from order-book lending with the yield from any external yield source, normalized over the total TVL. > > ```javascript Example theme={null} > const orderBookInterest = strategy.interestPerSecond * SECONDS_PER_YEAR; > const externalYield = externalYieldInfo.apy * strategy.externalYieldAmount; > > const lendingApy = (orderBookInterest + externalYield) / vaultTvl; > ``` > [tab] Rewards APY > > If the Vault has active reward emissions, they are available in the `vaultRewardsSchedule` array on the response. Each entry represents a token emission schedule. > > For each schedule: > > 1. Verify the schedule is active by checking that the current time falls between `rewardStartTime` and `rewardEndTime`. > 2. Compute the annualized value of emissions. Since rewards can be denominated in various tokens, you will need to source the token price externally. > > ```javascript Example theme={null} > // For each active reward schedule > const isActive = > now >= schedule.rewardStartTime > && now <= schedule.rewardEndTime; > > if (isActive) { > // Convert from lamports > const emissionsPerSecond = Number(schedule.emissionsPerSecond) / 1e9; > const annualRewardValue = emissionsPerSecond * SECONDS_PER_YEAR * rewardTokenPrice; > const rewardsApy = annualRewardValue / vaultTvl; > } > ``` > > > [!NOTE] > > > > If multiple reward schedules are active, sum their individual APYs to get the total rewards APY. #### Calculating Total APY The following combines both components into a single calculation: ```javascript Example highlight={21-22} theme={null} // 1. Lending APY from order-book interest + external yield const orderBookInterest = strategy.interestPerSecond * SECONDS_PER_YEAR; const externalYield = externalYieldInfo.apy * strategy.externalYieldAmount; const lendingApy = (orderBookInterest + externalYield) / vaultTvl; // 2. Rewards APY from all active incentive schedules let totalRewardsApy = 0; for (const schedule of vaultRewardsSchedule) { const isActive = now >= schedule.rewardStartTime && now <= schedule.rewardEndTime; if (isActive) { const emissionsPerSecond = Number(schedule.emissionsPerSecond) / 1e9; const annualRewardValue = emissionsPerSecond * SECONDS_PER_YEAR * rewardTokenPrice; totalRewardsApy += annualRewardValue / vaultTvl; } } // 3. Total Vault APY const totalVaultApy = lendingApy + totalRewardsApy; ``` ## Loop Metrics Use the [Get Loop Info](/api-reference/data/loops/get-loop-info) endpoint to retrieve Loop data. You can filter by: * **Loop identifiers** — either the slug (e.g. `acred-usdg`) or the mints formatted as `{PRINCIPAL_MINT}-{COLLATERAL_MINT}` * **Tags** — e.g. `Stablecoin`, `Exponent`, `Hylo`, etc. **Example request:** ```bash Example theme={null} curl -X POST https://tars.loopscale.com/v1/markets/loop/info \ -H "Content-Type: application/json" \ -d '{ "identifiers": ["acred-usdg"] }' ``` ### Total Looped Assets The `collateralDeposited` field returns the total assets deposited into the Loop, in decimal-scaled value. ```javascript Example theme={null} const totalLoopedAssets = loopInfo.collateralDeposited; ``` ### Computing Loop APY Use the `wAvgApy` field, which represents the current weighted-average APY across all active positions, weighted by size. ```javascript Example theme={null} // Prefer wAvgApy over maxApy for display const loopApy = loopInfo.wAvgApy; ``` > [!WARNING] > > Avoid using `maxApy` for display purposes. If borrow liquidity is exhausted, `maxApy` may be empty or pull from a small strategy with an unrealistically high or low yield. `wAvgApy` is more reliable and representative of actual user returns. # Loopscale API Source: https://docs.loopscale.com/api-reference/introduction/introduction Loopscale is a modular, order book-based lending protocol on Solana, enabling fully programmable credit markets. A unified order book that matches borrowers and lenders across flexible rates, durations, and collateral types, creating an open foundation for new financial products. Developers can use the Loopscale protocol power fixed-rate borrowing, leverage Loops, and bespoke credit products. This reference is **not a comprehensive API spec**. It provides documentation for a curated set of endpoints shared with partners and integrators on an as-needed basis. A full public API reference is in progress and coming soon. If you’re building on top of Loopscale and need access to additional endpoints or integration support, [get in touch](mailto:developers@loopscale.com). ## Start building > [card] [Transactions](/api-reference/transactions/borrow/flash-borrow/) > > Create borrow/lend orders and manage positions > [card] [Data](/api-reference/data/markets/get-quotes/) > > Access analytics and data on available liquidity # Borrow principal Source: https://docs.loopscale.com/api-reference/transactions/borrow/borrow-principal post /markets/creditbook/borrow Borrows additional principal against an existing loan and can optionally refinance the targeted ledger in the same transaction. # Build loan Source: https://docs.loopscale.com/api-reference/transactions/borrow/build-loan post /markets/creditbook/build Builds or mutates a loan through a sequence of high-level actions. Supported step types currently include `repay`, `flashBorrow`, and `swapCollateral`. # Close loan Source: https://docs.loopscale.com/api-reference/transactions/borrow/close-loan post /markets/creditbook/close_loan In the event a loan is fully repaid and all collateral is withdrawn, but wasn't closed, this directly closes the loan account and refunds the user. # Create loan Source: https://docs.loopscale.com/api-reference/transactions/borrow/create-loan post /markets/creditbook/create Creates a new loan with initial collateral and requested principal borrows, returning both the loan address and the serialized transaction needed to initialize it. # Deposit collateral Source: https://docs.loopscale.com/api-reference/transactions/borrow/deposit-collateral post /markets/creditbook/collateral/deposit Adds more collateral to an existing loan position. # Flash borrow Source: https://docs.loopscale.com/api-reference/transactions/borrow/flash-borrow post /markets/creditbook/flash_borrow Atomically creates a new loan and executes optional CPIs before depositing collateral. Supports deferred collateralization. Returns a transaction message and resulting loan address. # Refinance loan Source: https://docs.loopscale.com/api-reference/transactions/borrow/refinance-loan post /markets/creditbook/refinance Update the duration of the loan. # Repay loan Source: https://docs.loopscale.com/api-reference/transactions/borrow/repay-loan post /markets/creditbook/repay Partially or fully repay an active loan. Allows for the withdrawal of collateral for optional use in CPIs before repayment. # Sell ledger Source: https://docs.loopscale.com/api-reference/transactions/borrow/sell-ledger post /markets/creditbook/sell Sells a loan ledger from one strategy into another strategy, using the expected sale price guard provided in the request. # Simple repay loan Source: https://docs.loopscale.com/api-reference/transactions/borrow/simple-repay-loan post /markets/creditbook/repay_simple A simplified repay endpoint that handles a single strategy at a time. Unlike the full repay endpoint, it does not support CPI instructions, collateral withdrawals, or setup instructions. If a ledger is fully repaid on a multi-ledger loan, weight matrix updates are automatically generated to redistribute collateral away from the emptied ledger. # Swap collateral Source: https://docs.loopscale.com/api-reference/transactions/borrow/swap-collateral post /markets/creditbook/swap_collateral Enables safe rebalancing of collateral by withdrawing a selected asset, executing CPIs (e.g. swaps or liquidity provision), and depositing a new asset in its place. # Withdraw collateral Source: https://docs.loopscale.com/api-reference/transactions/borrow/withdraw-collateral post /markets/creditbook/collateral/withdraw Withdraws collateral from an existing loan. Full collateral removal may include internal weight-matrix and loan-lock handling before the transaction is returned. # Claim Orca fees Source: https://docs.loopscale.com/api-reference/transactions/clmm/claim-orca-fees post /markets/creditbook/collateral/orca/claim_fees Claim accrued fees for an Orca CLMM collateral position on a loan. # Transfer Orca position Source: https://docs.loopscale.com/api-reference/transactions/clmm/transfer-orca-position post /markets/creditbook/collateral/orca/transfer_position Reposition an Orca CLMM collateral position to a new tick range on an existing loan. # Transfer Raydium position Source: https://docs.loopscale.com/api-reference/transactions/clmm/transfer-raydium-position post /markets/creditbook/collateral/raydium/transfer_position Reposition a Raydium CLMM collateral position to a new tick range on an existing loan. # Update Orca liquidity Source: https://docs.loopscale.com/api-reference/transactions/clmm/update-orca-liquidity post /markets/creditbook/collateral/orca/update_liquidity Increase or decrease liquidity on an Orca CLMM collateral position while keeping the loan collateralized. # Update Raydium liquidity Source: https://docs.loopscale.com/api-reference/transactions/clmm/update-raydium-liquidity post /markets/creditbook/collateral/raydium/update_liquidity Increase or decrease liquidity on a Raydium CLMM collateral position while keeping the loan collateralized. # Acknowledge Earn Vault Source: https://docs.loopscale.com/api-reference/transactions/earn/acknowledge post /markets/earn/vaults/acknowledge Records that a wallet accepted a vault's deposit terms. Vaults with `requiresAcknowledgment: true` expect this call before a wallet's first deposit. It writes no transaction and is idempotent. # Cancel Earn Withdrawal Source: https://docs.loopscale.com/api-reference/transactions/earn/cancel-withdrawal POST https://tars.loopscale.com/v1/pandora/earn/vaults/withdraw_cancel/tx Builds the transactions that cancel an open queued withdrawal and return its shares to the wallet. Only available when the vault's `cancelEnabled` flag is set (see [Get Earn Vault](/api-reference/data/earn/get-earn-vault)). Get `requestId` from the withdraw request response, or from `openWithdrawalRequests[].onChainRequestAddr` on [Get Earn Position](/api-reference/data/earn/get-earn-position). Sign and send `txBase64s` in order as one Jito bundle, as described in [Sending Earn transactions](/api-reference/transactions/earn/deposit#sending-earn-transactions). ## Body **address** `string` *required* Earn vault address. **wallet** `string` *required* Wallet that opened the request. **requestId** `string` *required* Withdrawal request account address. **providerKind** `string` (default: exponent) Vault provider. Only `exponent` is supported today. ## Response Same shape as [Deposit to Earn Vault](/api-reference/transactions/earn/deposit#response), with `action: "withdrawCancel"` and `requestId` echoed back. ```bash Example theme={null} curl -X POST https://tars.loopscale.com/v1/pandora/earn/vaults/withdraw_cancel/tx \ -H "Content-Type: application/json" \ -d '{ "address": "EsTx9ToYW2k1DsTw6ccpmP3RrXQriod114hcM7U5ZKaR", "wallet": "", "requestId": "" }' ``` # Claim Earn Withdrawal Source: https://docs.loopscale.com/api-reference/transactions/earn/claim-withdrawal POST https://tars.loopscale.com/v1/pandora/earn/vaults/withdraw_claim/tx Builds the transactions that claim a filled queued withdrawal, paying the tokens out to the wallet and creating any token accounts it needs. The claim pays out every fill on the request, which can span more than one token. The request's `fills` on [Get Earn Position](/api-reference/data/earn/get-earn-position) or [Get Earn Withdrawal Queue](/api-reference/data/earn/get-earn-withdrawal-queue) list the per-token amounts; compare them with `payoutMint` to see whether the manager filled in the token the user asked for. Get `requestId` from the withdraw request response, or from `openWithdrawalRequests[].onChainRequestAddr` on [Get Earn Position](/api-reference/data/earn/get-earn-position). [Get Earn Withdrawal Queue](/api-reference/data/earn/get-earn-withdrawal-queue) shows how much of each request has been filled. Sign and send `txBase64s` in order as one Jito bundle, as described in [Sending Earn transactions](/api-reference/transactions/earn/deposit#sending-earn-transactions). ## Body **address** `string` *required* Earn vault address. **wallet** `string` *required* Wallet that opened the request. **requestId** `string` *required* Withdrawal request account address. **providerKind** `string` (default: exponent) Vault provider. Only `exponent` is supported today. ## Response Same shape as [Deposit to Earn Vault](/api-reference/transactions/earn/deposit#response), with `action: "withdrawClaim"` and `requestId` echoed back. ```bash Example theme={null} curl -X POST https://tars.loopscale.com/v1/pandora/earn/vaults/withdraw_claim/tx \ -H "Content-Type: application/json" \ -d '{ "address": "EsTx9ToYW2k1DsTw6ccpmP3RrXQriod114hcM7U5ZKaR", "wallet": "", "requestId": "" }' ``` # Deposit to Earn Vault Source: https://docs.loopscale.com/api-reference/transactions/earn/deposit POST https://tars.loopscale.com/v1/pandora/earn/vaults/deposit/tx Builds the transactions that deposit tokens into an Earn vault and mint vault shares (LP tokens) to the wallet. The response carries two transactions in `txBase64s`: an AUM refresh followed by the deposit itself. Sign both with the depositing wallet and submit them **in order as one Jito bundle**. The deposit transaction already contains the Jito tip. See [Sending Earn transactions](#sending-earn-transactions) below. If the vault has `requiresAcknowledgment: true` (see [Get Earn Vault](/api-reference/data/earn/get-earn-vault)), call [Acknowledge Earn Vault](/api-reference/transactions/earn/acknowledge) for the wallet before its first deposit. ## Body **address** `string` *required* Earn vault address. **wallet** `string` *required* Depositing wallet. It pays fees and signs both transactions. **amount** `string | integer` *required* Amount to deposit, in base units of the deposit mint (for example `"1000000"` is 1 USDC). **mint** `string` Token to deposit. Defaults to the vault's underlying (`acceptedAssetMint`). Must be one of the vault's token entries (`parsedAccountJson` on [Get Earn Vault](/api-reference/data/earn/get-earn-vault)), otherwise the request fails. **minLpOut** `string | integer` Minimum shares to receive, in LP base units. The transaction fails if fewer would be minted. Defaults to `0` (no slippage protection). **providerKind** `string` (default: exponent) Vault provider. Only `exponent` is supported today. ## Response **txBase64s** `string[]` Base64 v0 transactions to sign and send in order as one bundle: `[aumRefresh, deposit]`. **txBase64** `string` The deposit transaction on its own (the last entry of `txBase64s`). **action** `string` `deposit`. **providerKind** `string` Provider that built the transaction. **vault** `string` Vault address. **user** `string` Wallet the transaction was built for. **setupIxs** `object[]` Decoded setup instructions in the deposit transaction (compute budget, heap frame, Jito tip, token account creation). **ixs** `object[]` Decoded vault instructions in the deposit transaction. **luts** `string[]` Address lookup tables the deposit transaction uses. **signers** `string[]` Extra signers that already signed the deposit transaction. Empty for deposits. **missingLuts** `string[]` Lookup tables that could not be loaded. Diagnostic only. **accountsNotInLuts** `string[]` Accounts passed outside lookup tables. Diagnostic only. ```bash Example theme={null} curl -X POST https://tars.loopscale.com/v1/pandora/earn/vaults/deposit/tx \ -H "Content-Type: application/json" \ -d '{ "address": "EsTx9ToYW2k1DsTw6ccpmP3RrXQriod114hcM7U5ZKaR", "wallet": "", "amount": "1000000" }' ``` ```json 200 theme={null} { "providerKind": "exponent", "action": "deposit", "vault": "EsTx9ToYW2k1DsTw6ccpmP3RrXQriod114hcM7U5ZKaR", "user": "", "setupIxs": [{ "programId": "ComputeBudget111111111111111111111111111111", "accounts": [], "data": "..." }], "ixs": [{ "programId": "sVau1tXvayVWfotzm9Ahcv2qfnnfRWttt78BCnNC6dD", "accounts": ["..."], "data": "..." }], "luts": ["EmzYGKrZEyLvaRbmJGV5cdCqNjdPKpH62oscdGD7oui6"], "missingLuts": [], "accountsNotInLuts": ["..."], "signers": [], "txBase64": "", "txBase64s": ["", ""] } ``` ## Sending Earn transactions Every Earn transaction endpoint (deposit, withdraw request, claim, cancel) returns the same shape: 1. Deserialize each entry of `txBase64s` as a `VersionedTransaction`. 2. Sign each one with the wallet. Keep any signatures already present: a queued withdraw request comes partially signed by its new request account (listed in `signers`). 3. Submit the signed transactions **in the order returned** as a single Jito bundle. The first refreshes the vault's AUM so the action is priced at current NAV. The last carries the Jito tip. Sending the action alone, or out of order, can fail or price against stale NAV. Transactions use a recent blockhash from build time, so sign and send promptly. ## Errors If a transaction can't be built, the endpoint returns `500` with `error.code`, `error.message`, and the `accountsNotInLuts` and `missingLuts` diagnostics. # Withdraw from Earn Vault Source: https://docs.loopscale.com/api-reference/transactions/earn/withdraw-request POST https://tars.loopscale.com/v1/pandora/earn/vaults/withdraw_request/tx Builds the transactions that withdraw shares from an Earn vault, either instantly from the vault's reserves or through the withdrawal queue. * **`instant`** redeems shares straight from the vault's reserves in one step, paying the vault's fast-withdrawal cut. Payout is in the vault's underlying unless `mint` picks another token entry, and it only succeeds while that token's reserve holds enough. * **`queued`** opens a withdrawal request for the shares. Once the request is filled, [claim it](/api-reference/transactions/earn/claim-withdrawal) to receive the tokens, or [cancel it](/api-reference/transactions/earn/cancel-withdrawal) before then to get the shares back. Passing `mint` records the token you want the request filled in; the vault manager honors it when filling. Check the vault's `instantEnabled` and `queueEnabled` flags on [Get Earn Vault](/api-reference/data/earn/get-earn-vault) before offering a mode. Sign and send `txBase64s` in order as one Jito bundle, as described in [Sending Earn transactions](/api-reference/transactions/earn/deposit#sending-earn-transactions). A queued request transaction comes partially signed by the new request account; keep that signature when you add the wallet's. ## Body **address** `string` *required* Earn vault address. **wallet** `string` *required* Wallet that owns the shares. It pays fees and signs the transactions. **shares** `string | integer` *required* Shares to withdraw, in LP base units. **mode** `string` *required* `instant` or `queued`. **mint** `string` Token to receive. Must be one of the vault's token entries, the tokens the vault holds; `acceptedAssetMints` on [Get Earn Vault](/api-reference/data/earn/get-earn-vault) is the subset Loopscale offers in its app and is what integrators should stick to. Defaults to the vault's accepted asset (`acceptedAssetMint`). Instant mode pays it out in the same transaction. Queued mode writes it into the request transaction as a memo, and the fill later uses that token; the request then shows it as `payoutMint` on [Get Earn Position](/api-reference/data/earn/get-earn-position). **providerKind** `string` (default: exponent) Vault provider. Only `exponent` is supported today. ## Response Same shape as [Deposit to Earn Vault](/api-reference/transactions/earn/deposit#response), plus: **action** `string` `withdrawRequestInstant` or `withdrawRequestQueued`. **requestId** `string` Queued mode only. Address of the new withdrawal request account. Pass it to Claim or Cancel. It is also returned later as `onChainRequestAddr` by [Get Earn Position](/api-reference/data/earn/get-earn-position). **signers** `string[]` Queued mode only. Contains `requestId`, which has already signed the transaction. **payoutMint** `string` Token the withdrawal pays out in. Always set for instant mode; set for queued mode when `mint` was passed. ```bash Queued theme={null} curl -X POST https://tars.loopscale.com/v1/pandora/earn/vaults/withdraw_request/tx \ -H "Content-Type: application/json" \ -d '{ "address": "EsTx9ToYW2k1DsTw6ccpmP3RrXQriod114hcM7U5ZKaR", "wallet": "", "shares": "500000", "mode": "queued" }' ``` ```json 200 theme={null} { "providerKind": "exponent", "action": "withdrawRequestQueued", "vault": "EsTx9ToYW2k1DsTw6ccpmP3RrXQriod114hcM7U5ZKaR", "user": "", "requestId": "", "signers": [""], "txBase64": "", "txBase64s": ["", ""] } ``` # Close strategy Source: https://docs.loopscale.com/api-reference/transactions/strategy/close-strategy post /markets/strategy/close/{strategy} Closes an existing lending strategy and returns the serialized transaction required to do so. # Create strategy Source: https://docs.loopscale.com/api-reference/transactions/strategy/create-strategy post /markets/strategy/create Creates a new lending strategy, deposits the initial principal amount, and may return multiple transactions when lookup-table setup or external yield account initialization is required. # Deposit into strategy Source: https://docs.loopscale.com/api-reference/transactions/strategy/deposit-strategy post /markets/strategy/deposit Deposits additional principal into an existing lending strategy. # Update strategy Source: https://docs.loopscale.com/api-reference/transactions/strategy/update-strategy post /markets/strategy/update Updates strategy settings and collateral terms. Large collateral-term updates may be split across multiple returned transactions. # Withdraw from strategy Source: https://docs.loopscale.com/api-reference/transactions/strategy/withdraw-strategy post /markets/strategy/withdraw Withdraws principal from an existing lending strategy, optionally closing out the full position. # Cancel vault timelocks Source: https://docs.loopscale.com/api-reference/transactions/vault/cancel-timelocks post /markets/lending_vaults/timelock/cancel Cancel one or more pending timelock entries. # Claim Vault rewards Source: https://docs.loopscale.com/api-reference/transactions/vault/claim-rewards post /markets/lending_vaults/rewards/claim Claim rewards from a target lending Vault. This will harvest from all available rewards schedules and close empty accounts to refund SOL to requesting wallet. # Create rewards schedule Source: https://docs.loopscale.com/api-reference/transactions/vault/create-rewards-schedule post /markets/lending_vaults/rewards/schedule/create Create a new vault rewards schedule and optionally deposit reward tokens into it. # Create vault timelocks Source: https://docs.loopscale.com/api-reference/transactions/vault/create-timelocks post /markets/lending_vaults/timelock/create Create one or more timelock updates for vault collateral, rates, allocation, caps, and settings changes. # Deposit to Vault Source: https://docs.loopscale.com/api-reference/transactions/vault/deposit post /markets/lending_vaults/deposit Deposit funds into a target lending Vault. On an additional deposit, the previous stake account and reward schedule is deleted and a new one is created. # Edit vault deposits Source: https://docs.loopscale.com/api-reference/transactions/vault/edit-deposits post /markets/lending_vaults/deposits/edit Enable or disable deposits for a lending vault. # Edit rewards schedule Source: https://docs.loopscale.com/api-reference/transactions/vault/edit-rewards-schedule post /markets/lending_vaults/rewards/schedule/edit Edit an existing vault rewards schedule and optionally extend its end time while depositing additional rewards. # Withdraw from Vault Source: https://docs.loopscale.com/api-reference/transactions/vault/withdraw post /markets/lending_vaults/withdraw Withdraw funds from a target lending Vault. If any deposits remain, the previous stake account and reward schedule is deleted and a new one is created. # Loopscale Documentation Source: https://docs.loopscale.com/introduction/overview Loopscale is a modular, order book–based lending protocol on Solana. It enables overcollateralized borrowing and lending across a wide range of digital assets, including staked tokens, liquidity provider positions, and more specialized primitives. **By replacing pooled liquidity and algorithmic rates with direct order book matching and non-algorithmic, market-based rates**, Loopscale improves capital efficiency, enables more precise risk management, and supports new types of markets that are difficult to achieve with traditional DeFi architectures. ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/overview.svg?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=7704ca1d54d7005f5fdc5b31594163e3) ## Key Capabilities * **Markets for the next generation of digital assets:** Flexible market infrastructure supports sophisticated collateral types, including liquidity positions, staked tokens, and tokenized real-world assets. * **Precise risk management:** Isolated collateral, modular markets, and flexible parameters avoid systemic risk and one-size-fits-all exposure. * **Better rates and higher LTVs:** With order books, lend rate = borrow rate, eliminating the liquidity requirements present in pool models. This capital efficiency improves lending yields and reduces borrowing costs. * **Predictable costs and yield:** Fixed-rate, fixed-duration loans create predictability for borrowers and lenders. * **DeFi-native experience:** The Loopscale interface and primitives such as Loopscale Vaults concentrate liquidity and simplify the user experience while preserving the scalability of the core order book protocol. ## Learn about Loopscale > [card] [Loopscale Vaults](/using-loopscale/lend/lend/) > > Curated vaults that lend to Loopscale Markets > [card] [Loops](/using-loopscale/loop/) > > One-click leverage for without rate volatility > [card] [Borrow](/using-loopscale/borrow/) > > Fixed rate liquidity for more assets at better terms > [card] [Advanced Lend](/using-loopscale/lend/advanced-lend/) > > Positions with customizable collateral and rates ## Use Loopscale > [card] [App](https://app.loopscale.com) > > Borrow, lend, loop, and more # Why Loopscale? Source: https://docs.loopscale.com/introduction/why-loopscale Loopscale is designed in response to the structural limitations of traditional, pool-based DeFi lending protocols. This page describes the key differences between Loopscale’s architecture and pool-based lending models and explains how Loopscale enables scalable credit markets. ## Limitations of Pool-Based Models Most DeFi lending protocols rely on multi-asset liquidity pools. In this model, users deposit assets into a shared pool, and borrowers draw from that pool. Interest rates are set by a utilization curve: rates increase as more of the pool is borrowed. This model was developed under the constraints of early blockchain infrastructure (e.g., Ethereum) and when demand for onchain borrowing was uncertain. While effective for bootstrapping early DeFi markets, the model introduces several structural inefficiencies: * **Interest rate spread:** Interest is paid only on borrowed funds but distributed across all liquidity (including idle capital), creating a persistent spread between borrow and supply rates. * **Poor risk pricing:** Rates are based on the utilization of the borrowed asset and do not reflect the volatility or quality of the collateral. * **One-size-fits-all exposure:** All lenders in a pool share the same risk exposure, with no ability to define individual risk preferences. * **Limited flexibility:** New collateral assets require governance approval and deep liquidity and pools typically support only open-ended, variable-rate loans, significantly limiting protocol extensibility. * **Systemic risk:** Multi-asset pools create shared exposure—volatility in one asset can impact the entire system. ## Loopscale's Credit Order Book Model Loopscale replaces the pooled model with an order book system called the Credit Order Book, where each market is created and priced independently. Loans are executed through direct matches between borrowers and lenders, with fixed rates and market-defined terms. This model solves the issues of pool-based models and unlocks entirely new financial products and markets. * **More collateral assets:** Support for staked assets, LP positions, and novel primitives like RWAs or restaking tokens. * **Precise risk management:** Each market is isolated, and lenders define risk parameters per asset and per offer. * **Fixed rates:** Fixed-rate loans avoid exposure to the volatility of variable, utilization-based rates. * **Better rates:** With order books, Without the need for idle liquidity buffers, more capital is actively earning. This improves lending yields and reduces borrowing costs. * **Higher LTVs:** Markets are not constrained by the riskiest asset in a pool. Each asset’s risk is priced independently. ### Solving Fragmentation and Usability Historically, order book–based lending protocols have faced two primary challenges: liquidity fragmentation and complex user experience. Because each market in an order book is defined by a specific set of parameters, capital tends to fragment across many isolated opportunities, and lenders must manage each position manually. Loopscale addresses these challenges with two key abstractions: **Virtual Markets:** Rather than placing individual orders on every market, lenders create a ruleset defining acceptable terms (e.g., collateral, rate, duration). This ruleset is abstracted into Virtual Markets, which: * Present unified liquidity across markets matching the lender’s criteria * Concentrate liquidity around standardized, popular configurations * Support incremental refinement over time, enabling more granular markets as overall liquidity increases. This balances short-term liquidity aggregation with long-term extensibility, allowing Loopscale to support both common borrowing use cases and more specialized products. **Loopscale Vaults:** Users seeking a passive experience can deposit to Loopscale Vaults, lending strategies managed by third-party curators. These curators define and manage the ruleset on behalf of Vault participants, handling market selection and order placement. Vaults provide an accessible entry point for users who want to earn lending yield on Loopscale Markets without managing positions or understanding order book mechanics. Interest, risk, and performance are distributed among all Vault participants. ## Advantages of Orderbooks ### Interest Rates Algorithmic risk pricing fails to efficiently allocate capital, leaving significant funds idle. This idle liquidity creates an inherent rate spread that dilutes returns. Direct matches via order book bypass the spread between borrow and supply rates found in pool models by instead directly matching parties. Consider the following example: > [tab] Utilization-Based Rates > > 1. Lenders supply \$100 to the pool > 2. A borrower borrows \$60. The borrow rate is defined by the protocol as 5% APY for a 60% utilization ratio. > 3. The idle liquidity leads to a **Borrow APY of 5% and a Supply APY of 3%** as calculated by: > > $\text{Supply APY} = \text{Borrow APY} \times \text{Utilization Ratio}$ > > $3\% = 5\% \times \frac{60}{100}$ > [tab] Rates on Loopscale > > 1. Lender places offer: \$60 at 4% > 2. Borrower accepts offer: \$60 at 4% > 3. Direct matching leads to a **lower Borrow APY of 4% and a higher Supply APY of 4%** as calculated by: > > $\text{Lend Rate} = \text{Borrow Rate} = 4\%$ > > All loans on Loopscale are *fixed-term* and *fixed-rate*. Borrowers lock in a predictable cost of capital, while lenders earn predictable yield. This enables longer-term strategies and reduces exposure to interest rate volatility. ### Collateral Eligibility A major disadvantage of pool-based lending models is their inability to price risk based on collateral quality. A lender’s risk-return profile depends on the likelihood that the collateral will sufficiently cover the loan in the event of liquidation. This is primarily a function of the loan-to-value (LTV) ratio and the volatility of the collateral asset. Riskier collateral or higher LTVs should naturally command higher interest rates. However, in pool-based models, interest rates are determined solely by the utilization of the borrowed asset—not the collateral securing the loan. This leads to several problems: * **Uniform risk pricing:** Volatile or illiquid assets are priced the same as stable collateral. * **Cross-asset inefficiency:** Risk introduced by a single asset affects rates for all borrowers in the pool. * **Protocol constraints:** To avoid these issues, protocols often restrict the types of assets that can be used as collateral or create separate pools, which fragments liquidity. By contrast, Loopscale prices each market independently, allowing for per-asset risk differentiation. This ensures better rates for lower-risk collateral, enables support for novel asset types, and eliminates the need for restrictive eligibility or fragmented pools. ### Risk Management Pool-based lending protocols expose users to shared, system-wide risk. Because multiple assets are aggregated into a single pool, parameters like LTV, liquidation thresholds, and interest rates must be conservative enough to accommodate the riskiest supported collateral. This results in: * **One-size-fits-all parameters:** Safer assets are unnecessarily constrained by rules designed for more volatile ones. * **Systemic risk:** Underperformance or volatility in a single asset can threaten the solvency of the entire pool. * **Emergency interventions:** Protocols may be forced to pause markets or change parameters globally in response to localized risk events. Loopscale’s architecture avoids these issues through isolated, asset-specific markets that support both mature and emerging assets. Each market represents a single collateral-asset pair with independent, market-defined terms, enabling: * **Per-market terms:** Collateral-specific LTVs, rates, and durations tailored to the asset’s risk profile. * **No cross-asset contagion:** Volatility in one market has no effect on others. * **Customizable exposure:** Sophisticated lenders can set rates, durations, and collateral requirements based on individual risk appetite and market outlook. ## Supported Use Cases Loopscale unlocks new onchain financial products and credit applications, including: * Leveraged yield strategies (e.g., JLP, LSTs) * Margin for market makers (e.g., Orca Whirlpools) * Passive fixed-rate lending via Vaults * Structured credit (e.g. undercollateralized loans, tranched lending, credit facilities) * Receivables and RWA financing with custom risk parameters # Genesis Vaults Risk Framework Source: https://docs.loopscale.com/partners/archived/genesis-risk-framework The **Genesis Vaults** on Loopscale are the inaugural managed lending Vaults, designed and curated by the Loopscale core team. This framework outlines the principles, parameters, and systems in place to ensure that Genesis Vaults deliver yield with a high degree of transparency, security, and operational resilience. ## Collateral Management ### Inclusion Criteria Genesis Vaults only accept high-quality, Solana-native collateral assets that meet strict standards for liquidity, price discovery, and smart contract safety. To be eligible, tokens must meet all of the following: * **Oracle coverage** via Pyth * **Major CEX listings**, such as Binance, Coinbase, or ByBit * **Sufficient on-chain liquidity**, with at least \$1M in non-incentivized DEX volume * **Smart contract audits**, with LSTs, LPs, and other wrapped assets requiring reviews by at least two Tier-One Solana security firms Collateral is assessed for not only technical safety but also economic resilience, including team risk, protocol maturity, and market liquidity. > A curated collateral list is maintained weekly and available upon request. ### LTV Assignment Loan-to-Value (LTV) ratios are calculated based on a risk assessment factoring in: * **On-chain liquidity depth** * **Historical and implied volatility** * **Oracle latency and failure modes** Collateral types are treated individually: * **Standard tokens** are analyzed for DEX slippage and liquidation capacity * **LSTs and LRTs** are evaluated based on deviation from redemption value * **LP tokens** inherit the risk profile of the most volatile or illiquid token in the pair, plus smart contract risk * **Paired assets** (e.g., SOL/mSOL or USDC/USDT) may receive up to 95% LTV if both assets meet core security thresholds Assets that fail to meet minimum standards (such as unaudited LPs or tokens with insufficient liquidity) are explicitly excluded. ## Rate and Utilization Controls Genesis Vault use a dynamic, manually-updated rate model to balance competitive yield generation with healthy liquidity reserves. ### Utilization-Based Yield Curve Interest rates respond to the level of utilization within the Vault: | | | | - | - | | 0–25% utilization | 50% of the lowest available borrow rate on Solana | | 25–50% utilization | Matches the prevailing floating rate | | Above 50% | Rates step up toward the midpoint between market borrow and lend rates | | SOL-based loans | Peg to Solana base inflation rate beyond 50% | This system helps preserve a generous liquidity buffer while maintaining fair and transparent pricing for borrowers. ### Collateral Diversification To avoid overreliance on any single collateral type, there is a soft cap enforced on a collateral asset's share of active loans. This cap is enforced via rate pricing mechanics. Once a collateral exceeds 10% of all active loans, interest rates increase to offset the added risk. | Collateral Group | Max Target Share | Rate Adjustment Above Cap | | - | - | - | | USDC / USDT | 50% | +2.5% per % | | SOL + LSTs | 33% | +2.5% per % | | JLP | 33% | +2.5% per % | | Other assets | 10% | +2.5% per % | ### Duration Premiums Genesis Vaults initially support only short-term loans. When longer durations are enabled, they will carry additional interest premiums to offset reduced liquidity flexibility: * **+10% of the base rate per week of duration** * **Maximum exposure limits per term** (see [Term Caps](#term-caps)) ### Idle Capital To enhance returns on unused capital, idle Vault funds may be temporarily deployed to other low-risk Solana protocols (e.g., MarginFi). These allocations are actively monitored and can be halted if risk parameters tighten. ## Liquidity and Withdrawal Safeguards Loopscale employs multiple mechanisms to ensure vault liquidity is continuously available for depositor withdrawals and borrower repayments. ### Term Caps Loan maturities are restricted to avoid concentration in long-dated risk: | Loan Term | Max % of Vault Debt | | - | - | | 1 day | 100% | | 1 week | 50% | | 1 month | 20% | | 3 months | 10% | ### Liquidity Thresholds * **5% Liquidity Buffer**: Lending is automatically paused when idle capital drops below 5% of total deposits. * **1% Emergency Threshold**: If idle capital falls below 1%, Vaults begin actively offloading loans to restore liquidity. Capital may be rebalanced through cross-strategy orderbook sales. * **Withdrawal Queue Protocol**: When no additional liquidity can be sourced, a withdrawal queue is initiated. Lending originations pause until buffers are replenished. ### Bad Debt Handling Each Vault is isolated in terms of credit risk. If a loan defaults: * Liquidator receives full collateral value at oracle spot price * The difference between loan principal and recovered value is deducted from the Vault's NAV * Losses are absorbed proportionally by depositors in that Vault * **Withdrawals are paused** during resolution to prevent imbalance This structure ensures no contagion between Vaults and maintains transparency over realized losses. ## Fee Structure Genesis Vaults do not charge any fees until they surpass a \$25M deposit threshold. Beyond that: * **Performance fee:** 10% of interest earned * **Fee flexibility:** Fees are waived if Vault returns fall below competitive benchmarks ## Operations and Infrastructure ### Liquidations Loopscale maintains a redundant liquidation system to ensure reliable, timely execution and protect against bad debt. #### Three-Tiered Liquidation System 1. **Primary Service** * Cloud-based flash loan liquidator triggered by oracle updates * Fully automated using Kamino, MarginFi, Solend, and major DEX routes 2. **Secondary Poller** * Backup service polling every 5 minutes * Uses a pre-funded manager wallet with controlled execution 3. **Tertiary Manual Service** * Team-managed liquidation wallet with critical paging * Manually executes liquidation if automated systems fail ### Risk Monitoring & Alerts Loopscale continuously monitors collateral risk, liquidation performance, and infrastructure liveness. * **Real-time dashboards:** Collateral exposure, oracle performance, withdrawal trends, and rollover timing * **Alerts:** Slack, SMS, and PagerDuty notifications for: * Oracle staleness * Withdrawal spikes * Failed liquidations * Solana chain congestion or liveness issues ### Operational Security Loopscale operates all smart contracts and backend services under strict access control. * **3/5 multisig governance** for contract upgrades (via Squads) * **Granular IAM roles and 2FA** on backend services * **Immutable logic** on liquidation and refinance flows * **Dedicated disaster response internal SOP** and 24/7 on-call rotation Loopscale cannot directly access or transfer user funds through backend systems. # Loopscale Vault Curation Source: https://docs.loopscale.com/partners/curators/curation > [card] > > To explore opportunities to curate on Loopscale, reach out to Mary Gooneratne via [Telegram](https://t.me/marygooneratne) or [email](mailto:mary@loopscale.com). Loopscale Vaults offer users a passive and efficient way to earn fixed-rate lending yield across multiple Loopscale Markets. Users deposit into a Vault optimized by a Vault Curator who is responsible for defining eligible markets and loan terms. This documentation is for partners building credit products with Loopscale and describes the architecture, lifecycle, risk controls, and programmatic guardrails for Loopscale Vaults. ## Collateral Management Up to 200 collateral assets may be permissioned per vault, each with an assigned oracle. Curators may define: * **Loan-to-Value (LTV):** The maximum borrow value relative to deposited collateral value (also impacts how much collateral can be withdrawn from an outstanding loan). * **Liquidation Threshold (LQT):** The point at which liquidation is legal. * **Oracles:** Separate oracle accounts as well as staleness and variance criteria may be used for pricing and liquidations. Oracles must match a Loopscale-verified market configuration, as listed in the Oracles section of the docs. * **Maximum Allocation:** Per-asset loan exposure caps limit concentration for amount of principal at risk against any individual collateral asset. * **Interest rates:** Per-asset, per-duration interest rates can be set. Will apply to new loans or refinanced/rolled over loans. LTV and LQT apply only to new or refinanced loans, outstanding loans retain their initial parameters until rollover. ## Liquidity Management Vault liquidity can be actively shaped to balance yield generation and withdrawal readiness. Curators may define: * **Loan Durations and Rates:** Curators set which maturities are available in the order book and the rates for each tenor. * **Liquidity Buffer:** A portion of the vault can be reserved as idle liquidity to satisfy withdrawals, typically 2.5–7.5% of deposits. * **Idle Yield:** Unutilized funds may be allocated to external protocols (e.g. Marginfi) to earn incremental yield, though this introduces additional counterparty risk. * **Refinancing at Maturity:** If liquidity falls below the configured buffer, maturing loans are refinanced to other lenders or vaults to preserve withdrawal capacity. Vault operations also include configurable controls to manage inflows, outflows, and parameter changes. Curators may define: * **Deposit Caps:** Limits on total deposits accepted into the vault. * **Supply and Borrow Caps:** Limits on principal supplied or borrowed over 1h and 24h windows, and in total. Each window starts with the first action after the previous one expires. * **Withdrawal Caps:** Limits on withdrawals over 1h and 24h windows. There's no aggregate withdrawal cap. * **Pause Switches:** Ability to halt deposits or new loan originations. Disabling deposits takes effect immediately. Disabling originations is a strategy settings change, so it goes through the timelock. * **Timelock Buffers:** Parameter changes that increase risk (e.g. higher LTVs, expanded collateral sets) and changes to strategy settings wait 24 hours before taking effect. Risk-reducing changes like lower LTVs have no delay. See [Timelock delays](/partners/curators/vault-manager-ui#timelock-delays) for the full list. ## Curation Fees * **Origination Fee**: A fixed, one-time fee proportional to principal size, added to the borrower's principal on new loan originations (not refinances). The curator earns the share of it set by the vault's principal fee, and the rest accrues to depositors. The principal fee isn't editable in the Vault Manager UI. * **Interest Fee**: A variable share of accrued interest, configurable up to 100% of total interest generated. Origination, interest, and principal fees are each capped at 100%. A vault's max early unstake fee can be lowered but not raised. ## Liquidations Liquidations for loans on vaults are no different than the rest of the protocol, the liquidation framework is designed to ensure orderly resolution of insufficiently collateralized loans. * **Health Enforcement:** Monitor loan health factors defined by LTV and liquidation thresholds. Liquidations are triggered when collateral falls below required coverage. * **Settlement:** Liquidations involve the partial or full repayment of a debt in order to claim some/all collateral * **Whitelisted Access:** Liquidators must be whitelisted by Loopscale in order to be able to trigger a liquidation. * **Fees:** Liquidations follow a quasi-reverse dutch auction structure that rewards the liquidator proportionally to the percent below the liquidation ratio they are. This incentivizes less aggressive liquidations but in a competitive marketplace, liquidators are ultimately racing to determine a fair fee value at which they're willing to liquidate. # Security at Loopscale Source: https://docs.loopscale.com/partners/curators/security Loopscale is built with a strong emphasis on security, leveraging both technical and operational safeguards to protect user funds and ensure protocol integrity. This page outlines the key security measures in place and provides transparency into our risk management practices. For additional information on risk management, see [Risks & Security](/resources/risks-and-security) ## Technical Security * **Independent Audits**: All deployed programs undergo external security review prior to release. No upgrades or changes are made without third-party audit, and completed reports are published for transparency. * **Oracle Integrity**: Each supported oracle integration is implemented independently and monitored for latency, anomalies, and liveness. Lending and liquidation activity is paused if oracle feeds are stale or compromised. * **Transaction Safeguards**: In addition to multisig approval, all program transactions currently require a co-sign from the Loopscale Secrets Manager — a read-only AWS-based signer. This key cannot initiate actions on its own and functions only as a supplemental safeguard to ensure transactions are constructed as intended. ## Operational Security ### Access Controls All program upgrades require approval from a 3/5 multisig. This governance model ensures no single party can deploy changes unilaterally. Loopscale cannot directly access or transfer user funds. All state changes occur through immutable on-chain program logic. Backend services are protected by strict operational controls: * **3/5 multisig governance** for contract upgrades (via Squads). * **Granular IAM roles and 2FA** across backend infrastructure. * **Immutable logic** governing liquidation and refinance flows. * **Dedicated disaster-response SOP** with a 24/7 on-call rotation. ### Real-Time Monitoring Dashboards and automated alerts track collateral exposures, liquidity flows, oracle performance, and vault health. Alerts are escalated through 24/7 operational processes. Curators can monitor vaults directly via the curator dashboard and reporting interface. * **Dashboards**: Display collateral exposure, oracle status, withdrawal activity, and rollover timing. * **Alerts**: Sent via Slack, SMS, and PagerDuty for oracle staleness, withdrawal spikes, failed liquidations, or Solana liveness issues. ### Liquidations Liquidations are triggered automatically when loan health thresholds are breached and executed through whitelisted liquidators. For assets without deep on-chain liquidity, settlement may require coordination with external counterparties, introducing additional operational dependencies. The default liquidation system follows a tiered approach: 1. **Primary Service**: A cloud-based flash loan liquidator triggered by oracle updates, fully automated using onchain lending venues and major DEX routes to atomically liquidate at any size. 2. **Secondary Poller**: A backup service polling every five minutes, using a pre-funded manager wallet with controlled execution. 3. **Tertiary Manual Service**: A team-managed wallet with critical paging that executes liquidations manually if automated systems fail. Loopscale continuously monitors collateral risk, liquidation performance, and infrastructure liveness. ## Addresses | Program / Account | Address | Authority / Notes | | - | - | - | | Loopscale Program | `1oopBoJG58DgkUVKkEzKgyG9dvRmpgeEm1AVjoHkF78` | Core program logic | | Liquidation Engine | `mkr7azob5ee3RC64BVoHQPu7FnyaXzJnLMN8jm942pQ` | Automated liquidation execution | | Multisig Authority | `DwBXwJDZ4Av4miT62sEssWJUinkzwkmPPB4Fg3fKEfft` | 3-of-5 governance authority | | Secrets Manager Signer | `CyNKPfqsSLAejjZtEeNG3pR4SkPhSPHXdGhuNTyudrNs` | Supplemental co-sign, AWS-based key | # Loopscale Vault Architecture Source: https://docs.loopscale.com/partners/curators/vault-architecture Loopscale Vaults are an open, programmable infrastructure primitive that allow third parties to optimize lending strategies on behalf of depositors. Each Vault is dedicated to a single lending asset (e.g., USDC, SOL) and dynamically allocates that asset across multiple borrower-facing markets according to curated risk and liquidity parameters. ## Architecture Vaults are constructed from a set of program accounts that enforce accounting, staking, and risk controls on top of a Loopscale lending Strategy account: **Strategy** **Strategy**: As outlined in the core Loopscale Docs, Strategy Accounts are the backbone of the Loopscale Credit Order Book. Strategies contain the core NAV logic for a lender's position, maintained on each relevant loan action (deposit/withdrawal from strategy, borrow/repay loan), as well as interest rate and duration data. **MarketInformation** **MarketInformation**: A market information account stores up to 200 asset mints, oracle information, LTVs, and LQTs (liquidation ratios). Each strategy is mapped to one market information. Market informations are created by Loopscale (for the public borrow page) or Vault Managers. **VaultAccount** **VaultAccount**: Acts as a pooled wrapper on top of a Strategy. A third party (the vault manager) controls all settings for a given strategy as well as governors for deposits/withdrawals for depositors to the Vault. It creates and manages the supply of the LP tokens representing shares in the Vault and redeemable for principal + interest based on the NAV of the underlying Strategy. ### Vault Depositor Lifecycle Depositors to Loopscale Vaults follow a defined lifecycle governing deposits, staking, rewards, and withdrawals: 1. **Deposit**: Users deposit the vault’s principal asset and receive LP tokens in return. Deposits mint LP supply, forward principal into the vault strategy, and trigger a NAV update atomically. As the specific exchange rate of an LP token for a deposit asset may change every block, depositor-specified slippage bounds are enforced before acceptance. 2. **Stake**: The staking infrastructure (`VaultStake`) custodies LP positions (automatic if using Loopscale API/UI). This both simplifies life for depositors (no accidental burns) and allows for them to opt-in automatically to all rewards and points offered to vault depositors. 3. **Reward Accrual**: Active `VaultRewardsSchedule` accounts accrue emissions on a per-second basis. Rewards are indexed against the weighted stake supply and distributed proportionally across staked positions. Because deposits are auto-staked, users begin accruing rewards immediately without any additional action. 4. **Unstake**: LP Tokens can be unstaked and brought outside of Loopscale or unstaked in order to redeem for deposits. Unstaking a locked stake before its period ends burns part of the position as a fee, up to the vault's max early unstake fee. 5. **Withdrawal**: Withdrawals burn LP tokens and return principal. Accrued rewards are claimed separately. The Loopscale UI automatically performs any necessary unstake operations under the hood before transferring assets to the user. Vaults with a withdrawal queue enabled can limit how much leaves instantly and hold the rest in a queue. Loopscale configures the queue per vault, and it isn't part of the Vault Manager UI. ### Vault Risks Even with strict collateral parameters and curator oversight, vaults remain exposed to borrower performance and market dynamics. These risks cannot be fully eliminated: * **Borrower Default**: A borrower may fail to repay, and if collateral liquidations do not cover the shortfall, the vault absorbs the loss. * **Liquidation Risks**: Liquidations depend on timely oracle updates, on-chain liquidity, and execution capacity. Delays from network congestion, stale oracles, or rapid moves can reduce recovery. * **Contract Risks**: Bugs or vulnerabilities in Loopscale smart contracts could impair vault operation. * **Asset Risks**: Supported assets may depeg, be hacked, or otherwise lose significant value unexpectedly. * **Oracle Risk**: Oracles are defined at loan origination and cannot be modified until rollover. An oracle malfunction can trigger errant or failed liquidations. * **External Counterparty Risk (e.g. Marginfi)**: Idle vault liquidity can be allocated to external money markets to earn yield, but doing so introduces exposure to those protocols. > [!NOTE] > > Idle yield allocation is optional. Curators can disable this feature and keep idle funds in vault reserves. ### Bad Debt Handling Each Vault is isolated in terms of credit risk. If an individual loan ends up underwater (LTV > 100%): * Liquidator receives full collateral value at oracle spot price * The difference between loan principal and recovered value is deducted from the Strategy's NAV * Losses are absorbed proportionally by depositors in that Vault via the updated NAV This structure ensures no contagion between Vaults and maintains transparency over realized losses. > [!NOTE] > > Loopscale has never incurred a bad debt event and has robust liquidation systems in place with partners to ensure swift liquidation. # Vault Manager UI Guide Source: https://docs.loopscale.com/partners/curators/vault-manager-ui This page documents the Vault Manager interface used to configure a Loopscale vault. Only the vault's manager wallet can open it. > [!NOTE] > > Some screenshots predate the current UI. Where a screenshot and this page disagree (for example, the older `Settings` layout), this page is correct. Use it as the UI reference for: * operational controls * risk parameter updates * cap and allocation limits * rewards and timelock workflows ## Navigation The vault manager UI is organized into tabs: * `Overview` * `Collateral` * `Rates` * `Allocation` * `Principal Caps` * `Settings` * `Timelocks` * `Rewards` Most edit tabs follow the same pattern: * inline field edits * row-level `Reset` when a row has unsaved changes * a `Summary of changes` panel * a primary apply action (`Save changes`, `Create Limits`, or `Create Principal Caps`) * a page-level `Reset` action ## Overview Purpose: high-level monitoring and vault metadata. Key elements: * Metric cards: `Number of loans`, `Current APY`, `Total volume`, `Total interest` * `Vault Info` chart with metric selectors (`APY`, `Deployed`, `Utilization`, `TVL`) and time ranges (`1D`, `1W`, `1M`) * `Supply Utilization` donut with used %, supplied amount, and vault limit * `Allocation` table with source, allocation amount/share, APY context, and pagination. Collateral rows link to the vault's loans against that asset * `Vault Metadata` form for name, manager name, description, cap, theme color, banner, icon, and manager image URLs, and `URL Access` tags ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/overview-01-summary-and-vault-info.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=ee543db99670cce74088f54085d805b0) *Overview tab with metric cards, vault info trend chart, and supply utilization.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/overview-02-allocation-table.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=fe7d551ad652dc55b62d223ee5e23a1f) *Allocation subsection showing source-level deployed balances, share percentages, APY, and pagination.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/overview-03-vault-metadata.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=0d774197f2bf3d364a4faa11b1328035) *Vault metadata editor with branding, links, tags, and save/reset controls.* ## Collateral Purpose: define allowed collateral assets and core risk limits per asset. Key elements: * Warning: increasing LTV triggers a 24-hour timelock * `+ Add collateral` action * Search and filter controls * Table fields per token: * `LTV` * `Liquidation LTV` * Delete action * Add-collateral modal: * category and custom views * token/address search * multi-select with `Clear`, `All`, and `Confirm selection` * lists collateral with a Loopscale-verified market configuration, whether or not your wallet holds it * oracle choice when an asset has more than one verified oracle * assets with a pending add can't be selected again until the timelock executes or is cancelled in `Timelocks` ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/collateral-01-table.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=06e164bec8855ec42d2f7de5d8962640) *Collateral table with token list and editable `LTV` and `Liquidation LTV` values.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/collateral-02-edited-summary.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=5e49c32532e69fe7550fc1660c127a6b) *Collateral edits with per-row reset, summarized diff, and `Save changes` action.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/collateral-03-add-collateral-modal.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=8f3a449d7517e3d3690c305ebac1d22b) *Add Collateral modal with category tabs, token search, multi-select, and confirm action.* ## Rates Purpose: set APY by token and tenor. Key elements: * Search and filters * Token table with tenor columns: * `1 day APY` * `1 week APY` * `1 month APY` * `3 months APY` * Each tenor can be set to: * a numeric percent value * `Disabled` ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/rates-01-table.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=ad0f07e3b79499666845460a3f0b2867) *Rates table with APY controls across 1 day, 1 week, 1 month, and 3 month tenors.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/rates-02-edited-summary.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=d0ea6f8a8d87a0d9f25b47e3254241fa) *Rates edits summarized before save, including transitions from `Disabled` to active APY values.* ## Allocation Purpose: cap max allocation per token. Key elements: * Warning: increasing allocation triggers a 24-hour timelock * Search and filters * `Max Allocation %` per token * Values can be numeric or `Disabled`, and can't exceed 100% * Primary action: `Create Limits` ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/allocation-01-table.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=699bc193600622bc32ba916645e5374b) *Allocation table with per-token maximum allocation controls.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/allocation-02-edited-summary.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=de82f39243e97386279561bd01d4cf82) *Allocation updates with pending changes summary and `Create Limits` apply action.* ## Settings Purpose: configure vault-level operating and fee behavior. Key elements: * `Disable vault deposits` / `Enable vault deposits`, which sends its own transaction and takes effect immediately * `Status`: `Disable originations` / `Enable originations` * `Fees`: * `Origination fee` * `Interest fee` * `Fund Management`: * `Idle capital` routing (`MarginFi` or `None`) * `Liquidity buffer` * `Max origination size` with principal symbol suffix (e.g. USDC) * `Pending Update` values under a field while a change is waiting on its timelock * Primary action: `Save changes` * Fee claim action (`No fee to claim` when unavailable) > [!WARNING] > > The banner on this tab says changes take effect immediately. On a live vault, everything saved with `Save changes` goes through a 24-hour timelock. See [Timelock delays](#timelock-delays). ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/settings-01-default.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=ecd328ff07c2573dcd6d36d2c27825a2) *Settings tab in default state with status controls and fee/risk parameters.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/settings-02-edited-summary.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=3622491323f603f584427116af537765) *Settings tab with pending updates and a detailed summary of parameter changes.* ## Principal Caps Purpose: control borrow/supply/withdraw throughput over 1-hour and 24-hour windows. Each window starts with the first action after the previous one expires. Key elements: * Scope toggle: * `Borrow` * `Supply` * `Withdraw` * Cap inputs by scope: * `Borrow`: `Max 1hr borrow`, `Max 24hr borrow`, `Max borrow` * `Supply`: `Max 1hr supply`, `Max 24hr supply`, `Max TVL` * `Withdraw`: `Max 1hr withdrawals`, `Max 24hr withdrawals` * `Disabled` is supported for unset caps * Usage progress bars show utilized value and percentage for active caps * Primary action: `Create Principal Caps` * Lowering caps has no delay ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/principal-caps-01-borrow-view.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=059c617329ca53ea1ad98e9aa70f5c07) *Principal Caps in Borrow mode, including active cap utilization bars and disabled cap state.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/principal-caps-02-withdraw-view-edited.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=7f38c81ce710d136878fd438ad560a5d) *Principal Caps in Withdraw mode with new limits staged and summarized before apply.* ## Timelocks Purpose: inspect and filter scheduled and historical manager actions. Key elements: * Status filters: * `Pending` * `Executed` * `Cancelled` * Sort direction toggle * `Include Instant` filter (not available on `Pending`) * Entry cards include: * status badge * action type badge (e.g. `Update LTV`, `Add Collateral`) * shortened reference * relative and absolute timestamps * expand/collapse caret * cancel action on pending entries Pending entries are executed automatically by Loopscale once their delay has passed. ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/timelocks-01-pending.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=dee5d9d17dcd8cc5d702cf09d9349b5f) *Timelocks filtered to `Pending`, showing scheduled updates and time remaining.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/timelocks-02-executed.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=6e146bff64faed070c608e3cda7ed70a) *Timelocks filtered to `Executed`, listing completed manager actions with timestamps.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/timelocks-03-cancelled.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=ac6a27129e61bd3012dcd9766b0392fe) *Timelocks filtered to `Cancelled`, showing aborted actions and history metadata.* ### Timelock delays Delays apply once a vault is live. A vault with deposits disabled and no LP supply has no delay on any change. | Change | Delay | | - | - | | Add collateral | 24 hours | | Increase `LTV` or `Liquidation LTV` | 24 hours | | Decrease `LTV` or `Liquidation LTV` | None | | Remove collateral | None | | Increase `Max Allocation %` | 24 hours | | Decrease `Max Allocation %` | None | | Update APYs on the `Rates` tab | None | | `Save changes` on the `Settings` tab (originations, idle capital, liquidity buffer, fees, max origination size) | 24 hours | | Lower max early unstake fee | None | | Enable or disable vault deposits | None (not a timelock) | ## Rewards Purpose: manage reward schedules and emissions for vault depositors. Key elements: * Search by token/address * `+ Add rewards` action * Rewards table columns: * `Rewards` * `Emitted` * `Claimed` * `Start` * `End` * row action (`Edit`) * Add Rewards modal: * token search * selectable wallet token list with amount and USD estimate * Edit Rewards modal: * reward token summary and wallet balance * editable schedule end time * computed change preview (undistributed rewards, end time, emissions/week) * warning/info banners for historical schedule edits ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/rewards-01-table.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=7d0832bf066d46d2bbe481597d26cc18) *Rewards tab with active/inactive schedules, emitted/claimed totals, and edit controls.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/rewards-02-add-rewards-modal.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=19bd21c2ebe97c7f555b944a22b38d17) *Add Rewards modal with token search and selectable wallet inventory.* ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/curator/rewards-03-edit-rewards-modal.png?fit=max\&auto=format\&n=7wEScHg4Gg_v9bhc\&q=85\&s=f75d61799e27bc4fa23ccf80abddb44c) *Edit Rewards modal with end-time adjustment, projected schedule changes, and contextual warnings.* ## Operational Notes * Higher-risk changes are surfaced through timelock flows. * Unsaved edits are explicitly summarized before apply. * Disabled states are represented in-table (for example `Disabled` caps or APY tenors). * Pagination appears in large lists (collateral, rates, allocation, timelocks). # Deposit to Loopscale Vaults Source: https://docs.loopscale.com/partners/guides/deposit Depositing into a Loopscale vault is a straightforward process that can be completed in just a few minutes. This guide walks through each step, from connecting a wallet to confirming a transaction. Once funds are deposited, they begin earning yield according to the parameters of the selected vault. Users can monitor the Vault strategy and their position in real time through the application. ## Supported Wallets Loopscale supports any wallet that meets Solana Wallet standards, including those listed below. WalletConnect is also available for compatible wallets such as Fireblocks. (Note: Squads multisig wallets are not currently supported.) > [accordion] Popular supported wallets > > * Phantom > * Backpack > * Solflare > * MagicEden > * Trust Wallet > * Brave > * Fireblocks > * Fordefi ## Navigate to Vault 1. Open the Lend page in the Loopscale app. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/lend-click.png) 2. Select a Vault to view its details. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/vault-click.png) ### Vault Detail Page > [accordion] Market Parameters > > Review the Market Parameters section for information on eligible collateral, terms, and upcoming parameter changes. > ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/parameters.png) > [accordion] Performance Metrics > > Explore such as APY, deployed capital, and loan volume in the historical charts section. > ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/historical-performance.png) ## Deposit to Vault 3. Click Connect in the top-right corner of the Loopscale app. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/connect.png) 4. Click Deposit and enter the desired amount. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/deposit-click.png) 5. Confirm the deposit transaction by signing in your wallet. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/deposit-submit.png) # Manage Loopscale Vault Position Source: https://docs.loopscale.com/partners/guides/manage 1. After connecting your wallet, open the Portfolio page to view active Vault positions. Click a position to see current value and interest earned. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/open-position.png) 2. Use the position details view to manage funds or return to the Vault page. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/withdraw-vault.png) 3. On the Vault Page, review your position details and historical performance. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/position-vault.png) 4. Monitor Live Metrics such as performance, allocations, and market activity directly on the Vault page. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/live-performance.png) ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/allocation.png) # Withdraw from Loopscale Vaults Source: https://docs.loopscale.com/partners/guides/withdraw 1. From the Portfolio page or the Vault page, click Withdraw. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/withdraw-click.png) 2. Enter the withdrawal amount and confirm. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/withdraw-submit.png) 3. Approve the withdrawal transaction by signing in your wallet. ![](https://loopscale-site.s3.us-east-1.amazonaws.com/docs/guides/withdraw-confirm.png) # How Loopscale Works Source: https://docs.loopscale.com/partners/issuers/how-loopscale-works > [card] > > To explore opportunities to integrate with Loopscale, reach out to Mary Gooneratne via [Telegram](https://t.me/marygooneratne) or [email](mailto:mary@loopscale.com). Loopscale enables programmable credit markets on Solana. A unified order book matches lenders and borrowers across flexible rates, durations, and collateral types. Partners can use this architecture to create new markets, drive sustainable liquidity, and shape how their assets are used. ![](https://mintcdn.com/loopscale-docs/7wEScHg4Gg_v9bhc/static/assets/images/how-loopscale-works.gif?s=a5b225fd7fdc95b5c67c42d9a7a4f1bb) While Loopscale supports deeply customizable credit products, the core user experience simplifies protocol interactions through streamlined flows. This guide provides a high-level overview of those flows and the underlying mechanics, helping partners understand key concepts and identify integration opportunities. ## Lending: Powering Loopscale Markets Lenders supply capital to Loopscale markets where it sits on the orderbook until matched to a borrower. Users interact with Loopscale's order book by depositing to Loopscale Vaults or opening an Advanced Lend Position. ### Loopscale Vaults Each Vault has a single loan asset and can deploy capital across multiple Loopscale Markets. The risk-return profile of a Vault is optimized by a Curator, an individual or team responsible for deciding eligible collateral, rates and terms, and how capital is allocated. Vaults can be used to drive strategic market outcomes, such as building liquidity around a new asset or creating a stable source of borrowable capital. \[!NOTE] Partners can add incentives to existing Vaults to subsidize borrowing rates for particular collateral or launch new Vaults to bootstrap new markets.