@reflectmoney/stable.ts 1.0.1 → 1.0.3

package/dist/stablecoins/LstStablecoin.js

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

package/dist/stablecoins/UsdcPlusStablecoin.d.ts

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

package/dist/stablecoins/UsdcPlusStablecoin.js

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

package/dist/stablecoins/UsdjStablecoin.d.ts

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

package/dist/stablecoins/UsdjStablecoin.js

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

package/dist/stablecoins/index.d.ts

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

package/dist/stablecoins/index.js

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

package/package.json

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

package/dist/classes/Strategy.d.ts

@@ -1,30 +0,0 @@
-import { AccountMeta, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import BN from "bn.js";
-import { DriftClient } from "@drift-labs/sdk";
-import { Action } from "../generated";
-import { StablecoinMetadata } from "../types";
-export declare abstract class Strategy {
-    index: number;
-    name: string;
-    connection: Connection;
-    controller: PublicKey;
-    collateralMints: PublicKey[];
-    stablecoinMint: PublicKey;
-    driftClient?: DriftClient;
-    constructor(index: number, name: string, connection: Connection);
-    initializeTokenAccounts(owner: PublicKey, mints: PublicKey[], signer: PublicKey): Promise<TransactionInstruction[]>;
-    updateCap(signer: PublicKey, newCap: BN | number): Promise<TransactionInstruction>;
-    freezeCollateral(signer: PublicKey, freeze: boolean, mint: PublicKey): Promise<TransactionInstruction>;
-    freezeCollateralStrategy(signer: PublicKey, freeze: boolean, mint: PublicKey): Promise<TransactionInstruction>;
-    updateRecipients(signer: PublicKey, recipients: Map<PublicKey, number>): Promise<TransactionInstruction>;
-    initializeStrategyDriftAccount(signer: PublicKey, subAccountId?: number): Promise<TransactionInstruction>;
-    initializeStrategyDriftStatsAccount(signer: PublicKey): Promise<TransactionInstruction>;
-    freeze(signer: PublicKey, freeze: boolean, action: Action): Promise<TransactionInstruction>;
-    initializeStablecoin(signer: PublicKey, tokenKeypair: Keypair, metadata?: StablecoinMetadata): Promise<TransactionInstruction[]>;
-    abstract constructAccounts<T>(signer: PublicKey, ...args: any[]): Promise<T>;
-    abstract constructRemainingAccounts(): Promise<AccountMeta[]>;
-    abstract initialize(signer: PublicKey, ...args: any[]): Promise<TransactionInstruction[]>;
-    abstract mint(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
-    abstract redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number, ...args: any[]): Promise<TransactionInstruction[]>;
-    abstract rebalance(signer: PublicKey): Promise<TransactionInstruction[]>;
-}

package/dist/classes/Strategy.js

@@ -1,196 +0,0 @@
-"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.Strategy = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const sdk_1 = require("@drift-labs/sdk");
-const generated_1 = require("../generated");
-const PdaClient_1 = require("./PdaClient");
-const spl_token_1 = require("@solana/spl-token");
-const constants_1 = require("../constants");
-const mpl_token_metadata_1 = require("@metaplex-foundation/mpl-token-metadata");
-class Strategy {
-    constructor(index, name, connection) {
-        this.index = index;
-        this.name = name;
-        this.connection = connection;
-        this.controller = PdaClient_1.PdaClient.deriveController(this.index);
-    }
-    initializeTokenAccounts(owner, mints, signer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instructions = [];
-            for (const mint of mints) {
-                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner, true);
-                let isInitialized = false;
-                try {
-                    let account = yield this.connection.getAccountInfo(ata);
-                    isInitialized = account !== null;
-                }
-                catch (err) {
-                    isInitialized = false;
-                }
-                if (!isInitialized) {
-                    instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, ata, owner, mint));
-                }
-            }
-            return instructions;
-        });
-    }
-    updateCap(signer, newCap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ix = (0, generated_1.createUpdateCapInstruction)({
-                admin: signer,
-                main: PdaClient_1.PdaClient.deriveMain(),
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                systemProgram: web3_js_1.SystemProgram.programId,
-                strategy: this.controller
-            }, {
-                newCap,
-            }, generated_1.PROGRAM_ID);
-            return ix;
-        });
-    }
-    freezeCollateral(signer, freeze, mint) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ix = (0, generated_1.createSuspendLstProtocolInstruction)({
-                admin: signer,
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                main: PdaClient_1.PdaClient.deriveMain(),
-                systemProgram: web3_js_1.SystemProgram.programId,
-            }, {
-                freeze,
-                lstMint: mint
-            }, generated_1.PROGRAM_ID);
-            return ix;
-        });
-    }
-    freezeCollateralStrategy(signer, freeze, mint) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ix = (0, generated_1.createSuspendLstStrategyInstruction)({
-                admin: signer,
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                main: PdaClient_1.PdaClient.deriveMain(),
-                systemProgram: web3_js_1.SystemProgram.programId,
-                strategy: this.controller
-            }, {
-                freeze,
-                lstMint: mint
-            }, generated_1.PROGRAM_ID);
-            return ix;
-        });
-    }
-    updateRecipients(signer, recipients) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ix = (0, generated_1.createUpdateRecipientsInstruction)({
-                main: PdaClient_1.PdaClient.deriveMain(),
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                systemProgram: web3_js_1.SystemProgram.programId,
-                admin: signer,
-                strategy: this.controller
-            }, {
-                recipientAddresses: [...recipients.keys()],
-                recipientCuts: [...recipients.values()],
-            }, generated_1.PROGRAM_ID);
-            return ix;
-        });
-    }
-    initializeStrategyDriftAccount(signer_1) {
-        return __awaiter(this, arguments, void 0, function* (signer, subAccountId = 0) {
-            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, this.controller, subAccountId);
-            const userStats = (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, this.controller);
-            const [_, controllerBump] = PdaClient_1.PdaClient.deriveControllerWithBump(this.index);
-            const ix = (0, generated_1.createAddSubAccountInstruction)({
-                admin: signer,
-                drift: constants_1.DRIFT_PROGRAM_ID,
-                state: yield (0, sdk_1.getDriftStateAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID),
-                userStats,
-                userAccount,
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                main: PdaClient_1.PdaClient.deriveMain(),
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                systemProgram: web3_js_1.SystemProgram.programId,
-                lstController: this.controller
-            }, generated_1.PROGRAM_ID);
-            return ix;
-        });
-    }
-    initializeStrategyDriftStatsAccount(signer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, this.controller, 0);
-            const userStats = (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, this.controller);
-            const [_, controllerBump] = PdaClient_1.PdaClient.deriveControllerWithBump(this.index);
-            const ix = (0, generated_1.createCreateUserStatsAccountInstruction)({
-                admin: signer,
-                main: PdaClient_1.PdaClient.deriveMain(),
-                drift: constants_1.DRIFT_PROGRAM_ID,
-                userStats,
-                userAccount,
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                controller: this.controller,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                state: yield (0, sdk_1.getDriftStateAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID),
-                systemProgram: web3_js_1.SystemProgram.programId,
-            }, generated_1.PROGRAM_ID);
-            return ix;
-        });
-    }
-    freeze(signer, freeze, action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ix = (0, generated_1.createFreezeStrategyActionInstruction)({
-                admin: signer,
-                main: PdaClient_1.PdaClient.deriveMain(),
-                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
-                systemProgram: web3_js_1.SystemProgram.programId,
-                strategy: this.controller,
-            }, {
-                freeze,
-                action,
-                strategyId: this.index
-            });
-            return ix;
-        });
-    }
-    initializeStablecoin(signer, tokenKeypair, metadata) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instructions = [];
-            const createAccountInstruction = web3_js_1.SystemProgram.createAccount({
-                lamports: yield this.connection.getMinimumBalanceForRentExemption(spl_token_1.MINT_SIZE),
-                space: spl_token_1.MINT_SIZE,
-                fromPubkey: signer,
-                newAccountPubkey: tokenKeypair.publicKey,
-                programId: spl_token_1.TOKEN_PROGRAM_ID
-            });
-            instructions.push(createAccountInstruction);
-            const initializeMintInstruction = (0, spl_token_1.createInitializeMint2Instruction)(tokenKeypair.publicKey, 6, signer, signer);
-            instructions.push(initializeMintInstruction);
-            if (metadata) {
-                const createMetadataInstruction = (0, mpl_token_metadata_1.createCreateMetadataAccountV3Instruction)({
-                    metadata: PdaClient_1.PdaClient.deriveMetadataAccount(tokenKeypair.publicKey),
-                    mint: tokenKeypair.publicKey,
-                    mintAuthority: signer,
-                    payer: signer,
-                    updateAuthority: signer
-                }, {
-                    createMetadataAccountArgsV3: {
-                        data: metadata,
-                        isMutable: true,
-                        collectionDetails: null
-                    }
-                });
-                instructions.push(createMetadataInstruction);
-            }
-            const setAuthorityInstruction = (0, spl_token_1.createSetAuthorityInstruction)(tokenKeypair.publicKey, signer, spl_token_1.AuthorityType.MintTokens, this.controller);
-            instructions.push(setAuthorityInstruction);
-            return instructions;
-        });
-    }
-}
-exports.Strategy = Strategy;