@reflectmoney/stable.ts 2.9.1 → 3.0.1

package/dist/classes/Stablecoin.d.ts

@@ -1,222 +1,188 @@
-import { AccountMeta, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { Address, TransactionSigner, Rpc, SolanaRpcApi, Instruction } from "@solana/kit";
 import BN from "bn.js";
-import { DriftClient } from "@drift-labs/sdk";
-import { Action, Strategy } from "../generated/reflect_main";
-import { RawMint } from "@solana/spl-token";
-import { StablecoinMetadata, Collateral, Controller, MintContext, PythResponse } from "../types";
+import { Collateral, PythResponse } from "../types";
+import { Controller } from "../types";
+/**
+ * Strategy interface - common fields for all strategy controllers.
+ * This maps to the generated Base type but with Address for mint.
+ */
+export interface Strategy {
+    mint: Address;
+    bump: number;
+    index: number;
+    cap: bigint;
+}
 /**
  * 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;
+    /** Solana RPC instance for communication */
+    rpc: Rpc<SolanaRpcApi>;
+    /** Address of the controller account for this stablecoin */
+    controllerKey: Address | null;
+    /** Controller account data */
+    controller: T | null;
     /** Array of collateral assets backing this stablecoin */
     collaterals: Collateral[];
-    /** Public key of the stablecoin mint */
-    stablecoinMint: PublicKey;
+    /** Address of the stablecoin mint */
+    stablecoinMint: Address | null;
     /** Data of the stablecoin mint */
-    stablecoinMintData: RawMint;
-    /** Optional Drift client instance for DeFi operations */
-    driftClient?: DriftClient;
+    stablecoinMintSupply: bigint;
+    stablecoinMintDecimals: number;
     /** Lookup table with stablecoin-specific accounts. */
-    lookupTable: PublicKey;
+    lookupTable: Address;
     isPermissioned: boolean;
-    devnet?: boolean;
+    /** Whether to use devnet program */
+    devnet: boolean;
+    /** Whether to use mock program on mainnet (only applies when devnet=false) */
+    mock: boolean;
     /**
-     * Loads the controller account for this stablecoin.
-     *
-     * @returns Promise resolving to void, sets the controller and strategy fields
+     * Get the program address based on network configuration.
+     * - devnet=true → devnet program
+     * - devnet=false, mock=true → mock program on mainnet
+     * - devnet=false, mock=false → production mainnet program
+     */
+    get programAddress(): Address;
+    /**
+     * Initialize the stablecoin by deriving the controller key
      */
-    load(schema?: {
-        fromAccountAddress: (connection: Connection, key: PublicKey) => Promise<T>;
-    }): Promise<void>;
-    loadMint(): Promise<void>;
-    get programId(): PublicKey;
-    buildLookupTables<T extends MintContext>(signer: PublicKey): Promise<{
-        instructions: TransactionInstruction[];
-        lookupTable: PublicKey;
-    }>;
-    setLookupTable(address: PublicKey): void;
+    initializeKeys(): Promise<void>;
     getController(): T;
-    getStrategy(): Strategy;
-    getStablecoinMint(): PublicKey;
-    getStablecoinMintData(): RawMint;
-    getLookupTable(): PublicKey;
+    getStablecoinMint(): Address;
+    getLookupTable(): Address;
+    setLookupTable(addressVal: Address): void;
     /**
      * Creates a new Stablecoin instance.
      *
-     * @param index - Unique strategy index (0: USDC+, 1: JLP, 2: LST)
+     * @param index - Unique strategy index (0: USDC+, 1: USDT+)
      * @param name - Human-readable name for the stablecoin
-     * @param connection - Solana connection instance
+     * @param rpc - Solana RPC instance
+     * @param lookupTable - Address of the lookup table
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
      */
-    constructor(index: number, name: string, connection: Connection, lookupTable: PublicKey, devnet?: boolean);
-    /**
-     * 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[]>;
+    constructor(index: number, name: string, rpc: Rpc<SolanaRpcApi>, lookupTable: Address, devnet?: boolean, mock?: boolean);
     /**
      * 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
+     * @param admin - TransactionSigner of the admin
+     * @param newCap - New maximum supply cap
+     * @returns Instruction
      */
-    updateCap(signer: PublicKey, newCap: BN | number): Promise<TransactionInstruction>;
+    updateCap(admin: TransactionSigner, newCap: bigint | number): Promise<import("../generated/reflect_main").UpdateCapInstruction<Address, string, string, string, string, string, []>>;
     /**
      * 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
+     * @param admin - TransactionSigner of the admin
+     * @param recipientAddresses - Array of recipient addresses for fee distribution
+     * @param recipientCuts - Array of recipient cuts (u16 values, total must equal 10000)
+     * @returns Instruction
      */
-    updateRecipients(signer: PublicKey, recipients: Map<PublicKey, number>): Promise<TransactionInstruction>;
+    updateRecipients(admin: TransactionSigner, recipientAddresses: Address[], recipientCuts: number[]): Promise<import("../generated/reflect_main").UpdateRecipientsInstruction<Address, string, string, string, string, string, []>>;
     /**
-     * Initializes a Drift sub-account for this stablecoin controller.
+     * Initializes a Drift user account for this stablecoin controller.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @param subAccountId - Sub-account identifier (default: 0)
-     * @returns Promise resolving to a TransactionInstruction
+     * @returns Instruction
      */
-    initializeStablecoinDriftAccount(signer: PublicKey, subAccountId?: number): Promise<TransactionInstruction>;
+    initializeStablecoinDriftAccount(admin: TransactionSigner, subAccountId?: number): Promise<import("../generated/reflect_main").CreateDriftUserAccountInstruction<Address, string, string, string, string, string, string, string, string, string, string, []>>;
     /**
      * Initializes the Drift user stats account for this stablecoin controller.
      *
-     * @param signer - Public key of the admin signer
-     * @returns Promise resolving to a TransactionInstruction
+     * @param admin - TransactionSigner of the admin
+     * @returns Instruction
      */
-    initializeStablecoinDriftStatsAccount(signer: PublicKey): Promise<TransactionInstruction>;
+    initializeStablecoinDriftStatsAccount(admin: TransactionSigner): Promise<import("../generated/reflect_main").CreateDriftUserStatsAccountInstruction<Address, string, string, string, string, string, string, string, string, string, []>>;
     /**
      * Freezes or unfreezes a specific action for this stablecoin strategy.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @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
+     * @param action - The action to freeze/unfreeze (as u8)
+     * @returns Instruction
      */
-    initializeStablecoin(signer: PublicKey, tokenKeypair: Keypair, metadata?: StablecoinMetadata): Promise<TransactionInstruction[]>;
+    freeze(admin: TransactionSigner, freeze: boolean, action: number): Promise<import("../generated/reflect_main").FreezeStrategyActionInstruction<Address, string, string, string, string, string, []>>;
     /**
      * Fetches the current price of a collateral asset from Pyth oracle.
      *
-     * @param mint - Public key of the collateral mint
+     * @param mint - Address of the collateral mint
      * @returns Promise resolving to the collateral price data
      */
-    getCollateralPrice(mint: PublicKey): Promise<import("axios").AxiosResponse<PythResponse, any, {}>>;
+    getCollateralPrice(mint: Address): 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 collateralMint Collateral mint Address
      * @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>;
+    stablecoinToCollateralWithSlippage(amount: BN, collateralMint: Address, 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 collateralMint Collateral mint Address
      * @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>;
+    collateralToStablecoinWithSlippage(amount: BN, collateralMint: Address, 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.
+     * Loads the controller account for this stablecoin.
      * Must be implemented by concrete stablecoin classes.
-     *
-     * @returns Promise resolving to an array of AccountMeta objects
      */
-    abstract constructRemainingAccounts(): Promise<AccountMeta[]>;
+    abstract load(): Promise<void>;
     /**
      * Abstract method to initialize the stablecoin strategy.
      * Must be implemented by concrete stablecoin classes.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @param args - Additional arguments specific to the stablecoin implementation
-     * @returns Promise resolving to an array of TransactionInstruction objects
+     * @returns Promise resolving to an array of Instructions
      */
-    abstract initialize(signer: PublicKey, ...args: any[]): Promise<TransactionInstruction[]>;
+    abstract initialize(admin: TransactionSigner, ...args: any[]): Promise<Instruction[]>;
     /**
      * 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 user - TransactionSigner of the user minting stablecoins
+     * @param amount - Amount of collateral to deposit
      * @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
+     * @returns Promise resolving to an array of Instructions
      */
-    abstract mint(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
+    abstract mint(user: TransactionSigner, amount: bigint | number, minimumReceived: bigint | number, ...args: any[]): Promise<Instruction[]>;
     /**
      * 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 user - TransactionSigner 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
+     * @returns Promise resolving to an array of Instructions
      */
-    abstract redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
+    abstract redeem(user: TransactionSigner, amount: bigint | number, minimumReceived: bigint | number, ...args: any[]): Promise<Instruction[]>;
     /**
      * 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
+     * @param admin - TransactionSigner of the admin
+     * @returns Promise resolving to an array of Instructions
      */
-    abstract rebalance(signer: PublicKey): Promise<TransactionInstruction[]>;
+    abstract rebalance(admin: TransactionSigner): Promise<Instruction[]>;
     /**
-     * Abstract method to get the USD exchange rate for the base collateral of the stablecoin.
-     * Must be implemented by concrete stablecoin classes.
-     *
+     * Abstract method to get the USD exchange rate for the base collateral.
      * @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.
-     *
+     * Abstract method to get the USD exchange rate for the receipt token.
      * @returns Promise resolving to the USD exchange rate as a number
      */
     abstract getReceiptUsdExchangeRate(): Promise<number>;
@@ -232,25 +198,19 @@ export declare abstract class Stablecoin<T extends Controller> {
     abstract getReceiptToCollateralExchangeRate(): Promise<number>;
     /**
      * Abstract method to simulate mint math and get the quote for a mint operation.
-     * Must be implemented by concrete stablecoin classes.
-     *
-     * @param amount - Amount of base tokens (e.g., USDC) to deposit
+     * @param amount - Amount of base tokens to deposit
      * @returns Promise resolving to the amount of receipt tokens that would be minted
      */
     abstract simulateMintMath(amount: BN): Promise<BN>;
     /**
      * Abstract method to simulate redeem math and get the quote for a redeem operation.
-     * Must be implemented by concrete stablecoin classes.
-     *
      * @param amount - Amount of receipt tokens to redeem
      * @returns Promise resolving to the amount of base tokens that would be returned
      */
     abstract simulateRedeemMath(amount: BN): Promise<BN>;
     /**
      * Abstract method to cleanup the stablecoin.
-     * Must be implemented by concrete stablecoin classes.
      * Used to unsubscribe all connections to websockets.
-     *
      * @returns Promise resolving to void
      */
     abstract cleanup(): Promise<void>;