@reflectmoney/stable.ts 1.1.2 → 1.1.4

package/dist/classes/ApiClient.d.ts

@@ -0,0 +1,56 @@
+import { paths } from "../types/api";
+declare enum ApiEnvironment {
+    PROD = 0,
+    DEV = 1
+}
+declare class ApiClient {
+    private environment;
+    private url;
+    private supportedMarkets;
+    constructor(environment: ApiEnvironment);
+    private getUrl;
+    getHealth(): Promise<{
+        success: boolean;
+        message: string;
+        timestamp: string;
+    }>;
+    getSupportedMarkets(): Promise<string[]>;
+    getFundingRates(market: string, period: paths["/funding/rates"]["get"]["parameters"]["query"]["period"]): Promise<{
+        success: boolean;
+        data: import("../types/api").components["schemas"]["FundingRateData"][];
+        count: number;
+        period: "day" | "week" | "month" | "year";
+        market?: string;
+    }>;
+    getApySummaryForAllStrategies(strategy: paths["/apy"]["get"]["parameters"]["query"], historical: boolean): Promise<void>;
+    getApyForStrategy(strategy: paths["/apy/{strategy}"]["get"]["parameters"]["query"], historical: boolean): Promise<({
+        success: boolean;
+    } & {
+        data: import("../types/api").components["schemas"]["UsdcApyData"];
+    }) | ({
+        success: boolean;
+    } & {
+        data: import("../types/api").components["schemas"]["JlpApyData"];
+    }) | ({
+        success: boolean;
+    } & {
+        data: import("../types/api").components["schemas"]["LstApyData"];
+    })>;
+    getSupplyCapInfo(): Promise<{
+        success: boolean;
+        data: {
+            0?: import("../types/api").components["schemas"]["SupplyCapInfo"];
+            2?: import("../types/api").components["schemas"]["SupplyCapInfo"];
+        };
+    }>;
+    getStablecoinList(): Promise<{
+        success: boolean;
+        data: {
+            index: number;
+            name: string;
+        }[];
+    }>;
+    getStablecoinHoldersForStrategy(): Promise<void>;
+    getExchangeRateForStablecoin(): Promise<void>;
+}
+export { ApiClient };

package/dist/classes/PdaClient.d.ts

@@ -0,0 +1,131 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Utility class for deriving Program Derived Addresses (PDAs) used throughout the Reflect protocol.
+ * Provides static methods to generate deterministic addresses for various program accounts
+ * including main program accounts, controllers, permissions, and external protocol integrations.
+ */
+export declare class PdaClient {
+    /**
+     * Derives the main program account address.
+     * This is the primary account that stores global protocol state.
+     *
+     * @returns PublicKey of the main program account
+     */
+    static deriveMain(): PublicKey;
+    /**
+     * Derives the permissions account address for a specific user.
+     * This account stores the user's role-based permissions within the protocol.
+     *
+     * @param user - Public key of the user
+     * @returns PublicKey of the user's permissions account
+     */
+    static derivePermissions(user: PublicKey): PublicKey;
+    /**
+     * Derives the controller account address for a specific strategy.
+     * Each stablecoin strategy has its own controller account.
+     *
+     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
+     * @returns PublicKey of the strategy controller account
+     */
+    static deriveController(strategy: number): PublicKey;
+    /**
+     * Derives the controller account address with bump seed for a specific strategy.
+     * Returns both the public key and the bump seed.
+     *
+     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
+     * @returns Array containing [PublicKey, number] where number is the bump seed
+     */
+    static deriveControllerWithBump(strategy: number): [PublicKey, number];
+    /**
+     * Derives the rebalance details account address for a specific strategy.
+     * This account stores information about rebalancing operations.
+     *
+     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
+     * @returns PublicKey of the rebalance details account
+     */
+    static deriveRebalanceDetails(strategy: number): PublicKey;
+    /**
+     * Derives the Jupiter Perpetuals program account address.
+     * Used for integration with Jupiter's perpetuals protocol.
+     *
+     * @returns PublicKey of the Jupiter Perpetuals account
+     */
+    static deriveJupiterPerpetuals(): PublicKey;
+    /**
+     * Derives the Jupiter LP pool account address.
+     * Used for JLP (Jupiter LP) token operations.
+     *
+     * @returns PublicKey of the JLP pool account
+     */
+    static deriveJlpPool(): PublicKey;
+    /**
+     * Derives the Jupiter event authority account address.
+     * Used for event emission in Jupiter protocol interactions.
+     *
+     * @returns PublicKey of the Jupiter event authority account
+     */
+    static deriveEventAuthority(): PublicKey;
+    /**
+     * Derives the Jupiter transfer authority account address.
+     * Used for token transfer operations in Jupiter protocol.
+     *
+     * @returns PublicKey of the Jupiter transfer authority account
+     */
+    static deriveTransferAuthority(): PublicKey;
+    /**
+     * Gets the Drift vault address for a specific mint.
+     * Looks up the market index for the mint and derives the corresponding vault address.
+     *
+     * @param mint - Public key of the token mint
+     * @returns Promise resolving to the PublicKey of the Drift vault account
+     */
+    static getDriftVaultFromMint(mint: PublicKey): Promise<PublicKey>;
+    /**
+     * Derives the token metadata account address for a mint.
+     * Used for storing token metadata information.
+     *
+     * @param mint - Public key of the token mint
+     * @returns PublicKey of the metadata account
+     */
+    static deriveMetadataAccount(mint: PublicKey): PublicKey;
+    /**
+     * Derives the custody account address for a pool and token combination.
+     * Used in Jupiter protocol for token custody management.
+     *
+     * @param pool - Public key of the pool
+     * @param token - Public key of the token
+     * @returns PublicKey of the custody account
+     */
+    static deriveCustody(pool: PublicKey, token: PublicKey): PublicKey;
+    /**
+     * Derives the LP config account address.
+     * Used for tokenized bonds program configuration.
+     *
+     * @returns PublicKey of the LP config account
+     */
+    static deriveLpConfig(): PublicKey;
+    /**
+     * Derives the LP admin account address for a specific admin.
+     * Used for tokenized bonds program administration.
+     *
+     * @param admin - Public key of the admin
+     * @returns PublicKey of the LP admin account
+     */
+    static deriveLpAdmin(admin: PublicKey): PublicKey;
+    /**
+     * Derives the LP vault account address for a specific vault ID.
+     * Used for tokenized bonds vault management.
+     *
+     * @param vaultId - Numeric identifier for the vault
+     * @returns PublicKey of the LP vault account
+     */
+    static deriveLpVault(vaultId: number): PublicKey;
+    /**
+     * Derives the LP vault pool account address for a specific vault ID.
+     * Used for tokenized bonds vault pool management.
+     *
+     * @param vaultId - Numeric identifier for the vault
+     * @returns PublicKey of the LP vault pool account
+     */
+    static deriveLpVaultPool(vaultId: number): PublicKey;
+}

package/dist/classes/Reflect.d.ts

@@ -0,0 +1,7 @@
+import { Connection } from "@solana/web3.js";
+import { Main } from "../generated/reflect_main";
+export declare class Reflect {
+    connection: Connection;
+    constructor(connection: Connection);
+    fetchMain(): Promise<Main>;
+}

package/dist/classes/ReflectKeeper.d.ts

@@ -0,0 +1,105 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Action, Role, Update, UserPermissions } 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 ReflectKeeper {
+    /** 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 ReflectKeeper 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;
+    getPermissionAccount(): Promise<UserPermissions>;
+    /**
+     * 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/ReflectTokenisedBond.d.ts

@@ -0,0 +1,75 @@
+import { Connection } from "@solana/web3.js";
+import { Vault } from "../generated/reflect_tokenised_bonds";
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import { Keypair } from "@solana/web3.js";
+/**
+ * Client class for interacting with the Reflect Tokenised Bonds program.
+ * Provides functionality for creating and managing tokenized bond vaults,
+ * including receipt token creation, vault initialization, deposits, and withdrawals.
+ *
+ * This class handles the tokenized bonds aspect of the Reflect protocol,
+ * allowing users to deposit assets and receive receipt tokens representing
+ * their share of the vault.
+ */
+export declare class ReflectTokenisedBond {
+    /** Solana connection instance for RPC communication */
+    connection: Connection;
+    /**
+     * Creates a new ReflectTokenisedBond instance.
+     *
+     * @param connection - Solana connection instance
+     */
+    constructor(connection: Connection);
+    /**
+     * Creates a receipt token for a vault.
+     * Generates a new keypair for the receipt token mint and creates the necessary instructions.
+     *
+     * @param connection - Solana connection instance
+     * @param signer - Public key of the transaction signer
+     * @param vault - Public key of the vault account
+     * @returns Promise resolving to an object containing instructions and signers
+     */
+    createReceiptToken(decimals: number, connection: Connection, signer: PublicKey, vault: PublicKey): Promise<{
+        instructions: import("@solana/web3.js").TransactionInstruction[];
+        signers: Keypair[];
+    }>;
+    /**
+     * Initializes the tokenized bonds program.
+     * Creates the config and admin accounts for the program.
+     *
+     * @param signer - Public key of the admin signer
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    initialize(signer: PublicKey): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Initializes a new vault with specified deposit and receipt mints.
+     *
+     * @param signer - Public key of the admin signer
+     * @param depositMint - Public key of the deposit token mint
+     * @param receiptMint - Public key of the receipt token mint
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    initializeVault(signer: PublicKey, depositMint: PublicKey, receiptMint: PublicKey): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Creates a deposit instruction for a vault.
+     * Allows users to deposit assets and receive receipt tokens.
+     *
+     * @param signer - Public key of the user making the deposit
+     * @param vaultId - Numeric identifier for the vault
+     * @param amount - Amount of deposit tokens to deposit
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    deposit(signer: PublicKey, vaultId: number, amount: BN): Promise<import("@solana/web3.js").TransactionInstruction>;
+    /**
+     * Creates a withdrawal instruction for a vault.
+     * Allows users to burn receipt tokens and receive back their deposit tokens.
+     *
+     * @param signer - Public key of the user making the withdrawal
+     * @param vaultId - Numeric identifier for the vault
+     * @param amount - Amount of receipt tokens to burn for withdrawal
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    withdraw(signer: PublicKey, vaultId: number, amount: BN): Promise<import("@solana/web3.js").TransactionInstruction>;
+    getVault(vaultId: number): Promise<Vault>;
+}

package/dist/classes/Stablecoin.d.ts

@@ -0,0 +1,219 @@
+import { AccountMeta, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import BN from "bn.js";
+import { DriftClient } from "@drift-labs/sdk";
+import { Action, Strategy } from "../generated/reflect_main";
+import { StablecoinMetadata, Collateral, Controller, MintContext, PythResponse } from "../types";
+/**
+ * Abstract base class for all stablecoin implementations in the Reflect protocol.
+ * Provides common functionality for managing stablecoins including initialization,
+ * minting, redemption, rebalancing, and administrative operations.
+ *
+ * This class serves as the foundation for different stablecoins:
+ * - USDC+ (Index 0): Stablecoin backed by USDC deployed in money markets
+ * - JLP Hedged (Index 1): JLP token hedged with perpetual positions
+ * - LST Delta-Neutral (Index 2): Stablecoin backed by LSTs and delta-neutral strategies
+ */
+export declare abstract class Stablecoin<T extends Controller> {
+    /** Unique index identifier for the stablecoin */
+    index: number;
+    /** Human-readable name of the stablecoin */
+    name: string;
+    /** Solana connection instance for communication */
+    connection: Connection;
+    /** Public key of the controller account for this stablecoin */
+    controllerKey: PublicKey;
+    /** Public key of the controller account for this stablecoin */
+    controller: T;
+    /** Public key of the controller account for this stablecoin */
+    strategy: Strategy;
+    /** Array of collateral assets backing this stablecoin */
+    collaterals: Collateral[];
+    /** Public key of the stablecoin mint */
+    stablecoinMint: PublicKey;
+    /** Optional Drift client instance for DeFi operations */
+    driftClient?: DriftClient;
+    /** Lookup table with stablecoin-specific accounts. */
+    lookupTable: PublicKey;
+    /**
+     * Loads the controller account for this stablecoin.
+     *
+     * @returns Promise resolving to void, sets the controller and strategy fields
+     */
+    load(schema: {
+        fromAccountAddress: (connection: Connection, key: PublicKey) => Promise<T>;
+    }): Promise<void>;
+    buildLookupTables<T extends MintContext>(signer: PublicKey): Promise<{
+        instructions: TransactionInstruction[];
+        lookupTable: PublicKey;
+    }>;
+    setLookupTable(address: PublicKey): void;
+    /**
+     * Creates a new Stablecoin instance.
+     *
+     * @param index - Unique strategy index (0: USDC+, 1: JLP, 2: LST)
+     * @param name - Human-readable name for the stablecoin
+     * @param connection - Solana connection instance
+     */
+    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.
+     *
+     * @param owner - Public key of the token account owner
+     * @param mints - Array of mint public keys to create accounts for
+     * @param signer - Public key of the transaction signer
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    initializeTokenAccounts(owner: PublicKey, mints: PublicKey[], signer: PublicKey): Promise<TransactionInstruction[]>;
+    /**
+     * Updates the supply cap for this stablecoin strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param newCap - New maximum supply cap as BN or number
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateCap(signer: PublicKey, newCap: BN | number): Promise<TransactionInstruction>;
+    /**
+     * Updates the recipient addresses and their fee cuts for this stablecoin.
+     *
+     * @param signer - Public key of the admin signer
+     * @param recipients - Map of recipient public keys to their fee (in basepoints)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateRecipients(signer: PublicKey, recipients: Map<PublicKey, number>): Promise<TransactionInstruction>;
+    /**
+     * Initializes a Drift sub-account for this stablecoin controller.
+     *
+     * @param signer - Public key of the admin signer
+     * @param subAccountId - Sub-account identifier (default: 0)
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    initializeStablecoinDriftAccount(signer: PublicKey, subAccountId?: number): Promise<TransactionInstruction>;
+    /**
+     * Initializes the Drift user stats account for this stablecoin controller.
+     *
+     * @param signer - Public key of the admin signer
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    initializeStablecoinDriftStatsAccount(signer: PublicKey): Promise<TransactionInstruction>;
+    /**
+     * Freezes or unfreezes a specific action for this stablecoin strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param freeze - Whether to freeze (true) or unfreeze (false) the action
+     * @param action - The action to freeze/unfreeze
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    freeze(signer: PublicKey, freeze: boolean, action: Action): Promise<TransactionInstruction>;
+    /**
+     * Initializes the stablecoin mint with optional metadata.
+     *
+     * @param signer - Public key of the admin signer
+     * @param tokenKeypair - Keypair for the new mint account
+     * @param metadata - Optional metadata for the stablecoin
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    initializeStablecoin(signer: PublicKey, tokenKeypair: Keypair, metadata?: StablecoinMetadata): Promise<TransactionInstruction[]>;
+    /**
+     * Updates the rebalance slippage tolerance for this stablecoin strategy.
+     *
+     * @param signer - Public key of the admin signer
+     * @param slippage - New slippage tolerance value
+     * @returns Promise resolving to a TransactionInstruction
+     */
+    updateRebalanceSlippage(signer: PublicKey, slippage: number): Promise<TransactionInstruction>;
+    /**
+     * Fetches the current price of a collateral asset from Pyth oracle.
+     *
+     * @param mint - Public key of the collateral mint
+     * @returns Promise resolving to the collateral price data
+     */
+    getCollateralPrice(mint: PublicKey): Promise<import("axios").AxiosResponse<PythResponse, any>>;
+    /**
+     * Converts a stablecoin amount to the equivalent collateral amount, factoring in slippage (in bips).
+     * All math is done using BN for safety.
+     * @param amount Amount of stablecoin (BN)
+     * @param collateralMint Collateral mint PublicKey
+     * @param slippageBips Slippage in bips (1 bip = 0.01%, e.g. 50 = 0.5%)
+     * @returns Promise resolving to the collateral amount (BN)
+     */
+    stablecoinToCollateralWithSlippage(amount: BN, collateralMint: PublicKey, slippageBips: number): Promise<BN>;
+    /**
+     * Converts a collateral amount to the equivalent stablecoin amount, factoring in slippage (in bips).
+     * All math is done using BN for safety.
+     * @param amount Amount of collateral (BN)
+     * @param collateralMint Collateral mint PublicKey
+     * @param slippageBips Slippage in bips (1 bip = 0.01%, e.g. 50 = 0.5%)
+     * @returns Promise resolving to the stablecoin amount (BN)
+     */
+    collateralToStablecoinWithSlippage(amount: BN, collateralMint: PublicKey, slippageBips: number): Promise<BN>;
+    /**
+     * Abstract method to construct required accounts for transactions.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param signer - Public key of the transaction signer
+     * @param args - Additional arguments specific to the stablecoin implementation
+     * @returns Promise resolving to the constructed accounts object of type T
+     */
+    abstract constructAccounts<T extends MintContext>(signer: PublicKey, ...args: any[]): Promise<T>;
+    /**
+     * Abstract method to construct remaining accounts for transactions.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @returns Promise resolving to an array of AccountMeta objects
+     */
+    abstract constructRemainingAccounts(): Promise<AccountMeta[]>;
+    /**
+     * Abstract method to initialize the stablecoin strategy.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param signer - Public key of the admin signer
+     * @param args - Additional arguments specific to the stablecoin implementation
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    abstract initialize(signer: PublicKey, ...args: any[]): Promise<TransactionInstruction[]>;
+    /**
+     * Abstract method to create mint instructions for the stablecoin.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param signer - Public key of the user minting stablecoins
+     * @param amount - Amount of stablecoins to mint
+     * @param minimumReceived - Minimum amount of stablecoins to receive (slippage protection)
+     * @param args - Additional arguments specific to the stablecoin implementation
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    abstract mint(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
+    /**
+     * Abstract method to create redeem instructions for the stablecoin.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param signer - Public key of the user redeeming stablecoins
+     * @param amount - Amount of stablecoins to redeem
+     * @param minimumReceived - Minimum amount of collateral to receive (slippage protection)
+     * @param args - Additional arguments specific to the stablecoin implementation
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    abstract redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
+    /**
+     * Abstract method to create rebalance instructions for the stablecoin.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param signer - Public key of the admin signer
+     * @returns Promise resolving to an array of TransactionInstruction objects
+     */
+    abstract rebalance(signer: PublicKey): Promise<TransactionInstruction[]>;
+    /**
+     * Abstract method to get the USD exchange rate for the base collateral of the stablecoin.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @returns Promise resolving to the USD exchange rate as a number
+     */
+    abstract getBaseUsdExchangeRate(): Promise<number>;
+    /**
+     * Abstract method to get the USD exchange rate for the receipt token of the stablecoin.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @returns Promise resolving to the USD exchange rate as a number
+     */
+    abstract getReceiptUsdExchangeRate(): Promise<number>;
+}

package/dist/classes/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ReflectKeeper";
+export * from "./PdaClient";
+export * from "./Stablecoin";
+export * from "./Reflect";

package/dist/constants/drift.d.ts

@@ -0,0 +1,6 @@
+import { PublicKey } from "@solana/web3.js";
+declare const DRIFT_VAULT: PublicKey;
+declare const DRIFT_PROGRAM_ID: PublicKey;
+declare const REFERRAL_USER: PublicKey;
+declare const REFERRAL_USER_STATS: PublicKey;
+export { DRIFT_VAULT, REFERRAL_USER, REFERRAL_USER_STATS, DRIFT_PROGRAM_ID };

package/dist/constants/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./usdc";
+export * from "./drift";
+export * from "./wsol";
+export * from "./jupiter";
+export * from "./pyth";
+export * from "./lst";
+export * from "./lookupTables";
+export declare const EXCHANGE_RATE_PRECISION = 10000;

package/dist/constants/jupiter.d.ts

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

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/lst.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+declare const JITO_SOL_MINT: PublicKey;
+export { JITO_SOL_MINT };

package/dist/constants/pyth.d.ts

@@ -0,0 +1 @@
+export declare const PYTH_API_URL = "https://hermes.pyth.network/api/latest_price_feeds?ids[]=";

package/dist/constants/usdc.d.ts

@@ -0,0 +1,6 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const USDC_MINT: PublicKey;
+export declare const USDC_PUSH_ORACLE: PublicKey;
+export declare const USDC_PULL_ORACLE: PublicKey;
+export declare const USDC_SPOT_MARKET: PublicKey;
+export declare const USDC_DRIFT_VAULT: PublicKey;

package/dist/constants/wsol.d.ts

@@ -0,0 +1,6 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const WSOL_PUSH_ORACLE: PublicKey;
+export declare const WSOL_PULL_ORACLE: PublicKey;
+export declare const WSOL_SPOT_MARKET: PublicKey;
+export declare const WSOL_PERP_MARKET: PublicKey;
+export declare const WSOL_MINT: PublicKey;

package/dist/errors/ReflectError.d.ts

@@ -0,0 +1,4 @@
+declare class ReflectError extends Error {
+    constructor(msg: string);
+}
+export default ReflectError;