# Oracle SDK
Source: https://docs.reflect.money/api-reference/oracle

TypeScript SDK for Doppler, the efficient oracle used by Reflect.

### Installation

To install the Reflect Oracle SDK within your development environment, run one of the following commands:

<CodeGroup>
  ```bash yarn theme={null}
  yarn add @reflectmoney/oracle.ts
  ```

  ```bash npm theme={null}
  npm install @reflectmoney/oracle.ts
  ```

  ```bash pnpm theme={null}
  pnpm install @reflectmoney/oracle.ts
  ```
</CodeGroup>

### Overview

Doppler is the oracle solution used by Reflect. It enables extremely efficient oracle updates on Solana, requiring as little as 21 compute units per update. We use a fork of Doppler that uses 32 CUs due to an additional call to Clock sysvar.

* **Program ID**: `PRicevBH6BaeaE8qmrxrwGBZ5hSZ9vjBNue5Ygot1ML`

The SDK exposes the `Doppler` class for interacting with oracle accounts: creating new oracle accounts, updating their payloads, and reading the latest data.

### Quick Start

Initialize a `Doppler` instance with a Solana connection and an authority keypair.

```typescript initialize.ts theme={null}
import { Doppler } from "@reflectmoney/oracle.ts";
import { Connection, Keypair } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const admin = Keypair.fromSecretKey(/* admin secret key bytes */);

const doppler = new Doppler(connection, admin);
```

### Updating an Oracle

Create an 8-byte payload (u64) and submit an update for an existing oracle account.

```typescript updateOracle.ts theme={null}
import { PublicKey } from "@solana/web3.js";
import { createPricePayload, U8Array8Serializer } from "@reflectmoney/oracle.ts";

const oraclePublicKey = new PublicKey("ORACLE_ADDRESS");

// 8-byte payload representing a u64 value (e.g., 1_000_000 for 1 USDC with 6 decimals)
const pricePayload = createPricePayload(BigInt(1_000_000));

await doppler.updateOracle(
    oraclePublicKey,
    {
        slot: BigInt(Date.now()),
        payload: pricePayload,
    },
    new U8Array8Serializer(),
);
```

### Fetching Oracle Data

Read the latest oracle state and decode the price from the 8-byte payload.

```typescript fetchOracle.ts theme={null}
import { PublicKey } from "@solana/web3.js";
import { U8Array8Serializer, readPriceFromPayload } from "@reflectmoney/oracle.ts";

const oraclePublicKey = new PublicKey("ORACLE_ADDRESS");

const oracleData = await doppler.fetchOracle(
    oraclePublicKey,
    new U8Array8Serializer(),
);

if (oracleData) {
    console.log("Slot:", oracleData.slot);
    const price = readPriceFromPayload(oracleData.payload);
    console.log("Price:", price);
}
// Example output:
// Slot: 1728662400000n
// Price: 1000000n
```

### Creating an Oracle Account

Create a new oracle account with an initial payload and slot.

```typescript createOracle.ts theme={null}
import { U8Array8Serializer, createPricePayload } from "@reflectmoney/oracle.ts";

const oracleAccount = await doppler.createOracleAccount(
    "my-oracle-seed",
    new U8Array8Serializer(),
    {
        slot: 0n,
        payload: createPricePayload(BigInt(1_000_000)),
    }
);
```

### Payloads and Serializers

* **Payload format**: 8-byte array representing a u64. For prices, this commonly encodes fixed-point integers (e.g., micro-units for 6-decimal tokens).
* **Helpers**: `createPricePayload(u64)` and `readPriceFromPayload(payload)` provide convenient encoding/decoding for price data.
* **Serializer**: Use `U8Array8Serializer` to serialize and deserialize the 8-byte payloads when calling `updateOracle` and `fetchOracle`.

## Links

* **Reflect**: [https://reflect.money](https://reflect.money)

## License

MIT


# Whitelabel SDK
Source: https://docs.reflect.money/api-reference/proxy

Issue your own branded stablecoins backed by collateral in Reflect. Just select underlying asset, define yield split and upload metadata.

### Installation

To install Reflect Whitelabel SDK within your development environment, run the following command:

<CodeGroup>
  ```bash yarn theme={null}
  yarn add @reflectmoney/proxy.ts
  ```

  ```bash npm theme={null}
  npm install @reflectmoney/proxy.ts
  ```

  ```bash pnpm theme={null}
  pnpm install @reflectmoney/proxy.ts
  ```
</CodeGroup>

### Overview

Use this SDK to interact with Reflect Proxy Program, an onchain infrastructure for minting and redeeming whitelabel yield-bearing stablecoins backed by collateral in Reflect. This SDK offers high-level functionality for creating a new proxy, issuing a branded stablecoin, minting, redeeming, and managing the integration.

### Quick Start

To create a new proxy, use the static `initialize` method on the `Proxy` class exported from the SDK. When creating a new proxy instance via constructor, the SDK expects onchain accounts to be already initialized and loads them silently. Only use the constructor after setting up the onchain proxy first.

```typescript initialize.ts theme={null}
import { Proxy, USDC_PLUS_MINT } from "@reflectmoney/proxy.ts";
import { createSolanaRpc, address } from "@solana/kit";

// Initialize connection
const connection = createSolanaRpc("https://api.mainnet-beta.solana.com");

// Create a new proxy
const createProxyIx = await Proxy.initialize({
    signer,
    brandedMint: address("<branded mint address>"),
    feeBps: 100, // 1% fee
    stablecoinMint: address(USDC_PLUS_MINT)
});

// Transaction sign & send logic
```

To load an existing proxy, just use the constructor. In the background, the SDK will lazy-load all the necessary onchain state.

```typescript load.ts theme={null}
import { Proxy } from "@reflectmoney/proxy.ts";
import { createSolanaRpc, address } from "@solana/kit";

// Initialize connection
const connection = createSolanaRpc("https://api.mainnet-beta.solana.com");

// Create an instance of existing proxy
const proxy = new Proxy({ 
    connection, 
    proxyStateAddress: address("<your proxy account address>")
});
```

If you don't know the proxy account address, use the `loadFromMint` method that will load your Proxy when provided with the mint address of your branded stablecoin.

```typescript loadFromMint.ts theme={null}
import { Proxy } from "@reflectmoney/proxy.ts";
import { createSolanaRpc, address } from "@solana/kit";

// Initialize connection
const connection = createSolanaRpc("https://api.mainnet-beta.solana.com");

// Create an instance of existing proxy from mint
const proxy = Proxy.loadFromMint({ 
    connection, 
    brandedMint: address("<your branded stablecoin mint address>")
});
```

## Proxy Methods

##### `initialize(params)`

Creates a new proxy state account with the specified configuration.

**Parameters:**

* `signer: TransactionSigner` - The transaction signer who will pay for the transaction
* `authority?: Address` - Optional authority address (defaults to signer address)
* `brandedMint: Address` - The mint address of the branded token
* `feeBps: number` - The fee in basis points (e.g., 100 = 1%)
* `stablecoinMint: Address` - The mint address of the underlying stablecoin

**Returns:** `Promise<Instruction>` - A create proxy instruction

##### `loadFromMint(params)`

Creates a new Proxy instance by deriving the proxy state address from a branded mint.

**Parameters:**

* `connection: Rpc<SolanaRpcApi>` - The Solana RPC connection
* `brandedMint: Address` - The address of the branded mint

**Returns:** `Promise<Proxy>` - A new Proxy instance with loaded state data

##### `load()`

Reloads the proxy state data from the blockchain. It is lazily loaded when Proxy instance is initially created. Call to refresh the data.

**Returns:** `Promise<void>`

##### `deposit(params)`

Creates a deposit instruction that converts stablecoins to branded tokens.

**Parameters:**

* `signer: TransactionSigner` - The transaction signer who owns the tokens being deposited
* `amount: number` - The amount of stablecoins to deposit

**Returns:** `Promise<Instruction>` - A deposit instruction

##### `withdraw(params)`

Creates a withdraw instruction that converts branded tokens back to stablecoins.

**Parameters:**

* `signer: TransactionSigner` - The transaction signer who owns the branded tokens
* `amount: number` - The amount of branded tokens to withdraw

**Returns:** `Promise<Instruction>` - A withdraw instruction

##### `claimFees()`

Creates a claim fees instruction for the proxy authority to collect accumulated fees.

**Returns:** `Promise<Instruction>` - A claim fees instruction

### PdaClient

Utility class for finding PDAs.

##### `deriveProxyState(brandedMint)`

Derives the proxy state PDA from a branded mint address.

**Parameters:**

* `brandedMint: Address` - The branded mint address

**Returns:** `Promise<[Address, number]>` - A tuple containing the PDA address and bump seed

## Usage Examples

### Creating a New Proxy

```typescript theme={null}
import { Proxy, USDC_PLUS_MINT } from "@reflectmoney/proxy.ts";
import { address } from "@solana/kit";

const createInstruction = await Proxy.initialize({
    signer: myWallet,
    authority: address("AuthorityAddress"),
    brandedMint: address("BrandedTokenMint"),
    feeBps: 50, // 0.5% fee
    stablecoinMint: address(USDC_PLUS_MINT) // USDC+
});
```

### Loading and Using an Existing Proxy

```typescript theme={null}
// Method 1: Load from mint address
const proxy = await Proxy.loadFromMint({
    connection: myConnection,
    brandedMint: address("BrandedTokenMint")
});

// Method 2: Create instance and re-load manually
const proxy2 = new Proxy({
    connection: myConnection,
    proxyAddress: address("ProxyStateAddress")
});
await proxy2.load();
```

### Depositing Stablecoins

```typescript theme={null}
const depositInstruction = await proxy.deposit({
    signer: myWallet,
    amount: 1_000_000 // 1 USDC+ (6 decimals)
});
```

### Withdrawing to Stablecoins

```typescript theme={null}
const withdrawInstruction = await proxy.withdraw({
    signer: myWallet,
    amount: 1_000_000 // 1 branded token (6 decimals)
});

```

### Claiming Fees (Authority Only)

```typescript theme={null}
const claimFeesInstruction = await proxy.claimFees();
```

### Working with PDAs

```typescript theme={null}
import { PdaClient } from "@reflectmoney/proxy.ts";

const [proxyStateAddress, bump] = await PdaClient.deriveProxyState(
    address("<branded token mint>")
);

console.log("Proxy State PDA:", proxyStateAddress);
console.log("Bump seed:", bump);
```

## Constants

The SDK exports the following constants:

* `PROXY_STATE_SEED` - The seed used for proxy state PDA derivation
* `USDC_PLUS_ORACLE` - The oracle address tracking the real-time USDC+ exchange rate
* `REFLECT_PROXY_PROGRAM_PROGRAM_ADDRESS` - The program ID

## Support

For issues, questions, or contributions:

* **Repository:** [https://github.com/palindrome-eng/reflect-proxy-program](https://github.com/palindrome-eng/reflect-proxy-program)
* **Authors:** L0STE, stablecoinjesus @ Palindrome Engineering

## License

MIT License


# Stablecoin SDK
Source: https://docs.reflect.money/api-reference/stablecoin

Develop next-generation fintech applications with the full power of yield-bearing stablecoins.

![Docs Stablets Image Pn](https://github.com/palindrome-eng/docs/blob/main/images/docs-stablets-image.png?raw=true)

### Installation

To install Reflect Stablecoin SDK within your development environment, run the following command:

<CodeGroup>
  ```bash yarn theme={null}
  yarn add @reflectmoney/stable.ts
  ```

  ```bash npm theme={null}
  npm install @reflectmoney/stable.ts
  ```

  ```bash pnpm theme={null}
  pnpm install @reflectmoney/stable.ts
  ```
</CodeGroup>

### Core

The SDK exposes three core modules:

* `Reflect`, a general-purpose class for protocol setup and interactions with base functionalities.
* `ReflectKeeper`, a class exposing keeper-level functions necessary for maintenance and risk management. The majority of these functionalities require authentication at the protocol level.
* `PdaClient`, a class exposing functions for derivation of PDAs storing state within the Reflect Protocol.

### Stablecoins

In most cases, usage of the three classes above will not be necessary for simple integrations and usage of Reflect stablecoins. For every stablecoin, the SDK exposes a separate class equipped with functions for minting, redemption, and administrative features. All these classes follow the schema of the `Stablecoin` superclass.

```typescript Stablecoin.ts theme={null}
abstract class Stablecoin {
    // Internal index used for derivation.
    public index: number;
    // Name of the strategy.
    public name: string;
    // RPC connection class.
    public connection: Connection;
    // Public key of the controller account.
    public controller: PublicKey;
    // List of collateral assets allowed for deposits.
    public collaterals: Collateral[];
    // Mint of the stablecoin.
    public stablecoinMint: PublicKey;
    // Pyth client used for pricing data.
    public pythClient: HermesClient;
    // Drift client, only required for Drift-powered strategies.
    public driftClient?: DriftClient;

    // Generate user's token accounts if minting for the first time.
    abstract initializeTokenAccounts(owner: PublicKey, mints: PublicKey[], signer: PublicKey): Promise<TransactionInstruction[]>;

    // Mint a stablecoin to user's wallet.
    abstract mint(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;

    // Redeem a stablecoin into underlying collateral.
    abstract redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;

    // Rebalance the strategy internal balances. Currently permissioned, requiring authentication at the protocol level.
    abstract rebalance(signer: PublicKey): Promise<TransactionInstruction[]>;
}
```

Currently, the SDK exposes `Stablecoin` classes for all three Reflect stablecoins:

* `UsdcPlusStablecoin`, for integration with USDC+ (Index 0) - Live
* `UsdjStablecoin`, for integration with JLP Hedged (Index 1) - Coming soon
* `LstStablecoin`, for integration with LST Delta-Neutral (Index 2) - Live

### Creating and redeeming Reflect stablecoins with TypeScript

Follow the scripts below to mint and redeem Reflect stablecoins. All `Stablecoin` subclasses expose methods following the same schema, so the code below works interchangeably with minor changes.

<CodeGroup>
  ```typescript mintUsdcPlus.ts icon=square-js lines theme={null}
  import { UsdcPlusStablecoin } from "@reflectmoney/stable.ts";
  import { Connection, Keypair, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
  import BN from "bn.js";

  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const stablecoin = new UsdcPlusStablecoin(connection);

  // Load controller data for the most up-to-date stablecoin setup.
  await stablecoin.load(connection);

  // Use an actual user's public key, read from wallet adapter or local environment.
  const user = Keypair.generate();

  // $1000 USD
  const AMOUNT = new BN(1000 * Math.pow(10, 6));
  const MIN_RECEIVED = new BN(999 * Math.pow(10, 6)); // 0.1% slippage protection

  const ix = await stablecoin.mint(
      user.publicKey,
      AMOUNT,
      MIN_RECEIVED
  );

  const { blockhash } = await connection.getLatestBlockhash();

  const {
      value: lookupTable
  } = await connection.getAddressLookupTable(
      stablecoin.lookupTable
  );

  const message = new TransactionMessage({
      instructions: ix,
      payerKey: user.publicKey,
      recentBlockhash: blockhash
  }).compileToV0Message([lookupTable]);

  const transaction = new VersionedTransaction(message);

  // Transaction signature and confirmation logic, adjust for your needs.
  transaction.sign([user]);
  await connection.sendRawTransaction(transaction.serialize());
  ```

  ```typescript redeemUsdcPlus.ts icon=square-js lines theme={null}
  import { UsdcPlusStablecoin } from "@reflectmoney/stable.ts";
  import { Connection, Keypair, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
  import BN from "bn.js";

  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const stablecoin = new UsdcPlusStablecoin(connection);

  // Load controller data for the most up-to-date stablecoin setup.
  await stablecoin.load(connection);

  // Use an actual user's public key, read from wallet adapter or local environment.
  const user = Keypair.generate();

  // $999 USD worth of USDC+
  const AMOUNT = new BN(999 * Math.pow(10, 6));
  const MIN_RECEIVED = new BN(1000 * Math.pow(10, 6)); // USDC+ is yield bearing, so you'll receive more USDC over time

  const ix = await stablecoin.redeem(
      user.publicKey,
      AMOUNT,
      MIN_RECEIVED
  );

  const { blockhash } = await connection.getLatestBlockhash();

  const {
      value: lookupTable
  } = await connection.getAddressLookupTable(
      stablecoin.lookupTable
  );

  const message = new TransactionMessage({
      instructions: ix,
      payerKey: user.publicKey,
      recentBlockhash: blockhash
  }).compileToV0Message([lookupTable]);

  const transaction = new VersionedTransaction(message);

  // Transaction signature and confirmation logic, adjust for your needs.
  transaction.sign([user]);
  await connection.sendRawTransaction(transaction.serialize());
  ```

  ```typescript mintLst.ts icon=square-js lines theme={null}
  import { LstStablecoin } from "@reflectmoney/stable.ts";
  import { Connection, Keypair, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
  import BN from "bn.js";

  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const stablecoin = new LstStablecoin(connection);

  // Load controller data for the most up-to-date stablecoin setup.
  await stablecoin.load(connection);

  // Use an actual user's public key, read from wallet adapter or local environment.
  const user = Keypair.generate();

  // $1000 USD worth of LST
  const AMOUNT = new BN(1000 * Math.pow(10, 6));
  const MIN_RECEIVED = new BN(999 * Math.pow(10, 6)); // 0.1% slippage protection

  const ix = await stablecoin.mint(
      user.publicKey,
      AMOUNT,
      MIN_RECEIVED
  );

  const { blockhash } = await connection.getLatestBlockhash();

  const {
      value: lookupTable
  } = await connection.getAddressLookupTable(
      stablecoin.lookupTable
  );

  const message = new TransactionMessage({
      instructions: ix,
      payerKey: user.publicKey,
      recentBlockhash: blockhash
  }).compileToV0Message([lookupTable]);

  const transaction = new VersionedTransaction(message);

  // Transaction signature and confirmation logic, adjust for your needs.
  transaction.sign([user]);
  await connection.sendRawTransaction(transaction.serialize());
  ```
</CodeGroup>

## Yield distribution of the stablecoin

Depending on the selected stablecoin, yield is distributed in one of two ways:

* Natively, via the base stablecoin appreciating in value
* Through a "tokenized bond", a yield-bearing receipt token obtained after depositing the base stablecoin in Reflect Tokenized Bonds program

Currently, the USDC+ stablecoin is natively appreciating in value and does not require manual wrapping. All other stablecoins distribute their yield through the yield-bearing receipts.

Yield-bearing receipts are based on the following flow:

1. Deposit the collateral into a yield-bearing strategy
2. Mint the base stablecoin
3. Wrap the base stablecoin into a yield-bearing receipt
4. Continuously mint more of the base stablecoin against the yield generated from the strategy to keep the price of the base stablecoin at \$1 USD
5. Deposit stablecoins minted in the following steps to the yield distribution program

As a result, the yield-bearing receipts appreciate in value over time, as the underlying pool of the base stablecoin grows, while the amount of receipt tokens stays the same.

### Reflect Tokenized Bond

The Reflect SDK exposes a `ReflectTokenizedBond` class. It is an interface for interacting with the tokenized bond program used for distribution of the yield generated by underlying collateral of the Reflect stablecoins. On a daily basis, Reflect protocol keepers monitor the yield generated by Reflect and move it into the yield distribution program.

#### Usage

To interact with the tokenized bond program, use the following snippets:

<CodeGroup>
  ```typescript deposit.ts icon=square-js lines theme={null}
  import { ReflectTokenizedBond, UsdjStablecoin } from "@reflectmoney/stable.ts";
  import { Connection, Keypair, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
  import BN from "bn.js";

  const user = Keypair.generate();

  const stablecoin = new UsdjStablecoin(connection);
  const reflectTokenizedBond = new ReflectTokenizedBond(connection);

  const AMOUNT = new BN(1000 * 1_000_000);

  const instruction = reflectTokenizedBond.deposit(
      user.publicKey,
      stablecoin.index,
      AMOUNT
  );

  const { blockhash } = await connection.getLatestBlockhash();

  const message = new TransactionMessage({
      instructions: [instruction],
      payerKey: user.publicKey,
      recentBlockhash: blockhash
  }).compileToV0Message();

  const transaction = new VersionedTransaction(message);

  // Transaction signature and confirmation logic, adjust for your needs.
  transaction.sign([user]);
  await connection.sendRawTransaction(transaction.serialize());
  ```

  ```typescript withdraw.ts icon=square-js lines theme={null}
  import { ReflectTokenizedBond, UsdjStablecoin } from "@reflectmoney/stable.ts";
  import { Connection, Keypair, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
  import BN from "bn.js";

  const user = Keypair.generate();

  const stablecoin = new UsdjStablecoin(connection);
  const reflectTokenizedBond = new ReflectTokenizedBond(connection);

  const AMOUNT = new BN(1000 * 1_000_000);

  const instruction = reflectTokenizedBond.withdraw(
      user.publicKey,
      stablecoin.index,
      AMOUNT
  );

  const { blockhash } = await connection.getLatestBlockhash();

  const message = new TransactionMessage({
      instructions: [instruction],
      payerKey: user.publicKey,
      recentBlockhash: blockhash
  }).compileToV0Message();

  const transaction = new VersionedTransaction(message);

  // Transaction signature and confirmation logic, adjust for your needs.
  transaction.sign([user]);
  await connection.sendRawTransaction(transaction.serialize());
  ```
</CodeGroup>


# Audits
Source: https://docs.reflect.money/audits

Every Reflect program is independently reviewed more than once, with all reports published in full.

<img alt="Reflect Banner" />

#### Audits

Reflect's onchain programs have been independently reviewed by Offside Labs and by Adevar Labs. The number of reviews differs by program, since some were added more recently than others, so each program's history is listed below.

Reports are published in full rather than summarised, in the [audits repository](https://github.com/palindrome-eng/audits), and findings were addressed before publication. The Adevar Labs reports are being prepared and will be linked here.

#### Programs And Their Reviews

<Card title="Core: Yield Routing" icon="route">
  Directs and manages yield across every product.

  [Offside Labs, September 2025](https://github.com/palindrome-eng/audits/blob/main/Reflect-DeltaNeutral-Sep-2025-OffsideLabs.pdf) · [Offside Labs, February 2026](https://github.com/palindrome-eng/audits/blob/main/Reflect-ReflectCoreYieldRouting-Feb-2026-OffsideLabs.pdf) · Adevar Labs
</Card>

<Card title="Core: Indexes" icon="layer-group">
  Builds and maintains baskets of collateral behind a single token.

  Adevar Labs
</Card>

<Card title="Tranches" icon="shield-halved">
  Splits a yield-bearing asset into senior and junior positions and enforces the loss waterfall.

  Offside Labs · Adevar Labs
</Card>

<Card title="Whitelabel" icon="tag">
  Issues branded, yield-bearing tokens against collateral in Reflect, including the zero-fee swap path for retail-sized transactions.

  [Offside Labs, November 2025](https://github.com/palindrome-eng/audits/blob/main/Reflect-Proxy-Nov-2025-OffsideLabs.pdf) · Adevar Labs
</Card>

*Reviews without a link above have reports awaiting publication.*

#### Two Kinds Of Review

<Card title="Code security audits" icon="file-code">
  Line-by-line review of the programs themselves, looking for exploitable flaws: access control gaps, unvalidated accounts, arithmetic errors, privilege escalation, and anything that could move funds where they should not go.
</Card>

<Card title="Economic security audits" icon="chart-mixed">
  Review of the strategy rather than the code. Simulation and backtesting of how a strategy behaves under stress, including scenarios well outside normal conditions, carried out by firms specialising in financial rather than software review.
</Card>

#### What An Audit Does And Does Not Tell You

* **It is a point in time.** Each report reviews specific code as it stood on a specific date. Code changed afterwards is outside that report's scope, which is part of why programs are reviewed more than once.
* **It is not a warranty.** A clean report means reviewers found no unresolved issues in what they examined. It is not a statement that no flaw exists.
* **Code review and strategy review are separate.** A code audit says nothing about whether a strategy is economically sound, and an economic audit says nothing about whether the code implementing it is safe. Both matter, which is why both happen.
* **It covers Reflect's programs, not everyone else's.** Reserves sit in third-party lending markets with their own code and their own audit histories. Those are worth reading separately, and are covered under [Risk](https://docs.reflect.money/risk).

#### Next

<Columns>
  <Card title="Risk" icon="triangle-exclamation" href="https://docs.reflect.money/risk">
    What can go wrong, what reduces it, and what you can do.
  </Card>

  <Card title="Compliance" icon="scale-balanced" href="https://docs.reflect.money/compliance">
    How the architecture affects your regulatory position.
  </Card>
</Columns>


# Compliance
Source: https://docs.reflect.money/compliance

Non-custodial by construction. What that means for your regulatory position, and where the line sits.

<img alt="Reflect Banner" />

#### Compliance

Most teams are not blocked by engineering. They are blocked by whether shipping a product that pays interest creates obligations they cannot meet.

Reflect is built around the control-based framework at the centre of the CLARITY Act. Reflect never holds your customers' money, and where that money sits is decided by published rules rather than by anyone's judgement.

That framing follows US law. **<u>Nothing here is legal advice or should be relied on as such.</u>** What it means for your own position depends on your business and your markets, so form your own view with counsel.

#### What Would Make You Regulated

Obligations attach to control, not to the product you are building. Three statuses matter, and each turns on whether someone can make decisions about other people's money at their own discretion.

<Card title="Custodian" icon="vault">
  **What makes you one:** holding your customers' money.

  **What happens instead:** deposits are held by the contracts themselves. Nobody at Reflect and nobody at your company holds a key that can move them, and every movement of money is signed by the customer who owns it, including when they sign in with an email rather than a wallet. Redemption runs against the contracts directly rather than through an approval step. Protect junior positions carry a waiting period, set per market and published in advance.
</Card>

<Card title="Manager" icon="sliders">
  **What makes you one:** deciding where your customers' money goes.

  **What happens instead:** where deposits sit is determined by a published methodology built with [Blockworks Advisory](https://www.blockworksresearch.com/advisory) and carried out automatically. No one picks venues in the moment, and because the methodology is public, changes to it are visible rather than silent.
</Card>

<Card title="Issuer" icon="stamp">
  **What makes you one:** issuing a claim against reserves you hold yourself.

  **What happens instead:** you hold no reserves. Every token is backed by assets sitting in the contracts, and holders redeem against those assets directly rather than against a promise from you.
</Card>

*CLARITY draws its lines the same way, by control rather than by asset type, and separates teams who build systems they do not control from institutions that operate them. It is **not law**, so Reflect works under the rules that exist today. That costs nothing, because the control test is not CLARITY's invention.*

#### Where The Line Sits

<Info>
  **Reflect holds no customer money, touches no cash, and leaves no allocation to anyone's judgement.** Obligations generally follow from activity outside the system rather than from the integration itself. This reflects how the question is approached in the United States; other jurisdictions draw the line differently, and your own facts govern.
</Info>

<Card title="Inside Reflect" icon="circle-check">
  Holding a balance that earns. Issuing your own token. Adjusting its risk. Moving between Reflect assets. All of it settles in the assets themselves, inside the contracts.

  No custody, no cash, and nobody choosing where the money goes.
</Card>

<Card title="Outside Reflect" icon="circle-exclamation">
  Converting to or from cash. Bank accounts. Card issuance. Lending your own money against customer balances. Holding customer assets yourself.

  Regulated activity, and either yours to licence or your partner's.
</Card>

<Accordion title="Example: a customer paying a merchant" icon="arrow-right-arrow-left">
  Your app converts their token back into USDC in a single step, then hands off to a licensed stablecoin payments provider. Reflect's part was handing the customer their own money back. The regulated part is cash reaching the merchant, and the provider holds that licence.
</Accordion>

Either way, you own the customer relationship: what you tell holders about what backs their balance, and any rate you quote them.

#### Why Some Functions Are Gated Today

Routine upkeep moves money between approved venues as rates change, and sweeps earned interest into distribution. These operations carry out what the published rules already specify, and cannot direct money to a caller's benefit, so there is no structural reason to restrict who runs them. Architecturally anyone can.

Those calls are limited to approved callers during rollout because the rules are unsettled, not because the design requires it. The restriction lifts as the framework settles, and the architecture does not change when it does.

#### Common Questions

<AccordionGroup>
  <Accordion title="Do I need a licence to integrate Reflect?" icon="question">
    Reflect involves no holding of customer money, no allocation decisions and no claim issued against reserves you hold. Licensing generally follows from activity outside the system, as above. Your own facts and markets determine the answer, and counsel should confirm it rather than this page.
  </Accordion>

  <Accordion title="If Reflect handles wallets for my users, is that custody?" icon="question">
    No. Account abstraction removes the public key from the experience, not the control. Your customer signs in with an email address or the account they already have with you, and that only authenticates them to a key that stays theirs. Nobody at Reflect and nobody at your company can sign on their behalf, and there is no support desk holding balances or moving funds for people.
  </Accordion>

  <Accordion title="Is the token I create a security?" icon="question">
    Reflect does not give an opinion on that, and nothing here should be read as one. Classification turns on how your token is structured, how you market it, who you offer it to and where.

    What Reflect does is keep the infrastructure clear of the features that usually attract the question. Only permissionless, freely transferable collateral is eligible, so assets carrying transfer restrictions or holder eligibility requirements are excluded by design. Reflect holds no reserves, so redemption runs against the backing assets themselves rather than a promise from anyone. Nothing in the design requires you to take discretion over what holders own.

    Your own choices still matter. A token with fixed composition, redeemable pro rata into what actually backs it, and not marketed on expected returns looks materially different from one whose mix is selected and revised for a fee. Take the version you intend to ship to counsel before you launch it.
  </Accordion>

  <Accordion title="Can I offer this in my market?" icon="question">
    The contracts are public and enforce no geographic restrictions, so deciding which markets you serve sits with your application. Treatment outside the United States varies and is moving, so take your own markets to your own counsel.
  </Accordion>

  <Accordion title="What happens if the underlying loses money?" icon="question">
    Losses fall on holders of the affected asset. There is no insurance fund and no guarantee of principal. For downside protection, [Protect](https://docs.reflect.money/products/protect) lets you hold a senior position where other capital absorbs losses first.
  </Accordion>

  <Accordion title="Where does CLARITY stand right now?" icon="landmark">
    It passed the House in July 2025 and was advanced by the Senate Banking Committee in May 2026. It missed a floor vote before the August 2026 recess, a cloture motion on the motion to proceed was filed on 8 August, and the first procedural vote is expected after the Senate returns on 14 September. Passage requires 60 votes and remains genuinely uncertain.

    *Last reviewed 10 August 2026.*
  </Accordion>

  <Accordion title="What if CLARITY does not pass?" icon="landmark">
    The architecture does not change. The same control test runs through custody rules, adviser regulation, the SEC's Regulation Crypto rulemaking expected to reach formal proposal in the second half of 2026, and decades of case law on who exercises discretion over whose assets. A system where nobody holds discretionary authority answers that question the same way under all of them. CLARITY would make the answer explicit rather than create it.
  </Accordion>

  <Accordion title="Who has reviewed this architecture?" icon="scale-balanced">
    It was developed with counsel, and informed by conversations with people at and around the agencies that will administer these rules. That is not an endorsement from any of them, and nothing on this page is a compliance certification.
  </Accordion>

  <Accordion title="Who has audited the code?" icon="file-shield">
    Offside Labs and Adevar Labs, across Reflect Core, yield routing and the whitelabel program. Every report is public in the [audits repository](https://github.com/palindrome-eng/audits).
  </Accordion>
</AccordionGroup>

#### Next

<Columns>
  <Card title="Risk" icon="triangle-exclamation" href="https://docs.reflect.money/risk">
    Risk types, collateral review and how losses are absorbed.
  </Card>

  <Card title="Audits" icon="file-shield" href="https://docs.reflect.money/audits">
    Offside Labs and Adevar Labs reports in full.
  </Card>
</Columns>

***

*This page describes how Reflect is built. It is not legal advice, not an opinion on your regulatory position, and not a compliance certification. Regulation in this area is unsettled and moving. Form your own view with counsel who knows your markets.*


# For Developers
Source: https://docs.reflect.money/developers

Three TypeScript kits and a REST API for yield-bearing stablecoins.

<img alt="Reflect Banner" />

#### Reflect for Developers

Reflect exposes Earn, Create and Protect through three TypeScript kits and a REST API. Every write path returns an unsigned instruction or transaction that you sign and submit, so funds never pass through Reflect.

<Columns>
  <Card title="Stablecoin SDK" icon="chart-line-up" href="https://docs.reflect.money/api-reference/stablecoin">
    `@reflectmoney/stable.ts`

    Mint and redeem plus assets. Interest on user balances, savings accounts, idle float.
  </Card>

  <Card title="Whitelabel SDK" icon="tag" href="https://docs.reflect.money/api-reference/proxy">
    `@reflectmoney/proxy.ts`

    Issue a branded stablecoin backed by Reflect collateral. Set your fee, claim your cut.
  </Card>

  <Card title="Oracle SDK" icon="tower-broadcast" href="https://docs.reflect.money/api-reference/oracle">
    `@reflectmoney/oracle.ts`

    Read and write Doppler oracle accounts. 32 compute units per update.
  </Card>

  <Card title="REST API" icon="server" href="https://docs.reflect.money/reflect-api/health/health-check">
    Mint, redeem, quotes, APY, exchange rates, stats and events over HTTP, in any language.
  </Card>
</Columns>

#### Your First Call

Live rates for every supported asset, no key required.

```bash theme={null}
curl https://prod.api.reflect.money/stablecoin/apy
```

Base URLs are `https://prod.api.reflect.money` and `https://dev.api.reflect.money`. Reads are open at 100 requests per minute. Writes use the `X-API-Key` header and lift that to 500.

#### Point Your AI At Reflect

Every page is published for agents, so Claude, Cursor or ChatGPT can write against the current spec rather than guess at it.

* **Connect the MCP server** at `https://docs.reflect.money/mcp` for live access to every page and endpoint.
* **Or paste the whole site**: [llms-full.txt](https://docs.reflect.money/llms-full.txt) is the complete docs in one file, and [llms.txt](https://docs.reflect.money/llms.txt) is the page index.
* **Append `.md`** to any docs URL to get that page as clean Markdown.

#### Getting Access

Reflect is in closed beta, and integrators whitelist their own users.

<Steps>
  <Step title="Initialize your integration">
    `POST /integration/initialize/flow` creates your branded mint, uploads metadata, transfers authority and registers the integration in one transaction.
  </Step>

  <Step title="Reveal your API key">
    `POST /integration/api-key/reveal`, signed by your integration authority. Signatures are valid for one minute. Rotate at any time with `/integration/api-key/rotate`.
  </Step>

  <Step title="Whitelist your users">
    `POST /integration/whitelist` returns a transaction to submit for the users you are onboarding.
  </Step>
</Steps>

#### Worth Knowing

* **You sponsor gas, not your users.** Set `feePayer` to your own address on mint and Reflect covers transaction fees and token account creation in the same call. Accounts are initialized automatically when they do not exist.
* **You set the split.** `feeBps` on your integration defines your cut, claimable at any time through `claimFees`.
* **Contracts are audited and public.** Multiple independent reviews across core, yield routing whitelabel and tranches all reports in the [audits repository](https://github.com/palindrome-eng/audits).

#### Reference

<Columns>
  <Card title="REST API" icon="code" href="https://docs.reflect.money/reflect-api/health/health-check">
    Full endpoint reference for stablecoins, integrations, tranches, stats and events.
  </Card>

  <Card title="Developer Kits" icon="cube" href="https://docs.reflect.money/api-reference/stablecoin">
    Installation and integration walkthroughs for each SDK.
  </Card>

  <Card title="USDC+ Strategy" icon="chart-mixed" href="https://docs.reflect.money/strategies/USDC">
    How allocation works, and the risks integrators inherit.
  </Card>

  <Card title="Risk Framework" icon="shield-halved" href="https://docs.reflect.money/risk">
    Asset classification, economic audits and code audits.
  </Card>
</Columns>


# FAQs
Source: https://docs.reflect.money/faq

Common questions about Reflect, its products, and the risks involved.

### General

<AccordionGroup>
  <Accordion title="What is Reflect?" icon="question">
    Reflect is infrastructure for building with stablecoins. It lets you earn on stablecoins you already hold, launch your own yield-bearing asset, and tranche the risk of either, all through a single API.
  </Accordion>

  <Accordion title="Does Reflect issue its own stablecoins?" icon="question">
    **No.** Reflect does not create new dollars and is not a stablecoin issuer. Plus assets are wrapped, yield-bearing versions of stablecoins that already exist, issued entirely by onchain programs rather than by a company. Reflect provides the infrastructure that performs the wrapping.
  </Accordion>

  <Accordion title="What blockchain is Reflect available on?" icon="question">
    Solana. Applications built on Reflect can offer plus assets to their own users without those users ever handling a wallet.
  </Accordion>

  <Accordion title="Does Reflect hold my funds?" icon="question">
    No. Deposits are held by onchain programs, not by Reflect. Nobody can withdraw your funds, redirect them, or stop you redeeming.
  </Accordion>

  <Accordion title="Is Reflect affiliated with Circle or Tether?" icon="question">
    Reflect is a [Member of the Circle Alliance](https://partners.circle.com/partner/reflect-money), but is not affiliated with or endorsed by Circle Inc, Tether, or any other issuer. They are entirely separate entities.
  </Accordion>

  <Accordion title="What are the official Reflect channels?" icon="question">
    Reflect operates publicly through X only, at [@reflectmoney](https://x.com/reflectmoney). We do not operate an official Discord, Telegram, Bluesky, LinkedIn, or any other platform not listed here.
  </Accordion>

  <Accordion title="Can I work at Reflect?" icon="question">
    Looking to join the team? See our [jobs page](https://jobs.reflect.money).
  </Accordion>
</AccordionGroup>

### Earn

<AccordionGroup>
  <Accordion title="What is a plus asset?" icon="question">
    A plus asset is a stablecoin you already hold, wrapped so that it earns interest. Deposit USDC and you hold USDC+, which is worth slightly more than USDC and grows over time.
  </Accordion>

  <Accordion title="Which stablecoins can I earn on?" icon="question">
    USDC and USDT. Additional yield-bearing assets are available through Protect's tranche markets.
  </Accordion>

  <Accordion title="Where does the interest come from?" icon="question">
    Plus asset reserves are supplied to overcollateralised lending markets on Solana, including Kamino and Jupiter, where borrowers pay interest for liquidity. Allocation follows a risk-adjusted methodology built with [Blockworks Advisory](https://www.blockworksresearch.com/advisory) and published in full.
  </Accordion>

  <Accordion title="How do I receive my interest?" icon="question">
    Plus assets appreciate in value. You keep the same number of tokens and each one becomes worth more, so there is nothing to claim.
  </Accordion>

  <Accordion title="Can I withdraw at any time?" icon="question">
    Yes. Deposits and redemptions are instant and atomic, with no lockups and no notice period.
  </Accordion>

  <Accordion title="How does Reflect show interest rates?" icon="question">
    Reflect shows the real-time rate, derived from interest actually generated on a second-by-second basis. Trailing averages can flatter a rate that has already changed, so we do not use them.
  </Accordion>

  <Accordion title="Is there a limit on how much I can deposit?" icon="question">
    Each plus asset has a supply cap. Current caps, supply and remaining capacity are available from the `/stablecoin/limits` endpoint.
  </Accordion>

  <Accordion title="Is USDC+ as safe as USDC?" icon="question">
    No. A plus asset carries the risk of every lending market its reserves are supplied to, on top of the risk of the underlying stablecoin. Treat it as a higher-risk asset than the stablecoin it wraps, and read the [strategy page](https://docs.reflect.money/strategies/USDC) before depositing.
  </Accordion>
</AccordionGroup>

### Create

<AccordionGroup>
  <Accordion title="What can I launch with Create?" icon="question">
    Your own yield-bearing asset. Issue it as a branded stablecoin for your app or community, or as an index token that holds a basket of assets in one place.
  </Accordion>

  <Accordion title="What can back the asset I create?" icon="question">
    Collateral from across Solana, including plus assets, Protect senior positions, tokenised treasuries, equities and funds.
  </Accordion>

  <Accordion title="Do I earn anything from issuing it?" icon="question">
    Yes. You set your own share of the interest when you create the asset, and claim it whenever you like.
  </Accordion>

  <Accordion title="Can holders redeem at any time?" icon="question">
    Yes. Issue and redeem happen atomically against the underlying collateral, with no queue and no cooldown.
  </Accordion>

  <Accordion title="Can my asset pay interest to wallets instead of appreciating?" icon="question">
    Yes. Issuers can choose to stream interest directly to holders' wallets rather than have the token appreciate in price. This suits payroll, liquidity pools, and jurisdictions that treat price appreciation differently.
  </Accordion>
</AccordionGroup>

### Protect

<AccordionGroup>
  <Accordion title="What does Protect do?" icon="question">
    It splits a yield-bearing asset into two markets, senior and junior. Senior pays part of its interest to junior. In exchange, junior absorbs losses first.
  </Accordion>

  <Accordion title="Should I hold senior or junior?" icon="question">
    Hold **senior** for a lower rate with a cushion beneath it, if protecting your balance matters more than maximising it. Hold **junior** for an amplified rate, if you are willing to take the first loss to get it.
  </Accordion>

  <Accordion title="Can I lose money?" icon="question">
    Yes. Junior positions are designed to absorb losses before senior positions do, so a loss on the underlying asset reaches junior holders first. Senior is protected only up to the size of the junior tranche beneath it.
  </Accordion>

  <Accordion title="Can I withdraw at any time?" icon="question">
    Senior positions can be redeemed at any time. **Junior positions have a cooldown**: you request a redemption, wait out the period set by that market, then execute it. Cooldown length is published in each market's configuration.
  </Accordion>

  <Accordion title="What can be tranched?" icon="question">
    Reflect's own plus assets, third-party vaults and any other supported yield-bearing asset, including assets created with Create.
  </Accordion>

  <Accordion title="How do I know how much protection senior has?" icon="question">
    Each market publishes a coverage ratio comparing junior and senior size. The larger the junior tranche relative to senior, the more loss senior is shielded from.
  </Accordion>
</AccordionGroup>

### Risk and Security

<AccordionGroup>
  <Accordion title="Have the contracts been audited?" icon="question">
    Yes, by Offside Labs and Adevar Labs, covering Reflect Core, yield routing, the whitelabel program and tranches. Every report is public in our [audits repository](https://github.com/palindrome-eng/audits).
  </Accordion>

  <Accordion title="Are deposits insured?" icon="question">
    No. Rather than operate an insurance fund, Reflect runs open tranche markets where anyone can price the risk of a yield-bearing asset. If you want downside protection, hold a senior position and let junior holders absorb the first loss.
  </Accordion>

  <Accordion title="What are the main risks?" icon="question">
    Smart contract risk on every program involved, the risk of each lending market reserves are supplied to, interest rates that move with market conditions, and the risk of the collateral itself. Read the [risk framework](https://docs.reflect.money/risk) before depositing.
  </Accordion>

  <Accordion title="How is collateral chosen?" icon="question">
    Assets are reviewed before they can back anything on Reflect, scored on liquidity, issuer reliability and availability across venues. Only assets that clear the top of that scale are accepted.
  </Accordion>
</AccordionGroup>

### Building on Reflect

<AccordionGroup>
  <Accordion title="Where do I start?" icon="question">
    The [developer guide](https://docs.reflect.money/developers) covers the SDKs, the REST API, and how to point your AI tooling at the current spec.
  </Accordion>

  <Accordion title="Do my users need wallets?" icon="question">
    No. Reflect can manage accounts and keys for your users, and you can sponsor their network fees, so nothing about the experience needs to feel like crypto.
  </Accordion>

  <Accordion title="Is there a test environment?" icon="question">
    Yes. `dev.api.reflect.money` mirrors production, and some products are available there first.
  </Accordion>

  <Accordion title="How do I get an API key?" icon="question">
    Initialize your integration, then reveal your key with a signature from your integration authority. Keys can be rotated at any time. See [getting access](https://docs.reflect.money/developers).
  </Accordion>
</AccordionGroup>

<Card title="I don't see the question I wanted answered" icon="comment" href="https://x.com/reflectmoney">
  DM us [@reflectmoney](https://x.com/reflectmoney) on X.
</Card>


# Welcome to Reflect
Source: https://docs.reflect.money/introduction

The platform that makes building with stablecoins easy.

<img alt="Docs Header Image Main Pn" />

#### Introduction to [Reflect](https://reflect.money)

Reflect allows you to **earn** on *existing* industry leading stablecoins, **create** your own and tranche the risk of either with **protect**, all in a single API designed to reduce your compliance overhead and accelerate your time to market.

Reflect is purpose-built for any product that holds or moves money: neobanks, fintechs, payroll and payments tools, marketplaces, treasuries and consumer apps.

#### Go-to-market in days not months

Building this in-house means blockchain engineers, contract audits, compliance review and an independent risk methodology before any product work starts. Reflect ships with all four.

* **Blockchain integration**: wallets, keys, transactions and network fees, handled through the API.
* **Audited contracts**: already deployed and shared across every integration.
* **Independent risk methodology**: built and maintained with Blockworks Advisory.
* **Non-custodial architecture**: no discretionary control on your side. [How this reduces your compliance overhead →](https://docs.reflect.money/compliance)

#### Reflect's product(s)

Reflect is comprised of three core permissionless offerings alongside a suite of quality of life features designed to make building with stablecoins easier, faster and more intuitive.

<Card title="Earn" icon="chart-line-up" href="https://docs.reflect.money/products/earn">
  Deposit industry-leading stablecoins to receive their plus **(+)** asset, a capital-efficient <u>risk-adjusted</u> yield-bearing asset. No lockups, full transparency, entirely onchain. 
</Card>

<Card title="Protect" icon="shield-halved" href="https://docs.reflect.money/products/protect">
  Tranche any yield-bearing product into Junior and Senior markets, *amplify your interest-rate* or protect from downside.
</Card>

<Card title="Create" icon="magic-wand-sparkles" href="https://docs.reflect.money/products/create">
  Launch your own yield-bearing asset backed by *industry-leading* collateral, earn a cut in the interest through your own distribution channels. 
</Card>

#### Looking for where to head next?

*Choose any one of the following Quick Start options to get started!*

<Columns>
  <Card title="Reflect for Users" icon="user-crown" href="https://docs.reflect.money/users">
    Learn about Create, Protect, Earn and how they might work for you. 
  </Card>

  <Card title="Reflect for Developers" icon="code" href="https://docs.reflect.money/developers">
    Start Shipping: Quickstarts, API Reference and Integration Guides.
  </Card>
</Columns>

<Card title="Frequently Asked Questions (FAQs)" icon="question" href="https://docs.reflect.money/faq">
  Common questions about the reflect.money products, assets and risk model.
</Card>


# Create
Source: https://docs.reflect.money/products/create

Launch your own yield-bearing token, backed by collateral you choose, liquid from the moment it exists.

<img alt="Reflect Banner" />

#### Create

Create lets you issue a token that earns yield from the moment it is minted. Back it with any approved collateral, or a basket of several, and keep a share of the interest it generates.

<Columns>
  <Card title="A branded dollar" icon="tag">
    Your own stablecoin, carrying your name, for your app or community. Back it with a single asset, or with a basket so it is diversified across venues rather than dependent on any one of them.
  </Card>

  <Card title="An index token" icon="layer-group">
    A basket of yield-bearing assets held as a single token, for a treasury or product that would rather track one position than ten.
  </Card>
</Columns>

#### How It Works

Your token is a wrapper around yield-bearing collateral held onchain. A holder deposits, the deposit becomes your backing asset, and your token is minted against it, all in one transaction. Because the collateral earns, your token appreciates with it.

Collateral comes from a reviewed set. Every eligible asset has been through Reflect's classification process and carries an independent risk rating, and you can combine several so that no single venue or issuer determines your token's performance.

Eligibility is deliberately narrow. Only permissionless, freely transferable assets qualify. Anything carrying fixed transfer restrictions or holder eligibility requirements is excluded, so a token you issue never gives its holders exposure to something they could not have held directly.

Launching runs through a single transaction. `POST /integration/initialize/flow` creates the mint, attaches your metadata, hands mint authority to the program so it can issue against deposits, and registers the integration. Upload your image and metadata first with `POST /integration/upload`, which returns the URLs the flow expects.

#### Liquid At Launch

Reflect's issuance program is integrated directly into the [Titan](https://titan.exchange) and [Jupiter](https://jup.ag) routers, so your token is swappable the moment it exists. Issue and redeem happen natively inside a route, which means no pools to seed, no market makers to hire and no liquidity incentives to fund.

Bootstrapping liquidity is normally the hardest and most expensive part of launching a token. Here it is solved before you write any code.

#### Your Economics

You set how the interest splits between you and your holders. Your share accrues continuously and you claim it whenever you like.

As an illustration, if your collateral earns 5% and you keep a fifth of the interest, holders see 4% and your share works out at \$100,000 a year for every \$10M outstanding. Rates move with the underlying, so these are not projections. Balances that previously sat idle become a revenue line, scaling with deposits held rather than transactions processed.

#### For Your Holders

* **Instant mint and redemption,** settled atomically against the collateral. No queue, no cooldown, no notice period.
* **No wallets, no gas.** Token accounts are created on first mint, and you can sponsor network fees so nothing about the experience feels like crypto.
* **Free swaps between Reflect assets** up to several thousand dollars per transaction, which makes a branded dollar spendable rather than only holdable.

#### Risks

* **Your token inherits its collateral's risk,** including the venues behind it. A basket reduces concentration, but correlated collateral diversifies less than it appears to.
* **Yield is not fixed.** Holders' rates move with the collateral. Promise them a number and you absorb the difference.
* **You face your users.** Reflect custodies nothing, but your name is on the token, so disclosure of what backs it sits with you.
* **Protection is optional.** For conservative exposure, back your token with senior positions from [Protect](https://docs.reflect.money/protect) rather than raw assets.

#### Next

<Columns>
  <Card title="Whitelabel SDK" icon="code" href="https://docs.reflect.money/api-reference/proxy">
    Create a proxy, mint, redeem and claim in TypeScript.
  </Card>

  <Card title="Integration API" icon="server" href="https://docs.reflect.money/reflect-api/integration/initialize-integration-flow-complete-setup">
    Launch, configure, quote, mint, redeem and read statistics over HTTP.
  </Card>
</Columns>


# Earn
Source: https://docs.reflect.money/products/earn

Yield routing that turns the stablecoins you already hold into assets that earn.

<img alt="Reflect Banner" />

#### Earn

Earn is Reflect's yield routing layer. Deposit a stablecoin you already hold and receive its plus asset, which appreciates as its reserves earn interest across Solana's lending markets.

There is no fund, no manager and no mandate. Allocation follows a published methodology built with [Blockworks Advisory](https://www.blockworksresearch.com/advisory), executed by onchain programs, and you can redeem at any time.

<Columns>
  <Card title="USDC+" icon="dollar-sign" href="https://docs.reflect.money/strategies/USDC">
    Circle USDC, supplied across Solana's largest lending markets.
  </Card>

  <Card title="USDT+" icon="dollar-sign" href="https://docs.reflect.money/strategies/USDT">
    Tether USDT, supplied into the deepest available liquidity.
  </Card>
</Columns>

#### How Earn Works

<Steps>
  <Step title="You deposit" icon="arrow-right-to-bracket">
    Send USDC or USDT to the Earn program. Funds are held onchain, not by Reflect, and no person can withdraw or redirect them.
  </Step>

  <Step title="Reserves are supplied to lending markets" icon="building-columns">
    The program distributes reserves across supported markets according to the published methodology, targeting the best rate available at an acceptable level of risk rather than the highest headline number.
  </Step>

  <Step title="You hold a plus asset" icon="coins">
    You receive USDC+ or USDT+, representing your share of the reserve pool. One plus asset is worth slightly more than one of the underlying stablecoin, and that difference grows as interest accrues.
  </Step>

  <Step title="You redeem whenever you want" icon="arrow-right-from-bracket">
    Redemption is instant and atomic, back into the stablecoin you started with. No lockups, no notice period, no queue.
  </Step>
</Steps>

#### Where The Yield Comes From

Earn supplies reserves to overcollateralised lending markets on Solana. Borrowers post collateral worth more than they borrow, and pay interest for access to liquidity. That interest is the yield, and it is paid by borrowers rather than manufactured by a token incentive or a promise.

Reserves are currently supplied across venues including [Kamino](https://kamino.com) and [Jupiter Lend](https://jup.ag/lend/earn). Supplying to several markets at once, rather than one, keeps any single venue from dominating the position and lets the program move toward better rates as they appear.

Every venue holding reserves is visible onchain, and the live allocation is queryable at any time.

#### How Allocation Is Decided

The difference between a yield aggregator and a yield router is whether anyone is exercising judgement in the moment. Earn is a router.

Allocation follows a risk-adjusted methodology built with Blockworks Advisory, an independent research firm, and published in full. It is not an in-house view of which market looks good this week.

* **Assets are classified before they can hold reserves.** Each is scored on liquidity depth, issuer reliability and how widely it trades across venues. Only assets at the top of that scale are eligible.
* **Strategies are stress-tested separately from their code.** Economic security audits simulate and backtest each strategy under extreme conditions, so a strategy is judged on how it behaves in a crisis rather than in calm markets.
* **Code is audited and public.** Reviews by Offside Labs and Adevar Labs cover Reflect Core, yield routing and the whitelabel program, with every report in the [audits repository](https://github.com/palindrome-eng/audits).

The result is a rate that reflects what the market will actually pay for liquidity at a defensible level of risk, rather than the highest number available on any given day.

#### What You Actually Hold

* **Interest accrues in the price.** Your token count never changes. Each plus asset simply becomes worth more, so there is nothing to claim and nothing to compound manually.
* **Rates are shown in real time.** Reflect publishes the rate derived from interest generated second by second, not a trailing average that can flatter a rate which has already moved.
* **Capacity is capped and visible.** Each plus asset has a supply cap. Current supply and remaining capacity are published live.

#### Risks

A plus asset is not the same thing as the stablecoin it wraps, and it should not be treated as though it were.

* **Multi-venue smart contract risk.** Reserves sit in several lending markets, each with its own code, audit history and track record. That exposure compounds rather than diversifies away.
* **Liquidity under stress.** Withdrawal capacity depends on utilisation across venues. In stressed markets, redemption may be slower or more expensive than in normal conditions.
* **Rate volatility.** Lending rates move with borrower demand. A rate quoted today is not a rate promised tomorrow.
* **Collateral and issuer risk.** Earn inherits the risk of the underlying stablecoin and of the assets borrowers post against it.

Deposits are not insured. If you want downside protection, [Protect](https://docs.reflect.money/products/protect) lets you hold a senior position in a plus asset, where junior holders absorb losses first in exchange for a share of your interest.

Anyone building on Earn should treat a plus asset as a higher-risk asset than the stablecoin it wraps, and disclose that to their own users.

#### Data and Transparency

Every number behind Earn is queryable, whether or not you integrate it.

<Columns>
  <Card title="Rates and exchange rates" icon="percent" href="https://docs.reflect.money/reflect-api/stablecoin/get-apy-for-all-stablecoins">
    Live and historical APY, plus current and historical exchange rates per asset.
  </Card>

  <Card title="Supply and capacity" icon="gauge" href="https://docs.reflect.money/reflect-api/stablecoin/get-supply-cap-information-for-all-stablecoins">
    Supply caps, current supply and remaining capacity for every plus asset.
  </Card>

  <Card title="Protocol statistics" icon="chart-mixed" href="https://docs.reflect.money/reflect-api/stats/get-protocol-statistics">
    TVL and volume across all assets, current and historical.
  </Card>

  <Card title="Events" icon="list-timeline" href="https://docs.reflect.money/reflect-api/events/get-recent-events">
    Every mint, redemption and allocation action, by asset or by signer.
  </Card>
</Columns>

#### Next

<Columns>
  <Card title="USDC+" icon="dollar-sign" href="https://docs.reflect.money/strategies/USDC">
    The full strategy, venues and risk profile for USDC+.
  </Card>

  <Card title="Build with Earn" icon="code" href="https://docs.reflect.money/developers">
    Mint, redeem and read rates through the SDK or REST API.
  </Card>
</Columns>


# Protect
Source: https://docs.reflect.money/products/protect

Tranche markets that split any yield-bearing asset into protected senior and amplified junior exposure.

<img alt="Reflect Banner" />

#### Protect

Protect splits a yield-bearing asset into two tokens. Senior gives up a share of its interest and is insulated from the first losses. Junior collects that share on top of its own yield, and absorbs those losses in exchange.

A market on USDC produces `srUSDC` and `jrUSDC`, both transferable and usable anywhere on Solana. Structured finance has allocated risk this way for decades. Here the waterfall is enforced by a program rather than an indenture, and the price of protection is set by an open market rather than an insurance fund.

<Columns>
  <Card title="Senior" icon="lock">
    **Keeps most of the yield. Last to lose.**

    Passes a set share of its interest to junior in return for a cushion beneath it. Redeems on demand.

    Built for treasuries, neobanks and fintechs that need conservative exposure to a strategy they could not otherwise hold.
  </Card>

  <Card title="Junior" icon="chart-mixed">
    **Amplified rate. First to lose.**

    Earns its own yield plus senior's share, landing on a smaller base. Absorbs every dollar of loss until exhausted.

    Redemptions run on a cooldown and deposits are capped, so junior cannot exit ahead of a loss it was paid to absorb.
  </Card>
</Columns>

#### How The Split Works

A market holds **10M senior** and **2M junior**, both deployed in the same underlying strategy. Senior passes **20%** of its interest to junior. The strategy earns **5%**.

* Senior's capital earns \$500,000. Junior's capital earns \$100,000.
* Senior passes \$100,000 across and keeps \$400,000, a rate of **4%**.
* Junior collects \$200,000 on \$2M of capital, a rate of **10%**.

Now the underlying loses value. Junior's capital is the cushion, so losses come out of it first.

* **Pool down 10%**, or \$1.2M. Junior absorbs all of it and falls from \$2M to \$800,000, a **60% loss** on junior's capital. Senior is untouched.
* **Pool down 16.7%**, or \$2M. Junior is exactly wiped out. Senior is still untouched.
* **Pool down 20%**, or \$2.4M. Junior is gone, and the remaining \$400,000 reaches senior. Senior loses **4%** rather than 20%.

Senior gave up one point of yield and turned a 20% loss into a 4% one. Junior earned double the underlying rate and stood in front of the first 16.7% of losses to make that possible.

Note the asymmetry. Junior earns 2x the underlying rate here, but absorbs the whole pool's losses on one sixth of the capital, which is 6x the loss exposure. Junior is leveraged in both directions and not by the same multiple.

#### Coverage Ratio

Junior capital measured against senior capital, published live in basis points. In the example above, \$2M against \$10M is 20%.

The ratio sets senior's protection and junior's amplification at the same time. Holding the share at 20%:

* **10% coverage.** Junior earns roughly 3x the underlying rate, and is wiped out by a 9% fall in the pool.
* **20% coverage.** Junior earns roughly 2x, and is wiped out by a 17% fall.
* **40% coverage.** Junior earns roughly 1.5x, and is wiped out by a 29% fall.

Senior begins to lose only at the point junior is exhausted, so those same figures are the depth of senior's cushion.

Note that a coverage ratio is not a protection threshold. Junior holds the same asset it protects, so when that asset falls, junior's cushion is marked down alongside it. \$2M of junior capital cannot absorb a full \$2M of senior loss, which is why 20% coverage protects senior against a fall of 16.7% rather than 20%.

So scarce junior capital commands a higher rate until enough of it arrives. Abundant junior capital compresses its own rate and deepens senior's cushion. Nobody sets the price of protection.

#### What Can Be Tranched

Any yield-bearing asset that has cleared review: Reflect plus assets from [Earn](https://docs.reflect.money/products/earn), institutional credit, regulated T-bill products, onchain savings rates, and delta-neutral basis strategies.

Senior positions can also be used as collateral in [Create](https://docs.reflect.money/products/create), so an issuer can build an index made entirely of protected exposure.

#### Risks

* **Senior's rate is not fixed.** Senior receives a share of the underlying rate, so if the strategy's yield falls, senior's falls with it. Senior buys a cushion against loss, not certainty about return.
* **Senior is protected, not guaranteed.** Protection extends only as far as the junior tranche beneath it. A larger loss reaches senior directly.
* **Junior can lose everything.** It is designed to be exhausted before senior loses a dollar. Treat the whole position as at risk.
* **Underlying risk passes straight through,** including smart contract, venue, liquidity and collateral risk. Coverage also thins as junior capital leaves.

#### Next

<Columns>
  <Card title="Market data" icon="list" href="https://docs.reflect.money/reflect-api/tranches/list-all-tranches">
    Live markets, coverage ratios, rates, caps and cooldowns.
  </Card>

  <Card title="Build with Protect" icon="code" href="https://docs.reflect.money/developers">
    Deposit, redeem and read market state through the API.
  </Card>
</Columns>


# Get events by signer
Source: https://docs.reflect.money/reflect-api/events/get-events-by-signer

/api-reference/openapi.json get /events/{signer}
Retrieve protocol events associated with a signer address.



# Get recent events
Source: https://docs.reflect.money/reflect-api/events/get-recent-events

/api-reference/openapi.json get /events/all/{limit}
Retrieve the most recent protocol events up to a limit.



# Health check
Source: https://docs.reflect.money/reflect-api/health/health-check

/api-reference/openapi.json get /health
Check if the is operational and healthy.



# Check integration verification status
Source: https://docs.reflect.money/reflect-api/integration/check-integration-verification-status

/api-reference/openapi.json get /integration/check/{stablecoin}
Check whether a specific integration is verified by its branded stablecoin mint address. Returns a boolean indicating the verification status.



# Generate claim transaction
Source: https://docs.reflect.money/reflect-api/integration/generate-claim-transaction

/api-reference/openapi.json post /integration/claim
Generate a claim transaction for integration rewards. Claims all available rewards for the integration.



# Generate mint transaction
Source: https://docs.reflect.money/reflect-api/integration/generate-mint-transaction

/api-reference/openapi.json post /integration/mint
Generate a mint transaction for integration stablecoins. This endpoint automatically detects if the recipient's branded token account needs to be initialized and includes the initialization instruction in the transaction if required. Developers can pay for account initialization on behalf of users by setting the `feePayer` parameter to their own address - the feePayer will cover both transaction fees and account initialization costs.



# Generate redemption transaction
Source: https://docs.reflect.money/reflect-api/integration/generate-redemption-transaction

/api-reference/openapi.json post /integration/redeem
Generate a redemption transaction for integration stablecoins



# Get current exchange rate
Source: https://docs.reflect.money/reflect-api/integration/get-current-exchange-rate

/api-reference/openapi.json get /integration/{id}/exchange-rate
Retrieve current exchange rate for a specific integration



# Get historical integration statistics
Source: https://docs.reflect.money/reflect-api/integration/get-historical-integration-statistics

/api-reference/openapi.json get /integration/{id}/stats/historical
Retrieve historical statistics for a specific integration. Use the `period` query parameter to specify the number of days (e.g., '7' for 7 days, '30' for 30 days). Defaults to 7 days if not provided.



# Get integration configuration
Source: https://docs.reflect.money/reflect-api/integration/get-integration-configuration

/api-reference/openapi.json get /integration/{id}/config
Retrieve configuration for a specific integration



# Get integration events
Source: https://docs.reflect.money/reflect-api/integration/get-integration-events

/api-reference/openapi.json get /integration/{id}/events
Retrieve recent events for a specific integration.



# Get integration statistics
Source: https://docs.reflect.money/reflect-api/integration/get-integration-statistics

/api-reference/openapi.json get /integration/{id}/stats
Retrieve statistics for a specific integration



# Get integrations by authority
Source: https://docs.reflect.money/reflect-api/integration/get-integrations-by-authority

/api-reference/openapi.json get /integration/{authority}/integrations
Retrieve all integrations associated with a specific authority address



# Get quote for mint or redeem
Source: https://docs.reflect.money/reflect-api/integration/get-quote-for-mint-or-redeem

/api-reference/openapi.json post /integration/quote/{type}
Get a quote for minting (wrapping USDC+ into branded tokens) or redeeming (unwrapping branded tokens back to USDC+) for a specific integration.



# Get quote for mint or redeem with USDC input/output
Source: https://docs.reflect.money/reflect-api/integration/get-quote-for-mint-or-redeem-with-usdc-inputoutput

/api-reference/openapi.json post /integration/quote/flow/{type}
Get a quote for the full flow: USDC → USDC+ → branded tokens (mint) or branded tokens → USDC+ → USDC (redeem). This endpoint handles both the stablecoin conversion and the integration wrap/unwrap in a single quote.



# Get verified integrations
Source: https://docs.reflect.money/reflect-api/integration/get-verified-integrations

/api-reference/openapi.json get /integration/verified
Retrieve a list of all verified integrations with their statistics, metadata, and configuration. This endpoint returns public information about integrations that have been verified by the Reflect team.



# Initialize a stablecoin token
Source: https://docs.reflect.money/reflect-api/integration/initialize-a-stablecoin-token

/api-reference/openapi.json post /integration/initialize-stablecoin
Generate a transaction to create a new branded token mint with metadata.



# Initialize an integration
Source: https://docs.reflect.money/reflect-api/integration/initialize-an-integration

/api-reference/openapi.json post /integration/initialize
Initialize a new integration with branded mint and fee configuration.



# Initialize integration flow (complete setup)
Source: https://docs.reflect.money/reflect-api/integration/initialize-integration-flow-complete-setup

/api-reference/openapi.json post /integration/initialize/flow
A complete initialization flow that combines creating a branded mint, adding metadata, transferring authority, and initializing the integration in a single transaction. This is a wrapper around all initialization endpoints.



# Initialize integration vault
Source: https://docs.reflect.money/reflect-api/integration/initialize-integration-vault

/api-reference/openapi.json post /integration/initialize-vault
Initialize the proxy vault for an integration (admin-only).



# Initialize user branded token account
Source: https://docs.reflect.money/reflect-api/integration/initialize-user-branded-token-account

/api-reference/openapi.json post /integration/initialize-user-account
Generate a transaction to initialize a user's branded token account. This endpoint allows developers to pay for account initialization on behalf of users by setting the `signer` parameter to their own address - the signer will pay for the account initialization costs, while `feePayer` covers transaction fees. Note: The `/integration/mint` endpoint automatically handles account initialization, so this endpoint is typically only needed if you want to initialize accounts separately from minting.



# Mint stablecoin and whitelabel in single transaction
Source: https://docs.reflect.money/reflect-api/integration/mint-stablecoin-and-whitelabel-in-single-transaction

/api-reference/openapi.json post /integration/flow/mint
Generate a combined transaction that mints the underlying stablecoin and then whitelabels it in a single call. This combines the functionality of /stablecoin/mint and /integration/mint.



# Redeem whitelabeled stablecoin in single transaction
Source: https://docs.reflect.money/reflect-api/integration/redeem-whitelabeled-stablecoin-in-single-transaction

/api-reference/openapi.json post /integration/flow/redeem
Generate a combined transaction that redeems the whitelabeled stablecoin and burns the underlying stablecoin in a single call. This combines the functionality of /integration/redeem and /stablecoin/burn.



# Reveal API key
Source: https://docs.reflect.money/reflect-api/integration/reveal-api-key

/api-reference/openapi.json post /integration/api-key/reveal
Reveal the API key for an integration. Requires a signature from the integration authority to prove ownership. The message to sign should be: 'Reveal API key for integration {integrationId} at timestamp {timestamp}'. **Important**: The signature is only valid for 1 minute from the timestamp. The timestamp must be within 1 minute of the current server time.



# Rotate API key
Source: https://docs.reflect.money/reflect-api/integration/rotate-api-key

/api-reference/openapi.json post /integration/api-key/rotate
Rotate (generate a new) API key for an integration. Requires a signature from the integration authority to prove ownership. The message to sign should be: 'Rotate API key for integration {integrationId} at timestamp {timestamp}'. The old API key will be invalidated. **Important**: The signature is only valid for 1 minute from the timestamp. The timestamp must be within 1 minute of the current server time.



# Transfer mint authority
Source: https://docs.reflect.money/reflect-api/integration/transfer-mint-authority

/api-reference/openapi.json post /integration/transfer-authority
Generate a transaction to transfer mint authority of a branded token.



# Update integration configuration
Source: https://docs.reflect.money/reflect-api/integration/update-integration-configuration

/api-reference/openapi.json post /integration/{id}/config/update
Generate a transaction to update the fee configuration for a specific integration



# Upload integration metadata
Source: https://docs.reflect.money/reflect-api/integration/upload-integration-metadata

/api-reference/openapi.json post /integration/upload
Upload image and metadata for a branded mint. Returns URLs for the uploaded image and JSON metadata file that can be used when initializing integrations.



# Whitelist integration users
Source: https://docs.reflect.money/reflect-api/integration/whitelist-integration-users

/api-reference/openapi.json post /integration/whitelist
Reflect is currently in closed beta and requires whitelisting users. To whitelist your users as integrator, generate and submit transaction returned from this endpoint.



# Generate burn transaction
Source: https://docs.reflect.money/reflect-api/stablecoin/generate-burn-transaction

/api-reference/openapi.json post /stablecoin/burn
Generate a burn transaction for stablecoins using the Reflect SDK



# Generate mint transaction
Source: https://docs.reflect.money/reflect-api/stablecoin/generate-mint-transaction

/api-reference/openapi.json post /stablecoin/mint
Generate a mint transaction for stablecoins using the Reflect SDK.



# Get APY for all stablecoins
Source: https://docs.reflect.money/reflect-api/stablecoin/get-apy-for-all-stablecoins

/api-reference/openapi.json get /stablecoin/apy
Retrieve realtime APY data for all available stablecoins.



# Get APY for specific stablecoin
Source: https://docs.reflect.money/reflect-api/stablecoin/get-apy-for-specific-stablecoin

/api-reference/openapi.json get /stablecoin/{index}/apy
Retrieve APY data for a specific stablecoin (realtime data).



# Get available stablecoin types
Source: https://docs.reflect.money/reflect-api/stablecoin/get-available-stablecoin-types

/api-reference/openapi.json get /stablecoin/types
Retrieve list of available stablecoin types



# Get historical APY data for specific stablecoin
Source: https://docs.reflect.money/reflect-api/stablecoin/get-historical-apy-data-for-specific-stablecoin

/api-reference/openapi.json get /stablecoin/{index}/apy/historical
Retrieve historical APY data for a specific stablecoin over a specified number of days.



# Get historical exchange rates for a stablecoin
Source: https://docs.reflect.money/reflect-api/stablecoin/get-historical-exchange-rates-for-a-stablecoin

/api-reference/openapi.json get /stablecoin/exchange-rates/historical
Retrieve historical base and receipt exchange rates for a specific stablecoin (0: USDC+) and a number of days.



# Get latest exchange rates for all stablecoins
Source: https://docs.reflect.money/reflect-api/stablecoin/get-latest-exchange-rates-for-all-stablecoins

/api-reference/openapi.json get /stablecoin/exchange-rates
Retrieve the latest base and receipt exchange rates for all supported stablecoins (USDC+).



# Get quote for mint or redeem
Source: https://docs.reflect.money/reflect-api/stablecoin/get-quote-for-mint-or-redeem

/api-reference/openapi.json post /stablecoin/quote/{type}
Get a quote for minting or redeeming stablecoins



# Get realtime exchange rate for a stablecoin
Source: https://docs.reflect.money/reflect-api/stablecoin/get-realtime-exchange-rate-for-a-stablecoin

/api-reference/openapi.json get /stablecoin/{index}/exchange-rate
Retrieve the current exchange rate for the specified stablecoin.



# Get supply cap information for all stablecoins
Source: https://docs.reflect.money/reflect-api/stablecoin/get-supply-cap-information-for-all-stablecoins

/api-reference/openapi.json get /stablecoin/limits
Retrieve supply caps, current supply, and remaining capacity for all stablecoins



# Get global protocol statistics
Source: https://docs.reflect.money/reflect-api/stats/get-global-protocol-statistics

/api-reference/openapi.json get /stats/global
Retrieve overall protocol statistics including TVL breakdown by stablecoin. Alias for /stats.



# Get historical protocol statistics
Source: https://docs.reflect.money/reflect-api/stats/get-historical-protocol-statistics

/api-reference/openapi.json get /stats/historical
Retrieve historical TVL and volume data across all stablecoins for a given number of days.



# Get historical statistics for a specific stablecoin
Source: https://docs.reflect.money/reflect-api/stats/get-historical-statistics-for-a-specific-stablecoin

/api-reference/openapi.json get /stats/historical/{index}
Retrieve historical TVL and volume data for a specific stablecoin by index.



# Get protocol statistics
Source: https://docs.reflect.money/reflect-api/stats/get-protocol-statistics

/api-reference/openapi.json get /stats
Retrieve overall protocol statistics



# Get statistics for a specific stablecoin
Source: https://docs.reflect.money/reflect-api/stats/get-statistics-for-a-specific-stablecoin

/api-reference/openapi.json get /stats/{index}
Retrieve protocol statistics for a specific stablecoin by index.



# Execute junior tranche redemption
Source: https://docs.reflect.money/reflect-api/tranches--junior/execute-junior-tranche-redemption

/api-reference/openapi.json post /tranches/junior/redeem
**Available on development API only.**

Generate a transaction to execute a pending redemption after the cooldown period has elapsed.



# Generate junior tranche mint transaction
Source: https://docs.reflect.money/reflect-api/tranches--junior/generate-junior-tranche-mint-transaction

/api-reference/openapi.json post /tranches/junior/mint
**Available on development API only.**

Generate a transaction to deposit the underlying asset into a junior tranche and receive junior tranche tokens in return.



# Get historical junior tranche statistics
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-historical-junior-tranche-statistics

/api-reference/openapi.json get /tranches/junior/{id}/stats/historical
**Available on development API only.**

Retrieve time-bucketed historical statistics for a junior tranche. Returns hourly data for periods ≤ 7 days, daily data otherwise.



# Get junior tranche configuration
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-junior-tranche-configuration

/api-reference/openapi.json get /tranches/junior/{id}/config
**Available on development API only.**

Retrieve the on-chain configuration for a junior tranche, including the tranche token, cooldown duration, deposit cap, and asset composition.



# Get junior tranche deposit/withdraw quote
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-junior-tranche-depositwithdraw-quote

/api-reference/openapi.json post /tranches/junior/quote/{type}
**Available on development API only.**

Simulate a deposit or withdrawal for a junior tranche to get the expected output amount before generating a transaction.



# Get junior tranche events
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-junior-tranche-events

/api-reference/openapi.json get /tranches/junior/{id}/events
**Available on development API only.**

Retrieve deposit and withdrawal events for a junior tranche, optionally filtered by signer address, time period, and limit.



# Get junior tranche exchange rate
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-junior-tranche-exchange-rate

/api-reference/openapi.json get /tranches/junior/{id}/exchange-rate
**Available on development API only.**

Retrieve the current exchange rate for a junior tranche token. Returns the rate to USD and the per-asset redemption amounts.



# Get junior tranche statistics
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-junior-tranche-statistics

/api-reference/openapi.json get /tranches/junior/{id}/stats
**Available on development API only.**

Retrieve the latest statistics for a junior tranche including total supply, TVL, holder count, exchange rates, and coverage ratio.



# Get junior tranche withdrawal cooldowns
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-junior-tranche-withdrawal-cooldowns

/api-reference/openapi.json get /tranches/junior/{id}/cooldowns
**Available on development API only.**

Retrieve active withdrawal cooldowns for a junior tranche, optionally filtered by user address.



# Get tranche coverage ratio
Source: https://docs.reflect.money/reflect-api/tranches--junior/get-tranche-coverage-ratio

/api-reference/openapi.json get /tranches/junior/{id}/coverage-ratio
**Available on development API only.**

Retrieve the coverage ratio between junior and senior tranche TVL for the underlying asset. Returns both TVL values and the ratio in basis points.



# Request junior tranche redemption
Source: https://docs.reflect.money/reflect-api/tranches--junior/request-junior-tranche-redemption

/api-reference/openapi.json post /tranches/junior/request-redeem
**Available on development API only.**

Generate a transaction to initiate a redemption from a junior tranche. This starts a cooldown period after which the redemption can be executed.



# Generate senior tranche deposit transaction
Source: https://docs.reflect.money/reflect-api/tranches--senior/generate-senior-tranche-deposit-transaction

/api-reference/openapi.json post /tranches/senior/mint
**Available on development API only.**

Generate a transaction to deposit the underlying stablecoin into a senior tranche and receive senior tranche tokens in return.



# Generate senior tranche withdrawal transaction
Source: https://docs.reflect.money/reflect-api/tranches--senior/generate-senior-tranche-withdrawal-transaction

/api-reference/openapi.json post /tranches/senior/redeem
**Available on development API only.**

Generate a transaction to redeem senior tranche tokens and receive the underlying stablecoin back.



# Get historical senior tranche statistics
Source: https://docs.reflect.money/reflect-api/tranches--senior/get-historical-senior-tranche-statistics

/api-reference/openapi.json get /tranches/senior/{id}/stats/historical
**Available on development API only.**

Retrieve time-bucketed historical statistics for a senior tranche. Returns hourly data for periods ≤ 7 days, daily data otherwise.



# Get senior tranche configuration
Source: https://docs.reflect.money/reflect-api/tranches--senior/get-senior-tranche-configuration

/api-reference/openapi.json get /tranches/senior/{id}/config
**Available on development API only.**

Retrieve the on-chain configuration for a senior tranche, including the underlying stablecoin, branded token mint, fee structure, and authority.



# Get senior tranche deposit/redeem quote
Source: https://docs.reflect.money/reflect-api/tranches--senior/get-senior-tranche-depositredeem-quote

/api-reference/openapi.json post /tranches/senior/quote/{type}
**Available on development API only.**

Simulate a deposit (mint) or withdrawal (redeem) for a senior tranche to get the expected output amount before generating a transaction.



# Get senior tranche events
Source: https://docs.reflect.money/reflect-api/tranches--senior/get-senior-tranche-events

/api-reference/openapi.json get /tranches/senior/{id}/events
**Available on development API only.**

Retrieve deposit and withdrawal events for a senior tranche, optionally filtered by signer address, time period, and limit.



# Get senior tranche exchange rate
Source: https://docs.reflect.money/reflect-api/tranches--senior/get-senior-tranche-exchange-rate

/api-reference/openapi.json get /tranches/senior/{id}/exchange-rate
**Available on development API only.**

Retrieve the current exchange rate for a senior tranche token. Returns the rate to the underlying stablecoin and to USDC.



# Get senior tranche statistics
Source: https://docs.reflect.money/reflect-api/tranches--senior/get-senior-tranche-statistics

/api-reference/openapi.json get /tranches/senior/{id}/stats
**Available on development API only.**

Retrieve the latest statistics for a senior tranche including total supply, principal deposited, yield generated, holder count, and exchange rates.



# List all tranches
Source: https://docs.reflect.money/reflect-api/tranches/list-all-tranches

/api-reference/openapi.json get /tranches/all
**Available on development API only.**

Returns all registered tranches with their senior and junior tranche addresses and underlying asset.



# Risk
Source: https://docs.reflect.money/risk

What can go wrong, what reduces it, and what you can do about what remains.

<img alt="Reflect Banner" />

#### Risk

Every product that pays interest carries risk, because the interest exists for a reason: something underneath is exposed. What that something is depends on which product you use, and who absorbs a loss depends on how you hold it.

#### What You Are Exposed To

<Card title="Earn" icon="chart-line-up">
  The money behind your balance is lent to borrowers who put up more collateral than they take out, across several lending markets, and they pay for the use of it.

  You are exposed to those markets and to the stablecoin underneath. A balance that earns is not the same thing as a dollar sitting still.
</Card>

<Card title="Create" icon="tag">
  Your token is exposed to whatever you chose to back it with, and to how you combined those assets. A basket of lending vaults behaves nothing like a basket of tokenised treasuries.

  Composition is your decision, and your holders will look to you rather than to Reflect.
</Card>

<Card title="Protect" icon="shield-halved">
  Both sides are exposed to the same underlying asset. What the split changes is the order of loss: junior absorbs everything until it is exhausted, and only then does senior begin to.

  Junior can lose its entire position, and cannot exit during its cooldown. Senior is covered only as deep as the junior tranche beneath it, and that depth moves as capital enters and leaves.
</Card>

#### Who Absorbs A Loss

Not Reflect. A bank can offer cover because it holds your money and is licensed and capitalised to stand behind it, and Reflect holds neither your money nor that obligation.

Cover is still available, just bought rather than bundled in. [Protect](https://docs.reflect.money/products/protect) lets other capital agree to take the first loss on your behalf, at a price set by how much of it is competing for the job.

#### Risks That Apply Whatever You Use

Each one below sets out **what it is**, **what Reflect does about it**, and **what you can do** about the part that remains.

<AccordionGroup>
  <Accordion title="Smart contract risk" icon="file-code">
    **What it is.** Deposits are held by code. Code can contain flaws, and code holding money is a target.

    **What Reflect does.** Every program is audited before it holds deposits, by Offside Labs and Adevar Labs, covering Reflect Core, yield routing and the whitelabel program. Reports are published in full rather than summarised, in the [audits repository](https://github.com/palindrome-eng/audits).

    **What you can do.** Read the reports for the products you intend to use. Size any position to an amount you would accept losing.
  </Accordion>

  <Accordion title="Lending venue risk" icon="building-columns">
    **What it is.** Wherever money is lent, it sits in a lending market with its own code, history and operators. That applies to Earn directly, and to any token created against lending-backed collateral. Spreading across several markets reduces dependence on any one, but the exposures add up rather than cancel out.

    **What Reflect does.** Only reviewed venues are eligible to hold reserves, and the published methodology sets how much can sit in any one of them.

    **What you can do.** Current allocation is queryable at any time, so you can see which venues hold your reserves. If you want a buffer against venue losses, [Protect](https://docs.reflect.money/protect) lets you hold a senior position instead.
  </Accordion>

  <Accordion title="Liquidity and redemption risk" icon="droplet">
    **What it is.** Redeeming depends on withdrawal capacity at the venues holding reserves. Under stress, that capacity can tighten, making exit slower or more expensive than it is in calm markets.

    **What Reflect does.** Allocation weighs liquidity depth rather than rate alone, and each asset carries a supply cap that limits size relative to the capacity behind it.

    **What you can do.** Caps, current supply and remaining capacity are published live. Do not assume that an exit which is instant at small size is instant at large size during a crisis.
  </Accordion>

  <Accordion title="Interest rate risk" icon="percent">
    **What it is.** Rates move with borrower demand. A rate today is not a rate tomorrow, and it can fall a long way.

    **What Reflect does.** Published rates are real time, derived from interest actually being generated, rather than trailing averages that can flatter a rate which has already moved.

    **What you can do.** If you have quoted a fixed rate to your own users, you are absorbing the difference. A senior position in Protect trades some rate for a buffer, which suits products that need to be conservative.
  </Accordion>

  <Accordion title="Collateral and issuer risk" icon="sack-dollar">
    **What it is.** Every position inherits the risk of what backs it. A dollar depends on the company issuing it. A tokenised treasury depends on its issuer and their custodian.

    **What Reflect does.** Assets are reviewed before they can back anything, scored on liquidity depth, issuer reliability and how widely they trade across venues, over a review process rather than a checklist. Only permissionless, freely transferable assets are eligible, so nothing carrying transfer restrictions or holder eligibility requirements enters the system.

    **What you can do.** Know what backs your position and who issues it. Those details are published per asset.
  </Accordion>

  <Accordion title="Correlation risk" icon="diagram-project">
    **What it is.** A basket can look diversified and still fail as one piece. Two strategies that look unrelated in calm markets can break on the same day for the same reason, which is the failure mode that has broken structured products before.

    **What Reflect does.** Economic security audits test how a strategy behaves under stress and in extreme scenarios, not only under normal conditions. Classification considers how an asset trades when liquidity thins.

    **What you can do.** If you have built a basket, check whether its components share a dependency: the same venue, the same custodian, the same liquidity source. Diversification across names is not diversification across causes.
  </Accordion>

  <Accordion title="Pricing and oracle risk" icon="tower-broadcast">
    **What it is.** Token values depend on a price feed reporting the underlying exchange rate. A stale or incorrect price affects issuance, redemption and tranche accounting.

    **What Reflect does.** Reflect uses Doppler, an oracle designed for very low cost per update, so rates are refreshed frequently rather than occasionally. Feeds are onchain and readable by anyone.

    **What you can do.** Published rates and exchange rates are queryable. Treat an unusual divergence between a token and its backing as a reason to pause rather than to trade.
  </Accordion>
</AccordionGroup>

#### Regulatory Risk

The rules covering these products are unsettled. The CLARITY Act is not law, related rulemaking is still in progress, and treatment varies by jurisdiction. Changes could affect how products like these are offered, to whom, or on what terms.

Reflect's architecture is built to adapt rather than to bet on one outcome, which is covered in [Compliance](https://docs.reflect.money/compliance). That reduces exposure to a rule change. It does not remove it.

#### What Reduces These Risks

Three reviews happen before an asset or strategy is eligible to hold anything.

* **Asset classification.** Scoring on liquidity, issuer reliability and availability across venues. Assets that do not clear the threshold are not eligible, and requests to classify assets on behalf of others are not accepted.
* **Economic security audits.** Independent simulation and backtesting of a strategy, including extreme scenarios, carried out by third parties who specialise in financial rather than code review.
* **Code security audits.** Independent review of every program by Offside Labs and Adevar Labs, with all reports public.

After you are exposed, loss absorption works through markets rather than a fund. Reflect operates no insurance pool. Instead, [Protect](https://docs.reflect.money/protect) lets any yield-bearing asset be split so that capital which wants the risk absorbs losses first, and capital which does not gets a buffer priced by how much of the former turns up. Risk is priced continuously by people choosing to take it, rather than estimated once by whoever sized a fund.

#### Next

<Columns>
  <Card title="Audits" icon="file-shield" href="https://docs.reflect.money/audits">
    Every code and economic audit report in full.
  </Card>

  <Card title="Compliance" icon="scale-balanced" href="https://docs.reflect.money/compliance">
    How the architecture affects your regulatory position.
  </Card>
</Columns>

***

*This page describes risks as they are understood today and is not exhaustive. It is not financial, investment or legal advice. Onchain finance and self-custody carry risks beyond those listed here, and you should form your own view, with professional advice where appropriate, before depositing anything.*


# For Users
Source: https://docs.reflect.money/users

Earn on the stablecoins you already hold, issue your own assets, and choose how much risk sits behind either.

<img alt="Reflect Banner" />

#### Reflect for Users

Reflect gives you three things you can use directly: interest on stablecoins you already hold, markets that let you raise or lower the risk behind any yield-bearing asset, and the ability to issue an asset of your own.

All three are permissionless. There is no account to open and no approval to wait for. Your assets stay in your wallet, and nobody, including Reflect, can move them, change where they are allocated, or stop you redeeming.

#### Earn

Deposit an industry-leading stablecoin and receive its plus asset: the same dollar, now earning interest. Your balance grows for as long as you hold it, and you can redeem back at any time.

* **No lockups.** Redeem back to the underlying stablecoin at any time.
* **Risk-adjusted rates.** Allocation follows a methodology built with [Blockworks Advisory](https://www.blockworksresearch.com/advisory) and published in full, so you can see why your money sits where it does.
* **Transparent down to the market.** Every venue holding your reserves is visible onchain.

<Card title="Explore Earn" icon="chart-line-up" href="https://docs.reflect.money/products/earn">
  Supported stablecoins, current rates, and how allocation is decided.
</Card>

#### Protect

Any yield-bearing asset can be split into two markets, senior and junior. Senior pays part of its interest to junior. In exchange, junior absorbs losses first.

* **Hold senior** for a lower rate with a cushion beneath it, if you care more about protecting your balance than maximising it.
* **Hold junior** for an amplified rate, if you are willing to take the first loss to get it.

You can tranche Reflect's own plus assets or any other supported yield-bearing asset.

<Card title="Explore Protect" icon="shield-halved" href="https://docs.reflect.money/products/protect">
  Live markets, protection ratios, caps, and how the loss waterfall works.
</Card>

#### Create

Issue your own yield-bearing asset, backed by collateral you choose from across the Solana network, including tokenised treasuries, equities, funds, plus assets and Protect senior positions.

* **As a stablecoin,** if you want to issue a dollar for yourself or a community.
* **As an index,** if you want to hold a basket of assets as a single token and track it in one place.

<Card title="Explore Create" icon="wand-magic-sparkles" href="https://docs.reflect.money/products/create">
  Available collateral, how backing works, and issuing your first asset.
</Card>

#### How Your Funds Are Held

Reflect does not take custody of anything. Allocation follows published rules and runs automatically, so there is no administrator who decides where your money goes, no strategy that can be rewritten while you hold it, and no party who can delay or refuse a redemption.

*This is the reason Reflect can offer these products openly rather than only to approved institutions.*

<Columns>
  <Card title="Assets" icon="coins" href="https://docs.reflect.money/assets">
    Every plus asset, what backs it, and where its reserves sit.
  </Card>

  <Card title="Open the App" icon="arrow-up-right-from-square" href="https://alpha.reflect.money">
    Start earning on the stablecoins you already hold.
  </Card>
</Columns>

<Card title="FAQs" icon="question" href="https://docs.reflect.money/faq">
  Common questions about rates, redemption and risk.
</Card>