@reflectmoney/stable.ts 1.0.2 → 1.0.4

package/README.md

@@ -1,14 +1,22 @@
-# Reflect Money Stable.ts SDK
+# Reflect Money SDK
 
-A comprehensive TypeScript SDK for interacting with the Reflect Protocol Delta-Neutral Program on Solana. This SDK provides high-level abstractions for managing stablecoins, administrative operations, and protocol integrations.
+A TypeScript SDK for interacting with the Reflect programs on Solana. This SDK provides high-level abstractions for minting, redeeming, and managing stablecoins, administrative operations, and protocol integrations.
+
+## Installation
+
+```bash
+npm install @reflectmoney/stable.ts
+# or
+yarn add @reflectmoney/stable.ts
+```
 
 ## Overview
 
-The Reflect Protocol SDK enables developers to interact with three main Reflect stablecoins:
+The Reflect SDK enables developers to interact with the protocol via three main Reflect stablecoins:
 
-1. **USDC+ (Strategy 0)**: Stablecoin backed by USDC deployed in money markets
-2. **JLP Hedged (Strategy 1)**: Stablecoin backed by the JLP token, neutralised with perpetual hedging strategies
-3. **LST Delta-Neutral (Strategy 2)**: Stablecoin backed by hedged LSTs
+1. **USDC+ (Index 0)**: Stablecoin backed by USDC deployed in various money markets
+2. **JLP Hedged (Index 1)**: Stablecoin backed by the JLP token, neutralized with perpetual hedging strategies
+3. **LST Delta-Neutral (Index 2)**: Stablecoin backed by LSTs hedged by perpetual futures positions
 
 ## Architecture
 
@@ -17,153 +25,156 @@ The SDK is organized into several key components:
 ### Core Classes
 
 #### `Stablecoin` (Abstract Base Class)
-The foundation for all stablecoin implementations. Provides common interface for:
-- minting,
-- redemption,
-- administrative operations.
+The foundation for all stablecoin implementations. Provides abstract functions and a common interface for:
+- Minting
+- Redemption
+- Administrative operations
 
 **Key Methods:**
-- `initialize()` - Initialize the stablecoin strategy (admin-only)
 - `mint()` - Create mint instructions
 - `redeem()` - Create redemption instructions
-- `rebalance()` - Create rebalancing instructions (admin-only)
-- `updateCap()` - Update supply cap (admin-only)
-- `updateRecipients()` - Update fee recipients (admin-only)
+- `rebalance()` - Create rebalance instructions (admin-only or permissionless, depending on the strategy)
 
-#### `ReflectAdmin`
-Administrative client for protocol-level operations:
-- Protocol initialization
-- Role and permission management
-- Action freezing/unfreezing
-- Admin account creation
-
-**Key Methods:**
-- `initializeMain()` - Initialize the main program account
-- `freezeProtocolAction()` - Freeze/unfreeze protocol actions
-- `updateRoleHolderProtocol()` - Update protocol-level permissions
-- `createAdminAccount()` - Create new admin accounts
+#### `ReflectKeeper`
+Administrative client for protocol-level operations (admin-only).
 
 #### `PdaClient`
-Utility class for deriving Program Derived Addresses (PDAs):
-- Main program accounts
-- Controller accounts
+Utility class for deriving PDAs:
+- Configuration program accounts
+- Stablecoin controllers
 - Permission accounts
-- External protocol integrations (Drift, Jupiter)
+- External protocol integrations (Drift, Jupiter, Tokenized Bond)
 
-#### `ReflectTokenisedBond`
-Client for tokenized bonds program, allowing for wrapping base stablecoins into yield-bearing receipts. Allows for:
+#### `ReflectTokenizedBond`
+Client for the tokenized bonds program used for wrapping base stablecoins into yield-bearing receipts. Allows for:
 - Vault creation and management
 - Receipt token generation
 - Deposit and withdrawal operations
 
 ### Stablecoin Implementations
 
-#### `UsdcStablecoin`
-Simple USDC-backed stablecoin implementation:
+#### `UsdcPlusStablecoin`
+USDC+ is a stablecoin backed by USDC deployed in money markets. Implementation details:
+- Status: Live
 - Strategy ID: 0
 - Collateral: USDC
-- Integrated with tokenised bonds program on the protocol level
+- Integrated with the tokenized bonds program at the protocol level
+- Users only receive the yield-bearing stablecoin
+- Does not require rebalancing
 
-#### `JlpStablecoin`
-Jupiter LP token with perpetual hedging:
+#### `UsdjStablecoin`
+Stablecoin backed by JLP neutralized with perpetual hedging:
+- Status: Coming soon
 - Strategy ID: 1
 - Collateral: JLP (Jupiter LP tokens)
+- Requires manual wrapping via the Tokenized Bonds program
+- Requires rebalancing, currently permissioned
 
 #### `LstStablecoin`
 Liquid staking token delta-neutral strategy:
+- Status: Live
 - Strategy ID: 2
-- Collateral: Various LSTs (mSOL, jitoSOL, etc.)
+- Collateral: Various LSTs (mSOL, jitoSOL, etc.) - use `load()` functionality to fetch the currently supported list of collateral assets
+- Requires manual wrapping via the Tokenized Bonds program
+- Requires rebalancing, currently permissioned
 
-## Installation
+## Usage
 
-```bash
-npm install @reflectmoney/stable.ts
-# or
-yarn add @reflectmoney/stable.ts
-```
+Follow the snippets 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 - simply change between the three:
 
-## Quick Start
+```typescript
+const stablecoin = new UsdcPlusStablecoin(connection);
+const stablecoin = new UsdjStablecoin(connection);
+const stablecoin = new LstStablecoin(connection);
+```
 
 ### Minting Stablecoins
 
 ```typescript
-import { LstStablecoin } from '@reflectmoney/stable.ts';
-import { PublicKey } from '@solana/web3.js';
+import { UsdcPlusStablecoin } from '@reflectmoney/stable.ts';
+import { PublicKey, Keypair, Connection, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
 import BN from 'bn.js';
 
-const lstStablecoin = new LstStablecoin(connection);
+// Use an actual user's public key, read from wallet adapter or local environment.
+const user = Keypair.generate();
+const stablecoin = new UsdcPlusStablecoin(connection);
+
+// Load controller data for the most up-to-date stablecoin setup.
+await stablecoin.load(connection);
+
+// Mint stablecoins against USDC collateral
+const instructions = await stablecoin.mint(
+    user.publicKey,
+    new BN(1000 * 1_000_000), // Deposit collateral of 1,000 USDC (6 decimals)
+    new BN(999 * 1_000_000),  // Minimum received USDC+ (0.1% slippage protection)
+);
 
-// Load controller data
-await lstStablecoin.load(connection);
+const { blockhash } = await connection.getLatestBlockhash();
 
-// Mint stablecoins against LST collateral
-const mintInstructions = await lstStablecoin.mint(
-    userPublicKey,
-    new BN(1000000), // 1 USDC (6 decimals)
-    new BN(999000),  // Minimum received (slippage protection)
-    new PublicKey("<jitoSOL mint>") // LST mint address
+const {
+    value: lookupTable
+} = await connection.getAddressLookupTable(
+    stablecoin.lookupTable
 );
+
+const message = new TransactionMessage({
+    instructions,
+    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());
 ```
 
-### Administrative Operations
+### Redeeming Stablecoins
 
 ```typescript
-import { ReflectAdmin } from '@reflectmoney/stable.ts';
+import { UsdcPlusStablecoin } from '@reflectmoney/stable.ts';
+import { PublicKey, Keypair, Connection, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
+import BN from 'bn.js';
 
-const admin = new ReflectAdmin({
-    admin: adminPublicKey,
-    connection
-});
+// Use an actual user's public key, read from wallet adapter or local environment.
+const user = Keypair.generate();
+const stablecoin = new UsdcPlusStablecoin(connection);
 
-// Freeze minting operations
-const freezeIx = await admin.freezeProtocolAction(true, Action.Mint);
+// Load controller data for the most up-to-date stablecoin setup.
+await stablecoin.load(connection);
 
-// Update supply cap
-const updateCapIx = await usdcStablecoin.updateCap(adminPublicKey, new BN(1000000000));
-```
+// Redeem USDC+ into USDC
+const instructions = await stablecoin.redeem(
+    user.publicKey,
+    new BN(999 * 1_000_000), // Burn 999 of USDC+
+    new BN(1_000 * 1_000_000),  // Minimum received USDC (USDC+ is yield bearing, so you'll receive more USDC over time)
+);
 
-## Advanced Usage
+const { blockhash } = await connection.getLatestBlockhash();
 
-### Custom Stablecoin Implementation
+const {
+    value: lookupTable
+} = await connection.getAddressLookupTable(
+    stablecoin.lookupTable
+);
 
-```typescript
-import { Stablecoin } from '@reflectmoney/stable.ts';
-
-class CustomStablecoin extends Stablecoin {
-    constructor(connection: Connection) {
-        super(3, "Custom Strategy", connection);
-        this.collaterals = [{ mint: customMint, oracle: customOracle }];
-    }
-
-    async initialize(signer: PublicKey, ...args: any[]): Promise<TransactionInstruction[]> {
-        // Custom initialization logic
-    }
-
-    async mint(signer: PublicKey, amount: BN, minimumReceived: BN, ...args: any[]): Promise<TransactionInstruction[]> {
-        // Custom minting logic
-    }
-
-    async redeem(signer: PublicKey, amount: BN, minimumReceived: BN, ...args: any[]): Promise<TransactionInstruction[]> {
-        // Custom redemption logic
-    }
-
-    async rebalance(signer: PublicKey): Promise<TransactionInstruction[]> {
-        // Custom rebalancing logic
-    }
-
-    async constructAccounts<T>(signer: PublicKey, ...args: any[]): Promise<T> {
-        // Custom account construction
-    }
-
-    async constructRemainingAccounts(): Promise<AccountMeta[]> {
-        // Custom remaining accounts
-    }
-}
+const message = new TransactionMessage({
+    instructions,
+    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());
 ```
 
 ### Integration with External Protocols
 
-The SDK is built in integration with:
+The SDK is built with integration for:
 - **Drift Protocol**: For perpetual futures and spot trading
 - **Jupiter Protocol**: For LP token operations and swaps
 - **Pyth Network**: For price oracle data

package/dist/classes/ReflectKeeper.d.ts

@@ -0,0 +1,104 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Action, Role, Update } from "../generated/reflect_main";
+/**
+ * Administrative client for the Reflect protocol.
+ * Provides functionality for protocol-level administration including:
+ * - Protocol initialization and setup
+ * - Role and permission management
+ * - Action freezing/unfreezing
+ * - Admin account creation and management
+ *
+ * This class is used by protocol administrators to manage global settings,
+ * user permissions, and protocol-wide configurations.
+ */
+export declare class ReflectAdmin {
+    /** Public key of the admin user */
+    private admin;
+    /** Public key of the main program account */
+    private main;
+    /** Solana connection instance for RPC communication */
+    private connection;
+    /**
+     * Creates a new ReflectAdmin instance.
+     *
+     * @param admin - Public key of the admin user
+     * @param connection - Solana connection instance
+     */
+    constructor({ admin, connection }: {
+        admin: PublicKey;
+        connection: Connection;
+    });
+    /**
+     * Creates the main program account. This is the initial step of protocol setup.
+     *
+     * @param admin - Public key of the initial admin
+     * @returns TransactionInstruction for initializing the main account
+     */
+    static initializeMain(admin: PublicKey): import("@solana/web3.js").TransactionInstruction;
+    /**
+     * Freezes or unfreezes a specific protocol action.
+     *
+     * @param freeze - Whether to freeze (true) or unfreeze (false) the action
+     * @param action - The action to freeze/unfreeze
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    freezeProtocolAction(freeze: boolean, action: Action): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Freezes or unfreezes a specific DEX program.
+     *
+     * @param freeze - Whether to freeze (true) or unfreeze (false) the program
+     * @param programIndex - Index of the program to freeze/unfreeze
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    freezeDex(freeze: boolean, programIndex: number): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Creates a new admin account with specified permissions.
+     *
+     * @param signer - Public key of the caller (must be existing admin)
+     * @param newAdmin - Public key of the new admin to create
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    createAdminAccount(signer: PublicKey, newAdmin: PublicKey): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Updates role holder permissions at the protocol level.
+     *
+     * @param signer - Public key of the admin signer
+     * @param adminToUpdate - Public key of the admin whose permissions are being updated
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateRoleHolderProtocol(signer: PublicKey, adminToUpdate: PublicKey, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Updates role holder permissions for a specific strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param strategyId - ID of the strategy to update permissions for
+     * @param adminToUpdate - Public key of the admin whose permissions are being updated
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateRoleHolderStrategy(signer: PublicKey, strategyId: number, adminToUpdate: PublicKey, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Updates action role permissions for a specific strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param strategyId - ID of the strategy to update permissions for
+     * @param action - The action being modified
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateActionRoleStrategy(signer: PublicKey, strategyId: number, action: Action, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Updates action role permissions at the protocol level.
+     *
+     * @param signer - Public key of the admin signer
+     * @param action - The action being modified
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateActionRoleProtocol(signer: PublicKey, action: Action, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+}

package/dist/classes/ReflectKeeper.js

@@ -0,0 +1,219 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectAdmin = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const reflect_main_1 = require("../generated/reflect_main");
+const PdaClient_1 = require("./PdaClient");
+/**
+ * Administrative client for the Reflect protocol.
+ * Provides functionality for protocol-level administration including:
+ * - Protocol initialization and setup
+ * - Role and permission management
+ * - Action freezing/unfreezing
+ * - Admin account creation and management
+ *
+ * This class is used by protocol administrators to manage global settings,
+ * user permissions, and protocol-wide configurations.
+ */
+class ReflectAdmin {
+    /**
+     * Creates a new ReflectAdmin instance.
+     *
+     * @param admin - Public key of the admin user
+     * @param connection - Solana connection instance
+     */
+    constructor({ admin, connection }) {
+        this.admin = admin;
+        this.connection = connection;
+        this.main = PdaClient_1.PdaClient.deriveMain();
+    }
+    /**
+     * Creates the main program account. This is the initial step of protocol setup.
+     *
+     * @param admin - Public key of the initial admin
+     * @returns TransactionInstruction for initializing the main account
+     */
+    static initializeMain(admin) {
+        const [main] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("main")], reflect_main_1.PROGRAM_ID);
+        const ix = (0, reflect_main_1.createInitMainInstruction)({
+            main,
+            admin,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            creds: PdaClient_1.PdaClient.derivePermissions(admin)
+        }, reflect_main_1.PROGRAM_ID);
+        return ix;
+    }
+    /**
+     * Freezes or unfreezes a specific protocol action.
+     *
+     * @param freeze - Whether to freeze (true) or unfreeze (false) the action
+     * @param action - The action to freeze/unfreeze
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    freezeProtocolAction(freeze, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createFreezeProtocolActionInstruction)({
+                admin: this.admin,
+                main: this.main,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(this.admin),
+            }, {
+                freeze,
+                action
+            });
+            return ix;
+        });
+    }
+    /**
+     * Freezes or unfreezes a specific DEX program.
+     *
+     * @param freeze - Whether to freeze (true) or unfreeze (false) the program
+     * @param programIndex - Index of the program to freeze/unfreeze
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    freezeDex(freeze, programIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createFreezeProgramInstruction)({
+                admin: this.admin,
+                main: this.main,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(this.admin),
+            }, {
+                freeze,
+                programIndex
+            });
+            return ix;
+        });
+    }
+    /**
+     * Creates a new admin account with specified permissions.
+     *
+     * @param signer - Public key of the caller (must be existing admin)
+     * @param newAdmin - Public key of the new admin to create
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    createAdminAccount(signer, newAdmin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createCreateAdminAccountInstruction)({
+                caller: signer,
+                newCreds: PdaClient_1.PdaClient.derivePermissions(newAdmin),
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, {
+                newAdmin
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    /**
+     * Updates role holder permissions at the protocol level.
+     *
+     * @param signer - Public key of the admin signer
+     * @param adminToUpdate - Public key of the admin whose permissions are being updated
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateRoleHolderProtocol(signer, adminToUpdate, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateRoleHolderProtocolInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                updateAdminPermissions: PdaClient_1.PdaClient.derivePermissions(adminToUpdate),
+                // Dummy strategy account.
+                strategy: PdaClient_1.PdaClient.deriveController(0)
+            }, {
+                update,
+                accessLevel: affectedRole,
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    /**
+     * Updates role holder permissions for a specific strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param strategyId - ID of the strategy to update permissions for
+     * @param adminToUpdate - Public key of the admin whose permissions are being updated
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateRoleHolderStrategy(signer, strategyId, adminToUpdate, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateRoleHolderStrategyInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                updateAdminPermissions: PdaClient_1.PdaClient.derivePermissions(adminToUpdate),
+                strategy: PdaClient_1.PdaClient.deriveController(strategyId)
+            }, {
+                update,
+                role: affectedRole,
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    /**
+     * Updates action role permissions for a specific strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param strategyId - ID of the strategy to update permissions for
+     * @param action - The action being modified
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateActionRoleStrategy(signer, strategyId, action, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateActionRoleStrategyInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                strategy: PdaClient_1.PdaClient.deriveController(strategyId)
+            }, {
+                update,
+                role: affectedRole,
+                action
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    /**
+     * Updates action role permissions at the protocol level.
+     *
+     * @param signer - Public key of the admin signer
+     * @param action - The action being modified
+     * @param affectedRole - The role being modified
+     * @param update - The type of update (Grant or Revoke)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateActionRoleProtocol(signer, action, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateActionRoleProtocolInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, {
+                action,
+                role: affectedRole,
+                update
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+}
+exports.ReflectAdmin = ReflectAdmin;

package/dist/classes/Stablecoin.d.ts

@@ -28,6 +28,8 @@ export declare abstract class Stablecoin {
     stablecoinMint: PublicKey;
     /** Optional Drift client instance for DeFi operations */
     driftClient?: DriftClient;
+    /** Lookup table with stablecoin-specific accounts. */
+    lookupTable: PublicKey;
     /**
      * Creates a new Stablecoin instance.
      *
@@ -35,7 +37,7 @@ export declare abstract class Stablecoin {
      * @param name - Human-readable name for the stablecoin
      * @param connection - Solana connection instance
      */
-    constructor(index: number, name: string, connection: Connection);
+    constructor(index: number, name: string, connection: Connection, lookupTable: PublicKey);
     /**
      * Initializes token accounts for the specified owner and mints.
      * Creates associated token accounts if they don't exist.

package/dist/classes/Stablecoin.js

@@ -40,11 +40,12 @@ class Stablecoin {
      * @param name - Human-readable name for the stablecoin
      * @param connection - Solana connection instance
      */
-    constructor(index, name, connection) {
+    constructor(index, name, connection, lookupTable) {
         this.index = index;
         this.name = name;
         this.connection = connection;
         this.controller = PdaClient_1.PdaClient.deriveController(this.index);
+        this.lookupTable = lookupTable;
     }
     /**
      * Initializes token accounts for the specified owner and mints.

package/dist/classes/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./ReflectAdmin";
+export * from "./ReflectKeeper";
 export * from "./PdaClient";
 export * from "./Stablecoin";

package/dist/classes/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ReflectAdmin"), exports);
+__exportStar(require("./ReflectKeeper"), exports);
 __exportStar(require("./PdaClient"), exports);
 __exportStar(require("./Stablecoin"), exports);

package/dist/constants/index.d.ts

@@ -3,3 +3,4 @@ export * from "./drift";
 export * from "./wsol";
 export * from "./jupiter";
 export * from "./pyth";
+export * from "./lookupTables";

package/dist/constants/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./drift"), exports);
 __exportStar(require("./wsol"), exports);
 __exportStar(require("./jupiter"), exports);
 __exportStar(require("./pyth"), exports);
+__exportStar(require("./lookupTables"), exports);

package/dist/constants/lookupTables.d.ts

@@ -0,0 +1,4 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const USDC_PLUS_LOOKUP_TABLE: PublicKey;
+export declare const JLP_LOOKUP_TABLE: PublicKey;
+export declare const LST_LOOKUP_TABLE: PublicKey;

package/dist/constants/lookupTables.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LST_LOOKUP_TABLE = exports.JLP_LOOKUP_TABLE = exports.USDC_PLUS_LOOKUP_TABLE = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.USDC_PLUS_LOOKUP_TABLE = new web3_js_1.PublicKey(0);
+exports.JLP_LOOKUP_TABLE = new web3_js_1.PublicKey(0);
+exports.LST_LOOKUP_TABLE = new web3_js_1.PublicKey(0);

package/dist/stablecoins/LstStablecoin.js

@@ -39,7 +39,7 @@ class LstStablecoin extends Stablecoin_1.Stablecoin {
      * @param collateralMintsOverride - Optional override for collateral mint addresses
      */
     constructor(connection, stablecoinMintOverride, collateralMintsOverride) {
-        super(2, "Single-Sided LST Delta-Neutral", connection);
+        super(2, "LST Delta-Neutral", connection, constants_1.LST_LOOKUP_TABLE);
         this.driftClient = new sdk_1.DriftClient({
             connection,
             env: "mainnet-beta",

package/dist/stablecoins/UsdcPlusStablecoin.d.ts

@@ -0,0 +1,66 @@
+import { Stablecoin } from "../classes/Stablecoin";
+import { AccountMeta, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import BN from "bn.js";
+/**
+ * USDC+ Stablecoin implementation for the Reflect protocol.
+ * Extends the base Stablecoin class to provide USDC-specific functionality
+ * including initialization, minting, redemption, and rebalancing operations.
+ */
+export declare class UsdcPlusStablecoin extends Stablecoin {
+    /**
+     * Creates a new USDC+ Stablecoin instance.
+     *
+     * @param connection - Solana connection instance for RPC communication
+     * @param stablecoinMintOverride - Optional override for the stablecoin mint address
+     */
+    constructor(connection: Connection, stablecoinMintOverride?: PublicKey);
+    /**
+     * Initializes the USDC stablecoin with the specified parameters.
+     * Creates receipt tokens, initializes vault, and initializes the stablecoin.
+     *
+     * @param signer - Public key of the signer/initializer
+     * @param mint - Public key of the mint to be used for the stablecoin
+     * @param cap - Maximum supply cap as a BN (Big Number)
+     * @param recipientAddresses - Array of recipient public keys for fee distribution
+     * @param recipientCuts - Array of fee cuts (percentages) corresponding to each recipient
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    initialize(signer: PublicKey, mint: PublicKey, cap: BN, recipientAddresses: PublicKey[], recipientCuts: number[]): Promise<TransactionInstruction[]>;
+    /**
+     * Constructs the required accounts for the InitDriftControllerS1 instruction.
+     *
+     * @param signer - Public key of the signer
+     * @returns Promise resolving to the constructed accounts object of type T
+     */
+    constructAccounts<T>(signer: PublicKey): Promise<T>;
+    /**
+     * Constructs remaining accounts for transactions.
+     * Currently returns an empty array as no additional accounts are needed.
+     *
+     * @returns Promise resolving to an empty array of AccountMeta objects
+     */
+    constructRemainingAccounts(): Promise<AccountMeta[]>;
+    /**
+     * Creates a mint instruction for the USDC+ stablecoin.
+     *
+     * @param signer - Public key of the signer
+     * @param amount - Amount of USDC to deposit
+     * @param minimumReceived - Minimum amount of USDC+ stablecoins to receive (slippage protection)
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    mint(signer: PublicKey, amount: BN | number, minimumReceived: BN | number): Promise<TransactionInstruction[]>;
+    /**
+     * Creates a redeem instruction for the USDC stablecoin.
+     * Currently returns a placeholder instruction - implementation needed.
+     *
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number): Promise<TransactionInstruction[]>;
+    /**
+     * Creates a rebalance instruction for the USDC+ stablecoin.
+     * Currently returns an empty instruction, as the rebalance is unnecessary.
+     *
+     * @returns Promise resolving to an array containing a single, empty TransactionInstruction.
+     */
+    rebalance(): Promise<TransactionInstruction[]>;
+}

package/dist/stablecoins/UsdcPlusStablecoin.js

@@ -0,0 +1,197 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsdcPlusStablecoin = void 0;
+const Stablecoin_1 = require("../classes/Stablecoin");
+const web3_js_1 = require("@solana/web3.js");
+const classes_1 = require("../classes");
+const constants_1 = require("../constants");
+const reflect_main_1 = require("../generated/reflect_main");
+const sdk_1 = require("@drift-labs/sdk");
+const constants_2 = require("../constants");
+const ReflectTokenisedBond_1 = require("../classes/ReflectTokenisedBond");
+const spl_token_1 = require("@solana/spl-token");
+const __1 = require("..");
+const reflect_tokenised_bonds_1 = require("../generated/reflect_tokenised_bonds");
+/**
+ * USDC+ Stablecoin implementation for the Reflect protocol.
+ * Extends the base Stablecoin class to provide USDC-specific functionality
+ * including initialization, minting, redemption, and rebalancing operations.
+ */
+class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
+    /**
+     * Creates a new USDC+ Stablecoin instance.
+     *
+     * @param connection - Solana connection instance for RPC communication
+     * @param stablecoinMintOverride - Optional override for the stablecoin mint address
+     */
+    constructor(connection, stablecoinMintOverride) {
+        super(0, "USDC Money Market", connection, constants_2.USDC_PLUS_LOOKUP_TABLE);
+        this.collaterals = [{ mint: constants_1.USDC_MINT, oracle: "" }];
+        // Otherwise has to be loaded first.
+        if (stablecoinMintOverride)
+            this.stablecoinMint = stablecoinMintOverride;
+    }
+    /**
+     * Initializes the USDC stablecoin with the specified parameters.
+     * Creates receipt tokens, initializes vault, and initializes the stablecoin.
+     *
+     * @param signer - Public key of the signer/initializer
+     * @param mint - Public key of the mint to be used for the stablecoin
+     * @param cap - Maximum supply cap as a BN (Big Number)
+     * @param recipientAddresses - Array of recipient public keys for fee distribution
+     * @param recipientCuts - Array of fee cuts (percentages) corresponding to each recipient
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    initialize(signer, mint, cap, recipientAddresses, recipientCuts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vault = classes_1.PdaClient.deriveLpVault(0);
+            const lp = new ReflectTokenisedBond_1.ReflectTokenisedBond(this.connection);
+            const { instructions: receiptIx, signers: [receiptKeypair] } = yield lp.createReceiptToken(this.connection, signer, vault);
+            const vaultIx = yield lp.initializeVault(signer, mint, receiptKeypair.publicKey);
+            const ix = (0, reflect_main_1.createInitDriftControllerS1Instruction)({
+                admin: signer,
+                adminPermissions: classes_1.PdaClient.derivePermissions(signer),
+                main: classes_1.PdaClient.deriveMain(),
+                driftUsdcController: this.controller,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, {
+                mint,
+                cap,
+                recipientAddresses,
+                recipientCuts,
+                lpReciptMint: receiptKeypair.publicKey,
+                vault
+            }, reflect_main_1.PROGRAM_ID);
+            return [...receiptIx, vaultIx, ix];
+        });
+    }
+    /**
+     * Constructs the required accounts for the InitDriftControllerS1 instruction.
+     *
+     * @param signer - Public key of the signer
+     * @returns Promise resolving to the constructed accounts object of type T
+     */
+    constructAccounts(signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, this.controller);
+            const userStats = (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, this.controller);
+            const anchorRemainingAccounts = yield this.constructRemainingAccounts();
+            const { referrer } = yield (0, sdk_1.fetchUserStatsAccount)(this.connection, this.driftClient.program, userAccount);
+            const referrerUser = (0, sdk_1.getUserAccountPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, referrer);
+            const referrerUserStats = (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, referrer);
+            const userUsdcAta = (0, spl_token_1.getAssociatedTokenAddressSync)(this.controller, signer, true);
+            const vault = classes_1.PdaClient.deriveLpVault(0);
+            const { depositTokenMint: intermediaryMint, receiptTokenMint } = yield reflect_tokenised_bonds_1.Vault
+                .fromAccountAddress(this.connection, vault);
+            const userReceiptAta = (0, spl_token_1.getAssociatedTokenAddressSync)(receiptTokenMint, signer, true);
+            const controllerIntermediaryAta = (0, spl_token_1.getAssociatedTokenAddressSync)(intermediaryMint, this.controller, true);
+            const controllerReceiptAta = (0, spl_token_1.getAssociatedTokenAddressSync)(receiptTokenMint, this.controller, true);
+            const controllerUsdcAta = (0, spl_token_1.getAssociatedTokenAddressSync)(constants_1.USDC_MINT, this.controller, true);
+            const spotMarketVault = yield (0, sdk_1.getSpotMarketVaultPublicKey)(constants_1.DRIFT_PROGRAM_ID, 0);
+            const driftState = yield (0, sdk_1.getDriftStateAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID);
+            const vaultPool = classes_1.PdaClient.deriveLpVaultPool(0);
+            const accounts = {
+                clock: web3_js_1.SYSVAR_CLOCK_PUBKEY,
+                controllerIntermediaryAta,
+                controllerReceiptAta,
+                controllerUsdcAta,
+                drift: constants_1.DRIFT_PROGRAM_ID,
+                driftVault: constants_1.DRIFT_VAULT,
+                intermediaryMint,
+                lpPoolIntermediaryAta: vaultPool,
+                lpProgram: __1.TOKENISED_BONDS_PROGRAM_ID,
+                main: classes_1.PdaClient.deriveMain(),
+                receiptMint: receiptTokenMint,
+                referrerUser,
+                referrerUserStats,
+                spotMarketVault,
+                state: driftState,
+                usdcController: this.controller,
+                user: signer,
+                userAccount,
+                userReceiptAta,
+                userStats,
+                userUsdcAta,
+                vault,
+                adminPermissions: null,
+                anchorRemainingAccounts,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            };
+            return accounts;
+        });
+    }
+    /**
+     * Constructs remaining accounts for transactions.
+     * Currently returns an empty array as no additional accounts are needed.
+     *
+     * @returns Promise resolving to an empty array of AccountMeta objects
+     */
+    constructRemainingAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    ;
+    /**
+     * Creates a mint instruction for the USDC+ stablecoin.
+     *
+     * @param signer - Public key of the signer
+     * @param amount - Amount of USDC to deposit
+     * @param minimumReceived - Minimum amount of USDC+ stablecoins to receive (slippage protection)
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    mint(signer, amount, minimumReceived) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.constructAccounts(signer);
+            const ix = (0, reflect_main_1.createMintDriftS1Instruction)(accounts, {
+                minUsdcAmount: minimumReceived,
+                usdcAmount: amount
+            }, reflect_main_1.PROGRAM_ID);
+            return [ix];
+        });
+    }
+    /**
+     * Creates a redeem instruction for the USDC stablecoin.
+     * Currently returns a placeholder instruction - implementation needed.
+     *
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    redeem(signer, amount, minimumReceived) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.constructAccounts(signer);
+            const ix = (0, reflect_main_1.createRedeemDriftS1Instruction)(accounts, {
+                canChill: false,
+                minLstRedeem: minimumReceived,
+                rusdBurnAmount: amount
+            }, reflect_main_1.PROGRAM_ID);
+            return [ix];
+        });
+    }
+    /**
+     * Creates a rebalance instruction for the USDC+ stablecoin.
+     * Currently returns an empty instruction, as the rebalance is unnecessary.
+     *
+     * @returns Promise resolving to an array containing a single, empty TransactionInstruction.
+     */
+    rebalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = new web3_js_1.TransactionInstruction({
+                programId: web3_js_1.Keypair.generate().publicKey,
+                data: Buffer.from(""),
+                keys: []
+            });
+            return [ix];
+        });
+    }
+}
+exports.UsdcPlusStablecoin = UsdcPlusStablecoin;

package/dist/stablecoins/UsdjStablecoin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/stablecoins/UsdjStablecoin.js

@@ -0,0 +1,44 @@
+"use strict";
+// import {Stablecoin} from "../classes/Stablecoin";
+// import {PdaClient} from "../classes/PdaClient";
+// import {
+//     createInitDriftControllerS2Instruction,
+//     createMintDriftS2Instruction, 
+//     createRebalanceJlpInstruction,
+//     createRedeemDriftS2Instruction,
+//     createRedeem2DriftS2Instruction,
+//     DriftJlpController,
+//     MintDriftS2InstructionAccounts, PerpHedge,
+//     PROGRAM_ID
+// } from "../generated/reflect_main";
+// import {
+//     AccountMeta,
+//     Connection,
+//     Keypair,
+//     PublicKey,
+//     SystemProgram,
+//     Transaction,
+//     TransactionInstruction
+// } from "@solana/web3.js";
+// import {JLP_MINT, DRIFT_PROGRAM_ID, JUPITER_PROGRAM_ID, USDC_MINT} from "../constants";
+// import {getAccount, getAssociatedTokenAddressSync, getMint, TOKEN_PROGRAM_ID} from "@solana/spl-token";
+// import {
+//     getDriftSignerPublicKey,
+//     getDriftStateAccountPublicKey,
+//     getPerpMarketPublicKeySync,
+//     getSpotMarketPublicKey,
+//     getSpotMarketPublicKeySync, getSpotMarketVaultPublicKey,
+//     getUserAccountPublicKeySync,
+//     getUserStatsAccountPublicKey,
+//     PerpMarkets,
+//     SpotMarkets,
+//     MarginCategory,
+//     getTokenAmount,
+//     SpotBalanceType
+// } from "@drift-labs/sdk";
+// import BN, { min } from "bn.js";
+// import {AnchorProvider, Program} from "@coral-xyz/anchor";
+// import {type Perpetuals, IDL} from "../idl/perpetuals";
+// import NodeWallet from "@coral-xyz/anchor/dist/cjs/nodewallet";
+// import { JlpPoolInfo, JlpComponent } from "../types";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/stablecoins/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./JlpStablecoin";
+export * from "./UsdjStablecoin";
 export * from "./LstStablecoin";
-export * from "./UsdcStablecoin";
+export * from "./UsdcPlusStablecoin";

package/dist/stablecoins/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./JlpStablecoin"), exports);
+__exportStar(require("./UsdjStablecoin"), exports);
 __exportStar(require("./LstStablecoin"), exports);
-__exportStar(require("./UsdcStablecoin"), exports);
+__exportStar(require("./UsdcPlusStablecoin"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reflectmoney/stable.ts",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "author": "stablecoinjesus @ Palindrome Engineering",
   "repository": {