Reflect Money Stablecoin SDK

https://docs.reflect.money/api-reference
Admin
The Reflect Money Stablecoin SDK enables developers to build fintech applications with yield-bearing...
Tokens:11,032
Snippets:86
Trust Score:5.2
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install with yarn

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

Install the Reflect Whitelabel SDK using yarn.

```bash
yarn add @reflectmoney/proxy.ts
```

--------------------------------

### Install with pnpm

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

Install the Reflect Whitelabel SDK using pnpm.

```bash
pnpm install @reflectmoney/proxy.ts
```

--------------------------------

### Install with yarn

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

Install the Reflect Oracle SDK using yarn.

```bash
yarn add @reflectmoney/oracle.ts
```

--------------------------------

### Install with npm

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

Install the Reflect Oracle SDK using npm.

```bash
npm install @reflectmoney/oracle.ts
```

--------------------------------

### Install with npm

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

Install the Reflect Whitelabel SDK using npm.

```bash
npm install @reflectmoney/proxy.ts
```

--------------------------------

### Install with pnpm

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

Install the Reflect Oracle SDK using pnpm.

```bash
pnpm install @reflectmoney/oracle.ts
```

--------------------------------

### Install @reflectmoney/stable.ts with npm

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

Install the Reflect Stablecoin SDK using the npm package manager.

```bash
npm install @reflectmoney/stable.ts
```

--------------------------------

### Installation

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

Install the Reflect Oracle SDK using yarn, npm, or pnpm.

```APIDOC
## Installation

### yarn
```bash
yarn add @reflectmoney/oracle.ts
```

### npm
```bash
npm install @reflectmoney/oracle.ts
```

### pnpm
```bash
pnpm install @reflectmoney/oracle.ts
```
```

--------------------------------

### Install @reflectmoney/stable.ts with pnpm

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

Install the Reflect Stablecoin SDK using the pnpm package manager.

```bash
pnpm install @reflectmoney/stable.ts
```

--------------------------------

### Install @reflectmoney/stable.ts with yarn

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

Install the Reflect Stablecoin SDK using the yarn package manager.

```bash
yarn add @reflectmoney/stable.ts
```

--------------------------------

### Initialize a new proxy

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

Use the static `initialize` method on the `Proxy` class to create a new proxy. Requires onchain accounts to be initialized; the constructor should only be used after setup.

```typescript
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
```

--------------------------------

### Proxy.initialize

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

Creates a new proxy instance by generating an initialization instruction. Requires signer, authority, branded mint, fee basis points, and stablecoin mint.

```APIDOC
## Proxy.initialize

### Description
Creates a new proxy by generating an initialization instruction. This sets up the proxy state with the specified authority, branded token mint, fee, and stablecoin mint.

### Method
initialize

### Parameters
- **signer** (Wallet) - Required - The wallet signing the transaction.
- **authority** (Address) - Required - The authority address for the proxy.
- **brandedMint** (Address) - Required - The branded token mint address.
- **feeBps** (number) - Required - Fee in basis points (e.g., 50 for 0.5%).
- **stablecoinMint** (Address) - Required - The stablecoin mint address (e.g., USDC+).

### Request Example
```typescript
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+
});
```
```

--------------------------------

### initialize(params)

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

Creates a new proxy state account with the specified configuration. Returns a create proxy instruction.

```APIDOC
## initialize(params)

### Description
Creates a new proxy state account with the specified configuration.

### Method
initialize

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

### Returns
`Promise<Instruction>` - A create proxy instruction
```

--------------------------------

### Creating a New Proxy with Proxy.initialize

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

Initializes a new proxy with a signer, authority, branded mint, fee basis points, and stablecoin mint. The feeBps is set to 50 (0.5% fee) and the stablecoin mint is USDC+.

```typescript
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

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

Shows two methods to load a proxy: using Proxy.loadFromMint with a branded mint, or creating a new Proxy instance and calling load() manually. Both require a connection and the proxy address or mint.

```typescript
// 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();
```

--------------------------------

### Proxy.initialize

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

Creates a new proxy instance by initializing onchain accounts. This is a static method that returns a transaction instruction for creating the proxy.

```APIDOC
## Proxy.initialize

### Description
Creates a new proxy instance by initializing onchain accounts. This is a static method that returns a transaction instruction for creating the proxy.

### Method
initialize

### Parameters
- **signer** (Signer) - Required - The signer account for the transaction.
- **brandedMint** (Address) - Required - The mint address of the branded stablecoin.
- **feeBps** (number) - Required - Fee basis points (e.g., 100 for 1%).
- **stablecoinMint** (Address) - Required - The mint address of the underlying stablecoin (e.g., USDC_PLUS_MINT).

### Request Example
```typescript
import { Proxy, USDC_PLUS_MINT } from "@reflectmoney/proxy.ts";
import { createSolanaRpc, address } from "@solana/kit";

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

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

### Response
Returns a transaction instruction (createProxyIx) that can be signed and sent.
```

--------------------------------

### new Proxy() + load()

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

Creates a proxy instance manually using a known proxy state address, then loads its data. Useful when the proxy address is already known.

```APIDOC
## new Proxy() + load()

### Description
Creates a new Proxy instance with a given proxy state address and then loads the on-chain data. This is an alternative to `loadFromMint` when the proxy address is already known.

### Method
constructor + load

### Parameters
- **connection** (Connection) - Required - The Solana connection object.
- **proxyAddress** (Address) - Required - The proxy state address.

### Request Example
```typescript
const proxy2 = new Proxy({
    connection: myConnection,
    proxyAddress: address("ProxyStateAddress")
});
await proxy2.load();
```
```

--------------------------------

### loadFromMint(params)

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

Creates a new Proxy instance by deriving the proxy state address from a branded mint. Returns a new Proxy instance with loaded state data.

```APIDOC
## loadFromMint(params)

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

### Method
loadFromMint

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

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

--------------------------------

### Load proxy from mint address

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

Use the `loadFromMint` method to load a proxy when you know the branded stablecoin mint address but not the proxy account address.

```typescript
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.loadFromMint

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

Loads a Proxy instance when provided with the mint address of the branded stablecoin. This is a static method that resolves the proxy account from the mint.

```APIDOC
## Proxy.loadFromMint

### Description
Loads a Proxy instance when provided with the mint address of the branded stablecoin. This is a static method that resolves the proxy account from the mint.

### Method
loadFromMint

### Parameters
- **connection** (SolanaRpc) - Required - The Solana RPC connection.
- **brandedMint** (Address) - Required - The mint address of the branded stablecoin.

### Request Example
```typescript
import { Proxy } from "@reflectmoney/proxy.ts";
import { createSolanaRpc, address } from "@solana/kit";

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

const proxy = Proxy.loadFromMint({ 
    connection, 
    brandedMint: address("<your branded stablecoin mint address>")
});
```

### Response
Returns a Proxy instance.
```

--------------------------------

### new Proxy()

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

Loads an existing proxy by its state address. The constructor lazy-loads all necessary onchain state in the background.

```APIDOC
## new Proxy()

### Description
Loads an existing proxy by its state address. The constructor lazy-loads all necessary onchain state in the background.

### Method
constructor

### Parameters
- **connection** (SolanaRpc) - Required - The Solana RPC connection.
- **proxyStateAddress** (Address) - Required - The address of the proxy account.

### Request Example
```typescript
import { Proxy } from "@reflectmoney/proxy.ts";
import { createSolanaRpc, address } from "@solana/kit";

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

const proxy = new Proxy({ 
    connection, 
    proxyStateAddress: address("<your proxy account address>")
});
```

### Response
Returns a Proxy instance.
```

--------------------------------

### Initialize Doppler instance

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

Initialize a Doppler instance with a Solana connection and an admin keypair.

```typescript
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);
```

--------------------------------

### new Doppler(connection, admin)

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

Initializes a Doppler instance with a Solana connection and an authority keypair for interacting with oracle accounts.

```APIDOC
## Constructor: new Doppler(connection, admin)

### Description
Creates a new Doppler instance for interacting with oracle accounts on Solana.

### Parameters
- **connection** (Connection) - Required - A Solana connection object.
- **admin** (Keypair) - Required - The authority keypair used for signing transactions.

### Example
```typescript
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);
```
```

--------------------------------

### deposit(params)

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

Creates a deposit instruction that converts stablecoins to branded tokens. Returns a deposit instruction.

```APIDOC
## deposit(params)

### Description
Creates a deposit instruction that converts stablecoins to branded tokens.

### Method
deposit

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

### Returns
`Promise<Instruction>` - A deposit instruction
```

--------------------------------

### Load an existing proxy

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

Use the constructor to load an existing proxy. The SDK lazy-loads all necessary onchain state in the background.

```typescript
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>")
});
```

--------------------------------

### Create oracle account

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

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

```typescript
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)),
    }
);
```

--------------------------------

### proxy.deposit

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

Generates an instruction to deposit stablecoins into the proxy, minting branded tokens in return.

```APIDOC
## proxy.deposit

### Description
Creates a deposit instruction to convert stablecoins into branded tokens. The amount is specified in the smallest unit (e.g., 1 USDC+ = 1,000,000 units).

### Method
deposit

### Parameters
- **signer** (Wallet) - Required - The wallet signing the transaction.
- **amount** (number) - Required - The amount of stablecoins to deposit (in base units).

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

--------------------------------

### Proxy.loadFromMint

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

Loads an existing proxy instance using the branded token mint address. This is a static method that fetches the proxy state from the blockchain.

```APIDOC
## Proxy.loadFromMint

### Description
Loads an existing proxy instance by deriving its state address from the branded token mint and fetching the on-chain data.

### Method
loadFromMint

### Parameters
- **connection** (Connection) - Required - The Solana connection object.
- **brandedMint** (Address) - Required - The branded token mint address.

### Request Example
```typescript
const proxy = await Proxy.loadFromMint({
    connection: myConnection,
    brandedMint: address("BrandedTokenMint")
});
```
```

--------------------------------

### proxy.withdraw

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

Generates an instruction to withdraw branded tokens and receive stablecoins in return.

```APIDOC
## proxy.withdraw

### Description
Creates a withdrawal instruction to convert branded tokens back into stablecoins. The amount is specified in the smallest unit of the branded token.

### Method
withdraw

### Parameters
- **signer** (Wallet) - Required - The wallet signing the transaction.
- **amount** (number) - Required - The amount of branded tokens to withdraw (in base units).

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

--------------------------------

### withdraw(params)

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

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

```APIDOC
## withdraw(params)

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

### Method
withdraw

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

### Returns
`Promise<Instruction>` - A withdraw instruction
```

--------------------------------

### Working with PDAs

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

Derives the proxy state PDA and its bump seed from a branded token mint using PdaClient.deriveProxyState. Logs the PDA address and bump seed.

```typescript
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);
```

--------------------------------

### claimFees()

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

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

```APIDOC
## claimFees()

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

### Method
claimFees

### Returns
`Promise<Instruction>` - A claim fees instruction
```

--------------------------------

### doppler.createOracleAccount(seed, serializer, initialData)

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

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

```APIDOC
## Method: createOracleAccount

### Description
Creates a new oracle account with the given seed and initial data.

### Parameters
- **seed** (string) - Required - The seed used to derive the oracle account address.
- **serializer** (Serializer) - Required - The serializer used to serialize the initial payload (e.g., `U8Array8Serializer`).
- **initialData** (object) - Required - The initial data containing:
  - **slot** (bigint) - Required - The initial slot number.
  - **payload** (Uint8Array) - Required - The initial 8-byte payload.

### Example
```typescript
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)),
    }
);
```
```

--------------------------------

### load()

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

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

```APIDOC
## load()

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

### Method
load

### Returns
`Promise<void>`
```

--------------------------------

### Mint USDC+ Stablecoin with TypeScript

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

Script to mint USDC+ stablecoins. Uses UsdcPlusStablecoin, loads controller data, and sends a versioned transaction with slippage protection.

```TypeScript
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());
```

--------------------------------

### proxy.claimFees

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

Generates an instruction to claim accumulated fees. This method is only callable by the proxy authority.

```APIDOC
## proxy.claimFees

### Description
Creates a claim fees instruction. This is an authority-only operation that transfers accumulated fees to the authority.

### Method
claimFees

### Parameters
None

### Request Example
```typescript
const claimFeesInstruction = await proxy.claimFees();
```
```

--------------------------------

### Update an oracle

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

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

```typescript
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(),
);
```

--------------------------------

### Redeem USDC+ Stablecoin with TypeScript

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

Script to redeem USDC+ stablecoins. Uses UsdcPlusStablecoin, loads controller data, and sends a versioned transaction. Note that USDC+ is yield bearing, so MIN_RECEIVED is set higher than AMOUNT.

```TypeScript
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());
```

--------------------------------

### doppler.fetchOracle(oraclePublicKey, serializer)

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

Reads the latest oracle state and decodes the payload.

```APIDOC
## Method: fetchOracle

### Description
Fetches the latest oracle data for a given oracle account.

### Parameters
- **oraclePublicKey** (PublicKey) - Required - The public key of the oracle account to fetch.
- **serializer** (Serializer) - Required - The serializer used to deserialize the payload (e.g., `U8Array8Serializer`).

### Returns
- **oracleData** (object | null) - The oracle data containing:
  - **slot** (bigint) - The slot number of the latest update.
  - **payload** (Uint8Array) - The 8-byte payload.
  Returns `null` if the oracle account does not exist.

### Example
```typescript
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
```
```

--------------------------------

### Deposit into ReflectTokenizedBond (deposit.ts)

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

Deposits a specified amount of a stablecoin into the tokenized bond program. Uses the ReflectTokenizedBond.deposit method with the user's public key, stablecoin index, and amount. The transaction is built as a VersionedTransaction and signed with the user's keypair.

```typescript
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());
```

--------------------------------

### Stablecoin abstract class definition

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

Defines the abstract Stablecoin class that all stablecoin-specific classes (e.g., UsdcPlusStablecoin, LstStablecoin) follow. It includes properties for index, name, connection, controller, collaterals, stablecoinMint, pythClient, and optional driftClient, along with abstract methods for initializeTokenAccounts, mint, redeem, and rebalance.

```typescript
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[]>;
}
```

--------------------------------

### Depositing Stablecoins

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

Deposits stablecoins into the proxy. The amount is specified in the smallest unit (6 decimals), so 1,000,000 represents 1 USDC+.

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

--------------------------------

### Mint LST Stablecoin with TypeScript

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

Script to mint LST stablecoins. Uses LstStablecoin, loads controller data, and sends a versioned transaction with slippage protection.

```TypeScript
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());
```

--------------------------------

### PdaClient.deriveProxyState(brandedMint)

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

Derives the proxy state PDA from a branded mint address. Returns a tuple containing the PDA address and bump seed.

```APIDOC
## PdaClient.deriveProxyState(brandedMint)

### Description
Derives the proxy state PDA from a branded mint address.

### Method
deriveProxyState

### Parameters
- `brandedMint: Address` - Required - The branded mint address

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

--------------------------------

### Stablecoin abstract class

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

The Stablecoin superclass defines the common interface for all stablecoin integrations, including methods for minting, redeeming, and rebalancing.

```APIDOC
## Stablecoin abstract class

### Description
Abstract class defining the common interface for all stablecoin integrations. It includes properties for index, name, connection, controller, collaterals, stablecoin mint, Pyth client, and optional Drift client. It declares abstract methods for initializing token accounts, minting, redeeming, and rebalancing.

### Properties
- **index** (number) - Internal index used for derivation.
- **name** (string) - Name of the strategy.
- **connection** (Connection) - RPC connection class.
- **controller** (PublicKey) - Public key of the controller account.
- **collaterals** (Collateral[]) - List of collateral assets allowed for deposits.
- **stablecoinMint** (PublicKey) - Mint of the stablecoin.
- **pythClient** (HermesClient) - Pyth client used for pricing data.
- **driftClient** (DriftClient?) - Drift client, only required for Drift-powered strategies.

### Methods
#### initializeTokenAccounts
- **Parameters**: owner (PublicKey), mints (PublicKey[]), signer (PublicKey)
- **Returns**: Promise<TransactionInstruction[]>
- **Description**: Generate user's token accounts if minting for the first time.

#### mint
- **Parameters**: signer (PublicKey), amount (BN | number), minimumReceived (BN | number), ...args (any[])
- **Returns**: Promise<TransactionInstruction[]>
- **Description**: Mint a stablecoin to user's wallet.

#### redeem
- **Parameters**: signer (PublicKey), amount (BN | number), minimumReceived (BN | number), ...args (any[])
- **Returns**: Promise<TransactionInstruction[]>
- **Description**: Redeem a stablecoin into underlying collateral.

#### rebalance
- **Parameters**: signer (PublicKey)
- **Returns**: Promise<TransactionInstruction[]>
- **Description**: Rebalance the strategy internal balances. Currently permissioned, requiring authentication at the protocol level.

### Example
```typescript
abstract class Stablecoin {
    public index: number;
    public name: string;
    public connection: Connection;
    public controller: PublicKey;
    public collaterals: Collateral[];
    public stablecoinMint: PublicKey;
    public pythClient: HermesClient;
    public driftClient?: DriftClient;

    abstract initializeTokenAccounts(owner: PublicKey, mints: PublicKey[], signer: PublicKey): Promise<TransactionInstruction[]>;
    abstract mint(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
    abstract redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
    abstract rebalance(signer: PublicKey): Promise<TransactionInstruction[]>;
}
```
```

--------------------------------

### Payload Helpers and Serializers

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

Utility functions and serializers for encoding and decoding 8-byte payloads.

```APIDOC
## Payload Helpers and Serializers

### Description
Provides helpers and serializers for working with 8-byte payloads.

### Functions
- **createPricePayload(u64)** - Creates an 8-byte payload from a u64 value (e.g., `BigInt(1_000_000)`).
- **readPriceFromPayload(payload)** - Decodes a u64 value from an 8-byte payload.

### Classes
- **U8Array8Serializer** - Serializes and deserializes 8-byte payloads. Used with `updateOracle` and `fetchOracle`.

### Payload Format
- 8-byte array representing a u64. For prices, this commonly encodes fixed-point integers (e.g., micro-units for 6-decimal tokens).
```

--------------------------------

### PdaClient.deriveProxyState

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

Derives the proxy state PDA (Program Derived Address) from a branded token mint address.

```APIDOC
## PdaClient.deriveProxyState

### Description
Derives the proxy state PDA (Program Derived Address) from a branded token mint address. Returns the PDA address and bump seed.

### Method
deriveProxyState

### Parameters
- **brandedMint** (Address) - Required - The branded token mint address.

### Returns
- **proxyStateAddress** (Address) - The derived PDA address.
- **bump** (number) - The bump seed.

### Request Example
```typescript
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);
```
```

--------------------------------

### Fetch oracle data

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

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

```typescript
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
```

--------------------------------

### doppler.updateOracle(oraclePublicKey, data, serializer)

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

Submits an update for an existing oracle account with a new slot and payload.

```APIDOC
## Method: updateOracle

### Description
Updates an existing oracle account with a new slot and payload.

### Parameters
- **oraclePublicKey** (PublicKey) - Required - The public key of the oracle account to update.
- **data** (object) - Required - The update data containing:
  - **slot** (bigint) - Required - The slot number for the update.
  - **payload** (Uint8Array) - Required - The 8-byte payload to store.
- **serializer** (Serializer) - Required - The serializer used to serialize the payload (e.g., `U8Array8Serializer`).

### Example
```typescript
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(),
);
```
```

--------------------------------

### Withdrawing to Stablecoins

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

Withdraws branded tokens from the proxy, converting them to stablecoins. The amount is in the smallest unit (6 decimals), so 1,000,000 represents 1 branded token.

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

--------------------------------

### Withdraw from ReflectTokenizedBond (withdraw.ts)

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

Withdraws a specified amount of a stablecoin from the tokenized bond program. Uses the ReflectTokenizedBond.withdraw method with the user's public key, stablecoin index, and amount. The transaction is built as a VersionedTransaction and signed with the user's keypair.

```typescript
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());
```

--------------------------------

### ReflectTokenizedBond.deposit

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

Deposits a specified amount of a stablecoin into the tokenized bond program. The method returns an instruction that can be added to a Solana transaction.

```APIDOC
## ReflectTokenizedBond.deposit

### Description
Deposits a specified amount of a stablecoin into the tokenized bond program. The method returns an instruction that can be added to a Solana transaction.

### Method
`deposit`

### Parameters
- **user** (PublicKey) - Required - The public key of the user making the deposit.
- **stablecoinIndex** (number) - Required - The index of the stablecoin to deposit.
- **amount** (BN) - Required - The amount to deposit, in base units (e.g., 1_000_000 per token).

### Request Example
```typescript
const instruction = reflectTokenizedBond.deposit(
    user.publicKey,
    stablecoin.index,
    AMOUNT
);
```

### Response
Returns a Solana transaction instruction that can be included in a transaction.

```

--------------------------------

### ReflectTokenizedBond.withdraw

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

Withdraws a specified amount of a stablecoin from the tokenized bond program. The method returns an instruction that can be added to a Solana transaction.

```APIDOC
## ReflectTokenizedBond.withdraw

### Description
Withdraws a specified amount of a stablecoin from the tokenized bond program. The method returns an instruction that can be added to a Solana transaction.

### Method
`withdraw`

### Parameters
- **user** (PublicKey) - Required - The public key of the user making the withdrawal.
- **stablecoinIndex** (number) - Required - The index of the stablecoin to withdraw.
- **amount** (BN) - Required - The amount to withdraw, in base units (e.g., 1_000_000 per token).

### Request Example
```typescript
const instruction = reflectTokenizedBond.withdraw(
    user.publicKey,
    stablecoin.index,
    AMOUNT
);
```

### Response
Returns a Solana transaction instruction that can be included in a transaction.

```

--------------------------------

### Claiming Fees (Authority Only)

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

Claims accumulated fees from the proxy. This operation is restricted to the authority.

```typescript
const claimFeesInstruction = await proxy.claimFees();
```
Tokens:
Raw