@reflectmoney/stable.ts 1.0.1 → 1.0.3

package/README.md

@@ -1,14 +1,22 @@
-# Reflect Money Stable.ts SDK
+# @reflectmoney/stable.ts | Reflect 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, neutralised with perpetual hedging strategies
+3. **LST Delta-Neutral (Index 2)**: Stablecoin backed by LSTs hedged by perpetual futures position
 
 ## Architecture
 
@@ -17,148 +25,164 @@ The SDK is organized into several key components:
 ### Core Classes
 
 #### `Stablecoin` (Abstract Base Class)
-The foundation for all stablecoin implementations. Provides common interface for:
+The foundation for all stablecoin implementations. Provides abstract functions and common interface for:
 - minting,
 - redemption,
 - administrative operations.
 
 **Key Methods:**
-- `initialize()` - Initialize the stablecoin strategy (admin-only)
+- `initialize()` - Initialize and set-up the stablecoin (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)
 
-#### `ReflectAdmin`
-Administrative client for protocol-level operations:
+#### `ReflectKeeper`
+Administrative client for protocol-level operations (admin-only):
 - Protocol initialization
 - Role and permission management
 - Action freezing/unfreezing
 - Admin account creation
 
 **Key Methods:**
-- `initializeMain()` - Initialize the main program account
+- `initializeMain()` - Initialize the main account with the program configuration
 - `freezeProtocolAction()` - Freeze/unfreeze protocol actions
 - `updateRoleHolderProtocol()` - Update protocol-level permissions
-- `createAdminAccount()` - Create new admin accounts
+- `createAdminAccount()` - Manage admin accounts
 
 #### `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, Tokenised Bond)
 
 #### `ReflectTokenisedBond`
-Client for tokenized bonds program, allowing for wrapping base stablecoins into yield-bearing receipts. Allows for:
+Client for 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:
+- Live
 - Strategy ID: 0
 - Collateral: USDC
-- Integrated with tokenised bonds program on the protocol level
+- Integrated with tokenised bonds program on the protocol level. 
+- Users only receive the yield-bearing stablecoin.
+- Doesn't require rebalancing, as hedge is always preserved.
 
-#### `JlpStablecoin`
-Jupiter LP token with perpetual hedging:
+#### `UsdjStablecoin`
+Stablecoin backed by JLP neutralised with perpetual hedging:
+- Coming soon
 - Strategy ID: 1
 - Collateral: JLP (Jupiter LP tokens)
+- Requires manual wrapping via the Tokenised Bonds program.
+- Requires rebalancing, currently permissioned.
+
 
 #### `LstStablecoin`
 Liquid staking token delta-neutral strategy:
+- Live
 - Strategy ID: 2
-- Collateral: Various LSTs (mSOL, jitoSOL, etc.)
+- Collateral: Various LSTs (mSOL, jitoSOL, etc.) - use `load()` functionality to fetch currently supported list of collateral assets.
+- Requires manual wrapping via the Tokenised Bonds program.
+- Requires rebalancing, currently permissioned.
 
-## Installation
+## Usage
 
-```bash
-npm install @reflectmoney/stable.ts
-# or
-yarn add @reflectmoney/stable.ts
+Follow 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:
+```typescript
+const stablecoin = new UsdcPlusStablecoin(connection);
+const stablecoin = new UsdjStablecoin(connection);
+const stablecoin = new LstStablecoin(connection);
 ```
 
-## Quick Start
-
 ### Minting Stablecoins
 
 ```typescript
-import { LstStablecoin } from '@reflectmoney/stable.ts';
+import { UsdcPlusStablecoin } from '@reflectmoney/stable.ts';
 import { PublicKey } 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
-await lstStablecoin.load(connection);
+// Load controller data for most up-to-date stablecoin setup.
+await stablecoin.load(connection);
 
 // Mint stablecoins against LST collateral
-const mintInstructions = await lstStablecoin.mint(
+const instructions = await stablecoin.mint(
     userPublicKey,
-    new BN(1000000), // 1 USDC (6 decimals)
-    new BN(999000),  // Minimum received (slippage protection)
-    new PublicKey("<jitoSOL mint>") // LST mint address
+    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)
 );
+
+const { blockhash } = await connection.getLatestBlockhash();
+
+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 landing 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 } 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 most up-to-date stablecoin setup.
+await stablecoin.load(connection);
 
-// Update supply cap
-const updateCapIx = await usdcStablecoin.updateCap(adminPublicKey, new BN(1000000000));
-```
+// Redeems USDC+ into USDC
+const instructions = await stablecoin.redeem(
+    userPublicKey,
+    new BN(999 * 1_000_000), // Burn 1,000 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 landing logic, adjust for your needs.
+transaction.sign([user]);
+await connection.sendRawTransaction(transaction.serialize());
 ```
 
 ### Integration with External Protocols

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