@reflectmoney/stable.ts 2.9.1 → 3.0.1

package/dist/stablecoins/UsdcPlusStablecoinLegacy.d.ts

@@ -0,0 +1,97 @@
+import { Address, TransactionSigner, Rpc, SolanaRpcApi, Instruction } from "@solana/kit";
+import { Stablecoin } from "../classes/Stablecoin";
+import { type DriftUsdcController } from "../generated/reflect_main/accounts";
+import BN from "bn.js";
+/**
+ * Legacy USDC+ Stablecoin implementation for the Reflect protocol.
+ *
+ * This class uses the legacy DriftUsdcController account type and mint/redeem
+ * instructions (mintDriftS1/redeemDriftS1) that were used before the program migration.
+ * These instructions interact directly with Drift and require many more accounts.
+ *
+ * Use this class for programs that have NOT been migrated yet.
+ * After migration, use the regular UsdcPlusStablecoin class instead.
+ *
+ * Strategy ID: 0
+ * Collateral: USDC
+ *
+ * Environment handling:
+ * - devnet=true → Uses devnet program
+ * - devnet=false, mock=true → Uses mock program on mainnet
+ * - devnet=false, mock=false → Uses production mainnet program
+ */
+export declare class UsdcPlusStablecoinLegacy extends Stablecoin<DriftUsdcController> {
+    /**
+     * Creates a new Legacy USDC+ Stablecoin instance.
+     *
+     * @param rpc - Solana RPC instance
+     * @param stablecoinMintOverride - Optional override for the stablecoin mint address
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
+     */
+    constructor(rpc: Rpc<SolanaRpcApi>, stablecoinMintOverride?: Address, devnet?: boolean, mock?: boolean);
+    /**
+     * Loads the legacy USDC+ controller data from the blockchain.
+     * Uses the DriftUsdcController account type which has baseStrategy and compounder.
+     */
+    load(): Promise<void>;
+    /**
+     * Helper to get associated token address
+     */
+    private getAtaLegacy;
+    /**
+     * Creates a mint instruction for the USDC+ stablecoin using the legacy instruction.
+     *
+     * This method uses the legacy mintDriftS1 instruction that interacts directly
+     * with Drift protocol. Use this for programs that have NOT been migrated.
+     *
+     * @param user - TransactionSigner of the user
+     * @param amount - Amount of USDC to deposit
+     * @param minimumReceived - Minimum amount of USDC+ stablecoins to receive
+     * @returns Promise resolving to an array of Instructions
+     */
+    mint(user: TransactionSigner, amount: bigint | number, minimumReceived: bigint | number): Promise<Instruction[]>;
+    /**
+     * Creates a redeem instruction for the USDC+ stablecoin using the legacy instruction.
+     *
+     * This method uses the legacy redeemDriftS1 instruction that interacts directly
+     * with Drift protocol. Use this for programs that have NOT been migrated.
+     *
+     * @param user - TransactionSigner of the user
+     * @param amount - Amount of USDC+ to redeem
+     * @param minimumReceived - Minimum amount of USDC to receive
+     * @param canChill - Whether to allow the transaction to "chill" if Drift withdrawal is delayed
+     * @returns Promise resolving to an array of Instructions
+     */
+    redeem(user: TransactionSigner, amount: bigint | number, minimumReceived: bigint | number, canChill?: boolean): Promise<Instruction[]>;
+    /**
+     * Initializes the legacy USDC stablecoin with the specified parameters.
+     */
+    initialize(admin: TransactionSigner, mint: Address, cap: bigint, recipientAddresses: Address[], recipientCuts: number[]): Promise<Instruction[]>;
+    /**
+     * Rebalance is not needed for legacy USDC+.
+     */
+    rebalance(): Promise<Instruction[]>;
+    /**
+     * Gets the USD exchange rate for the USDC+ stablecoin.
+     */
+    getBaseUsdExchangeRate(): Promise<number>;
+    getReceiptUsdExchangeRate(): Promise<number>;
+    getBaseToCollateralExchangeRate(): Promise<number>;
+    getReceiptToCollateralExchangeRate(): Promise<number>;
+    /**
+     * Math helper function that calculates receipt tokens to issue for a given deposit amount.
+     */
+    private computeReceiptToken;
+    /**
+     * Math helper function that calculates base token amount to return for a given receipt token burn.
+     */
+    private computeBaseToken;
+    simulateMintMath(usdcAmount: BN): Promise<BN>;
+    simulateRedeemMath(receiptTokens: BN): Promise<BN>;
+    /**
+     * Deposit to Drift
+     */
+    depositDrift(depositor: TransactionSigner, amount: bigint): Promise<import("../generated/reflect_main").DepositDriftInstruction<Address, string, string, string, string, string, string, string, string, string, string, string, string, "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", []>>;
+    cleanup(): Promise<void>;
+}

package/dist/stablecoins/UsdcPlusStablecoinLegacy.js

@@ -0,0 +1,386 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsdcPlusStablecoinLegacy = void 0;
+const kit_1 = require("@solana/kit");
+const Stablecoin_1 = require("../classes/Stablecoin");
+const classes_1 = require("../classes");
+const constants_1 = require("../constants");
+const reflect_main_1 = require("../generated/reflect_main");
+const accounts_1 = require("../generated/reflect_main/accounts");
+const drift_1 = require("../helpers/drift");
+const sdk_1 = require("@drift-labs/sdk");
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const token_1 = require("@solana-program/token");
+/**
+ * Legacy USDC+ Stablecoin implementation for the Reflect protocol.
+ *
+ * This class uses the legacy DriftUsdcController account type and mint/redeem
+ * instructions (mintDriftS1/redeemDriftS1) that were used before the program migration.
+ * These instructions interact directly with Drift and require many more accounts.
+ *
+ * Use this class for programs that have NOT been migrated yet.
+ * After migration, use the regular UsdcPlusStablecoin class instead.
+ *
+ * Strategy ID: 0
+ * Collateral: USDC
+ *
+ * Environment handling:
+ * - devnet=true → Uses devnet program
+ * - devnet=false, mock=true → Uses mock program on mainnet
+ * - devnet=false, mock=false → Uses production mainnet program
+ */
+class UsdcPlusStablecoinLegacy extends Stablecoin_1.Stablecoin {
+    /**
+     * Creates a new Legacy USDC+ Stablecoin instance.
+     *
+     * @param rpc - Solana RPC instance
+     * @param stablecoinMintOverride - Optional override for the stablecoin mint address
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
+     */
+    constructor(rpc, stablecoinMintOverride, devnet = false, mock = false) {
+        super(0, "USD Coin Plus (Legacy)", rpc, devnet ? constants_1.USDC_PLUS_LOOKUP_TABLE_DEVNET : constants_1.USDC_PLUS_LOOKUP_TABLE, devnet, mock);
+        this.collaterals = [
+            {
+                mint: devnet ? constants_1.USDC_MINT_DEVNET : constants_1.USDC_MINT,
+                oracle: "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
+                decimals: 6,
+            },
+        ];
+        this.isPermissioned = true;
+        if (stablecoinMintOverride) {
+            this.stablecoinMint = stablecoinMintOverride;
+        }
+    }
+    /**
+     * Loads the legacy USDC+ controller data from the blockchain.
+     * Uses the DriftUsdcController account type which has baseStrategy and compounder.
+     */
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            // Fetch and decode the DriftUsdcController account
+            const controllerAccount = yield (0, accounts_1.fetchDriftUsdcController)(this.rpc, this.controllerKey);
+            this.controller = controllerAccount.data;
+            this.stablecoinMint = this.controller.baseStrategy.mint;
+        });
+    }
+    /**
+     * Helper to get associated token address
+     */
+    getAtaLegacy(mint, owner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [ata] = yield (0, token_1.findAssociatedTokenPda)({
+                mint,
+                owner,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            });
+            return ata;
+        });
+    }
+    /**
+     * Creates a mint instruction for the USDC+ stablecoin using the legacy instruction.
+     *
+     * This method uses the legacy mintDriftS1 instruction that interacts directly
+     * with Drift protocol. Use this for programs that have NOT been migrated.
+     *
+     * @param user - TransactionSigner of the user
+     * @param amount - Amount of USDC to deposit
+     * @param minimumReceived - Minimum amount of USDC+ stablecoins to receive
+     * @returns Promise resolving to an array of Instructions
+     */
+    mint(user, amount, minimumReceived) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            if (!this.stablecoinMint)
+                throw new Error("Stablecoin mint not loaded. Call load() first.");
+            const main = yield classes_1.PdaClient.deriveMain(this.devnet, this.mock);
+            const adminPermissions = yield classes_1.PdaClient.derivePermissions(user.address, this.devnet, this.mock);
+            const usdcMint = this.devnet ? constants_1.USDC_MINT_DEVNET : constants_1.USDC_MINT;
+            const userReceiptAta = yield this.getAtaLegacy(this.stablecoinMint, user.address);
+            const userUsdcAta = yield this.getAtaLegacy(usdcMint, user.address);
+            const controllerUsdcAta = yield this.getAtaLegacy(usdcMint, this.controllerKey);
+            // Derive Drift accounts
+            const driftProgramPubkey = new web3_js_1.PublicKey(constants_1.DRIFT_PROGRAM_ID);
+            const controllerPubkey = new web3_js_1.PublicKey(this.controllerKey);
+            const driftState = yield (0, sdk_1.getDriftStateAccountPublicKey)(driftProgramPubkey);
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(driftProgramPubkey, controllerPubkey);
+            const userStats = yield (0, sdk_1.getUserStatsAccountPublicKey)(driftProgramPubkey, controllerPubkey);
+            const spotMarketVault = yield (0, sdk_1.getSpotMarketVaultPublicKey)(driftProgramPubkey, 0);
+            const ix = (0, reflect_main_1.getMintDriftS1Instruction)({
+                user,
+                main,
+                usdcController: this.controllerKey,
+                adminPermissions,
+                userReceiptAta,
+                userUsdcAta,
+                controllerUsdcAta,
+                receiptMint: this.stablecoinMint,
+                drift: constants_1.DRIFT_PROGRAM_ID,
+                state: (0, kit_1.address)(driftState.toBase58()),
+                userStats: (0, kit_1.address)(userStats.toBase58()),
+                referrerUserStats: constants_1.REFERRAL_USER_STATS,
+                referrerUser: constants_1.REFERRAL_USER,
+                userAccount: (0, kit_1.address)(userAccount.toBase58()),
+                spotMarketVault: (0, kit_1.address)(spotMarketVault.toBase58()),
+                driftVault: constants_1.DRIFT_VAULT,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                usdcAmount: BigInt(amount),
+                minUsdcAmount: BigInt(minimumReceived),
+            }, { programAddress: this.programAddress });
+            return [ix];
+        });
+    }
+    /**
+     * Creates a redeem instruction for the USDC+ stablecoin using the legacy instruction.
+     *
+     * This method uses the legacy redeemDriftS1 instruction that interacts directly
+     * with Drift protocol. Use this for programs that have NOT been migrated.
+     *
+     * @param user - TransactionSigner of the user
+     * @param amount - Amount of USDC+ to redeem
+     * @param minimumReceived - Minimum amount of USDC to receive
+     * @param canChill - Whether to allow the transaction to "chill" if Drift withdrawal is delayed
+     * @returns Promise resolving to an array of Instructions
+     */
+    redeem(user_1, amount_1, minimumReceived_1) {
+        return __awaiter(this, arguments, void 0, function* (user, amount, minimumReceived, canChill = false) {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            if (!this.stablecoinMint)
+                throw new Error("Stablecoin mint not loaded. Call load() first.");
+            const main = yield classes_1.PdaClient.deriveMain(this.devnet, this.mock);
+            const adminPermissions = yield classes_1.PdaClient.derivePermissions(user.address, this.devnet, this.mock);
+            const usdcMint = this.devnet ? constants_1.USDC_MINT_DEVNET : constants_1.USDC_MINT;
+            const userReceiptAta = yield this.getAtaLegacy(this.stablecoinMint, user.address);
+            const userUsdcAta = yield this.getAtaLegacy(usdcMint, user.address);
+            const controllerUsdcAta = yield this.getAtaLegacy(usdcMint, this.controllerKey);
+            // Derive Drift accounts
+            const driftProgramPubkey = new web3_js_1.PublicKey(constants_1.DRIFT_PROGRAM_ID);
+            const controllerPubkey = new web3_js_1.PublicKey(this.controllerKey);
+            const driftState = yield (0, sdk_1.getDriftStateAccountPublicKey)(driftProgramPubkey);
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(driftProgramPubkey, controllerPubkey);
+            const userStats = yield (0, sdk_1.getUserStatsAccountPublicKey)(driftProgramPubkey, controllerPubkey);
+            const spotMarketVault = yield (0, sdk_1.getSpotMarketVaultPublicKey)(driftProgramPubkey, 0);
+            const ix = (0, reflect_main_1.getRedeemDriftS1Instruction)({
+                user,
+                main,
+                usdcController: this.controllerKey,
+                adminPermissions,
+                userReceiptAta,
+                userUsdcAta,
+                controllerUsdcAta,
+                receiptMint: this.stablecoinMint,
+                drift: constants_1.DRIFT_PROGRAM_ID,
+                state: (0, kit_1.address)(driftState.toBase58()),
+                userStats: (0, kit_1.address)(userStats.toBase58()),
+                referrerUserStats: constants_1.REFERRAL_USER_STATS,
+                referrerUser: constants_1.REFERRAL_USER,
+                userAccount: (0, kit_1.address)(userAccount.toBase58()),
+                spotMarketVault: (0, kit_1.address)(spotMarketVault.toBase58()),
+                driftVault: constants_1.DRIFT_VAULT,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                rusdBurnAmount: BigInt(amount),
+                minLstRedeem: BigInt(minimumReceived),
+                canChill,
+            }, { programAddress: this.programAddress });
+            return [ix];
+        });
+    }
+    /**
+     * Initializes the legacy USDC stablecoin with the specified parameters.
+     */
+    initialize(admin, mint, cap, recipientAddresses, recipientCuts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            const main = yield classes_1.PdaClient.deriveMain(this.devnet, this.mock);
+            const adminPermissions = yield classes_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const usdcMint = this.devnet ? constants_1.USDC_MINT_DEVNET : constants_1.USDC_MINT;
+            const ix = (0, reflect_main_1.getInitDriftControllerS1Instruction)({
+                admin,
+                adminPermissions,
+                main,
+                driftUsdcController: this.controllerKey,
+                mint,
+                cap,
+                recipientAddresses,
+                recipientCuts,
+            }, { programAddress: this.programAddress });
+            // Create new instruction with USDC mint added as remaining account
+            // (ix is frozen, so we need to create a new object)
+            const ixWithRemainingAccounts = Object.assign(Object.assign({}, ix), { accounts: [
+                    ...ix.accounts,
+                    { address: usdcMint, role: kit_1.AccountRole.READONLY },
+                ] });
+            return [ixWithRemainingAccounts];
+        });
+    }
+    /**
+     * Rebalance is not needed for legacy USDC+.
+     */
+    rebalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    /**
+     * Gets the USD exchange rate for the USDC+ stablecoin.
+     */
+    getBaseUsdExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            const controllerPubkey = new web3_js_1.PublicKey(this.controllerKey);
+            const driftProgramPubkey = new web3_js_1.PublicKey(constants_1.DRIFT_PROGRAM_ID);
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(driftProgramPubkey, controllerPubkey);
+            const { data: userAccountData } = yield (0, drift_1.fetchUser)(this.rpc, (0, kit_1.address)(userAccount.toBase58()));
+            const spotPosition = userAccountData.spotPositions[0];
+            const { scaledBalance, balanceType } = spotPosition;
+            const spotMarketAccount = (0, sdk_1.getSpotMarketPublicKeySync)(driftProgramPubkey, 0);
+            const { data: spotMarketAccountData } = yield (0, drift_1.fetchSpotMarket)(this.rpc, (0, kit_1.address)(spotMarketAccount.toBase58()));
+            const usdcAmount = (0, sdk_1.getTokenAmount)(new bn_js_1.default(scaledBalance.toString()), (0, drift_1.mapSpotMarket)(spotMarketAccountData), (0, drift_1.mapSpotBalanceType)(balanceType));
+            const [{ mint: usdcMint }] = this.collaterals;
+            const { data: [{ price: { expo, price } }], } = yield this.getCollateralPrice(usdcMint);
+            const exchangeRate = usdcAmount
+                .mul(new bn_js_1.default(price))
+                .mul(new bn_js_1.default(constants_1.EXCHANGE_RATE_PRECISION))
+                .div(new bn_js_1.default(this.stablecoinMintSupply.toString()))
+                .div(new bn_js_1.default(10).pow(new bn_js_1.default(expo).abs()));
+            return exchangeRate.toNumber();
+        });
+    }
+    getReceiptUsdExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getBaseUsdExchangeRate();
+        });
+    }
+    getBaseToCollateralExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            const controllerPubkey = new web3_js_1.PublicKey(this.controllerKey);
+            const driftProgramPubkey = new web3_js_1.PublicKey(constants_1.DRIFT_PROGRAM_ID);
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(driftProgramPubkey, controllerPubkey);
+            const { data: userAccountData } = yield (0, drift_1.fetchUser)(this.rpc, (0, kit_1.address)(userAccount.toBase58()));
+            const spotPosition = userAccountData.spotPositions[0];
+            const { scaledBalance, balanceType } = spotPosition;
+            const spotMarketAccount = (0, sdk_1.getSpotMarketPublicKeySync)(driftProgramPubkey, 0);
+            const { data: spotMarketAccountData } = yield (0, drift_1.fetchSpotMarket)(this.rpc, (0, kit_1.address)(spotMarketAccount.toBase58()));
+            const usdcAmount = (0, sdk_1.getTokenAmount)(new bn_js_1.default(scaledBalance.toString()), (0, drift_1.mapSpotMarket)(spotMarketAccountData), (0, drift_1.mapSpotBalanceType)(balanceType));
+            const exchangeRate = usdcAmount
+                .mul(new bn_js_1.default(constants_1.EXCHANGE_RATE_PRECISION))
+                .div(new bn_js_1.default(this.stablecoinMintSupply.toString()));
+            return exchangeRate.toNumber();
+        });
+    }
+    getReceiptToCollateralExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getBaseToCollateralExchangeRate();
+        });
+    }
+    /**
+     * Math helper function that calculates receipt tokens to issue for a given deposit amount.
+     */
+    computeReceiptToken(deposit, depositedVault, receiptTokenSupply) {
+        if (receiptTokenSupply.isZero()) {
+            return deposit;
+        }
+        return deposit.mul(receiptTokenSupply).div(depositedVault);
+    }
+    /**
+     * Math helper function that calculates base token amount to return for a given receipt token burn.
+     */
+    computeBaseToken(receipt, depositedVault, receiptTokenSupply) {
+        return receipt.mul(depositedVault).div(receiptTokenSupply);
+    }
+    simulateMintMath(usdcAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.controller) {
+                yield this.load();
+            }
+            if (!((_a = this.controller) === null || _a === void 0 ? void 0 : _a.compounder)) {
+                throw new Error("AutoCompound data not available");
+            }
+            const receiptTokens = this.computeReceiptToken(usdcAmount, new bn_js_1.default(this.controller.compounder.depositedVaultValue.toString()), new bn_js_1.default(this.stablecoinMintSupply.toString()));
+            return receiptTokens;
+        });
+    }
+    simulateRedeemMath(receiptTokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.controller) {
+                yield this.load();
+            }
+            if (!((_a = this.controller) === null || _a === void 0 ? void 0 : _a.compounder)) {
+                throw new Error("AutoCompound data not available");
+            }
+            const usdcAmount = this.computeBaseToken(receiptTokens, new bn_js_1.default(this.controller.compounder.depositedVaultValue.toString()), new bn_js_1.default(this.stablecoinMintSupply.toString()));
+            return usdcAmount;
+        });
+    }
+    /**
+     * Deposit to Drift
+     */
+    depositDrift(depositor, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controllerKey)
+                yield this.initializeKeys();
+            if (!this.controller)
+                throw new Error("Controller not loaded. Call load() first.");
+            const { oracle, marketIndex } = sdk_1.SpotMarkets["mainnet-beta"][0];
+            const driftProgramPubkey = new web3_js_1.PublicKey(constants_1.DRIFT_PROGRAM_ID);
+            const controllerPubkey = new web3_js_1.PublicKey(this.controllerKey);
+            const spotMarket = (0, sdk_1.getSpotMarketPublicKeySync)(driftProgramPubkey, marketIndex);
+            const [{ mint }] = this.collaterals;
+            const controllerTokenAccount = yield this.getAtaLegacy(mint, this.controllerKey);
+            const depositorTokenAccount = yield this.getAtaLegacy(mint, depositor.address);
+            const bump = this.controller.baseStrategy.bump;
+            const driftState = yield (0, sdk_1.getDriftStateAccountPublicKey)(driftProgramPubkey);
+            const spotMarketVault = yield (0, sdk_1.getSpotMarketVaultPublicKey)(driftProgramPubkey, 0);
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(driftProgramPubkey, controllerPubkey);
+            const userStats = (0, sdk_1.getUserStatsAccountPublicKey)(driftProgramPubkey, controllerPubkey);
+            const ix = (0, reflect_main_1.getDepositDriftInstruction)({
+                controller: this.controllerKey,
+                depositor,
+                spotMarket: (0, kit_1.address)(spotMarket.toBase58()),
+                controllerTokenAccount,
+                main: yield classes_1.PdaClient.deriveMain(this.devnet, this.mock),
+                userAccount: (0, kit_1.address)(userAccount.toBase58()),
+                userStats: (0, kit_1.address)(userStats.toBase58()),
+                spotMarketVault: (0, kit_1.address)(spotMarketVault.toBase58()),
+                oracle: (0, kit_1.address)(oracle.toBase58()),
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                state: (0, kit_1.address)(driftState.toBase58()),
+                depositorTokenAccount,
+                drift: constants_1.DRIFT_PROGRAM_ID,
+                amount,
+                controllerBump: bump,
+                controllerIndex: this.index,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
+    }
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // No cleanup needed
+        });
+    }
+}
+exports.UsdcPlusStablecoinLegacy = UsdcPlusStablecoinLegacy;

package/dist/stablecoins/UsdtPlusStablecoin.d.ts

@@ -0,0 +1,120 @@
+import { Stablecoin } from "../classes/Stablecoin";
+import { Address, TransactionSigner, Rpc, SolanaRpcApi, Instruction } from "@solana/kit";
+import { StrategyController } from "../generated/reflect_main/accounts";
+import BN from "bn.js";
+/**
+ * USDT+ Stablecoin implementation for the Reflect protocol.
+ * Extends the base Stablecoin class to provide USDT-specific functionality
+ * including initialization, minting, redemption, and rebalancing operations.
+ *
+ * Strategy ID: 1
+ * Collateral: USDT
+ *
+ * This class uses the StrategyController account type which stores data
+ * in a rack component system.
+ *
+ * Environment handling:
+ * - devnet=true → Uses devnet program
+ * - devnet=false, mock=true → Uses mock program on mainnet
+ * - devnet=false, mock=false → Uses production mainnet program
+ */
+export declare class UsdtPlusStablecoin extends Stablecoin<StrategyController> {
+    private autoCompound;
+    /**
+     * Creates a new USDT+ Stablecoin instance.
+     *
+     * @param rpc - Solana RPC instance
+     * @param stablecoinMintOverride - Optional override for the stablecoin mint address
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
+     */
+    constructor(rpc: Rpc<SolanaRpcApi>, stablecoinMintOverride?: Address, devnet?: boolean, mock?: boolean);
+    /**
+     * Loads the USDT+ controller data from the blockchain.
+     * Updates the stablecoin mint and strategy information.
+     *
+     * This method fetches the StrategyController account and extracts:
+     * - Base strategy data (mint, bump, cap, etc.)
+     * - AutoCompound component from the rack system
+     */
+    load(): Promise<void>;
+    /**
+     * Helper to get associated token address
+     */
+    private getAta;
+    /**
+     * Initializes the USDT+ stablecoin with the specified parameters.
+     *
+     * @param admin - TransactionSigner of the initializer
+     * @param mint - Address of the mint to be used for the stablecoin
+     * @param cap - Maximum supply cap
+     * @param recipientAddresses - Array of recipient addresses for fee distribution
+     * @param recipientCuts - Array of recipient cuts (u16 values, total must equal 10000)
+     * @returns Promise resolving to an array of Instructions
+     */
+    initialize(admin: TransactionSigner, mint: Address, cap: bigint, recipientAddresses: Address[], recipientCuts: number[]): Promise<Instruction[]>;
+    /**
+     * Creates a mint instruction for the USDT+ stablecoin.
+     *
+     * @param user - TransactionSigner of the user
+     * @param amount - Amount of USDT to deposit
+     * @param minimumReceived - Minimum amount of USDT+ stablecoins to receive
+     * @returns Promise resolving to an array of Instructions
+     */
+    mint(user: TransactionSigner, amount: bigint | number, minimumReceived: bigint | number): Promise<Instruction[]>;
+    /**
+     * Creates a redeem instruction for the USDT+ stablecoin.
+     *
+     * @param user - TransactionSigner of the user
+     * @param amount - Amount of USDT+ to redeem
+     * @param minimumReceived - Minimum amount of USDT to receive
+     * @returns Promise resolving to an array of Instructions
+     */
+    redeem(user: TransactionSigner, amount: bigint | number, minimumReceived: bigint | number): Promise<Instruction[]>;
+    /**
+     * Creates a rebalance instruction for the USDT+ stablecoin.
+     * Currently returns an empty array as rebalance may not be necessary.
+     *
+     * @returns Promise resolving to an empty array
+     */
+    rebalance(): Promise<Instruction[]>;
+    /**
+     * Gets the USD exchange rate for the USDT+ stablecoin.
+     *
+     * @returns Promise resolving to the USD exchange rate as a number
+     */
+    getBaseUsdExchangeRate(): Promise<number>;
+    getReceiptUsdExchangeRate(): Promise<number>;
+    /**
+     * Base (USDT) to Collateral (USDT) exchange rate.
+     * For USDT+, base and collateral are the same asset/decimals.
+     */
+    getBaseToCollateralExchangeRate(): Promise<number>;
+    /**
+     * Receipt (USDT+) to Collateral (USDT) exchange rate.
+     */
+    getReceiptToCollateralExchangeRate(): Promise<number>;
+    /**
+     * Math helper function that calculates receipt tokens to issue for a given deposit amount.
+     */
+    private computeReceiptToken;
+    /**
+     * Math helper function that calculates base token amount to return for a given receipt token burn.
+     */
+    private computeBaseToken;
+    /**
+     * Processes a user deposit: calculates receipt tokens to issue.
+     */
+    private processDeposit;
+    /**
+     * Processes a user redemption: calculates USDT to return.
+     */
+    private processRedemption;
+    simulateMintMath(usdtAmount: BN): Promise<BN>;
+    simulateRedeemMath(receiptTokens: BN): Promise<BN>;
+    /**
+     * Deposit to Drift
+     */
+    depositDrift(depositor: TransactionSigner, amount: bigint): Promise<import("../generated/reflect_main").DepositDriftInstruction<Address, string, string, string, string, string, string, string, string, string, string, string, string, "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", []>>;
+    cleanup(): Promise<void>;
+}