@reflectmoney/stable.ts 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./stablecoins";
+export * from "./classes";
+export { PROGRAM_ID as DELTA_NEUTRAL_PROGRAM_ID, } from "./generated/reflect_main";
+export { PROGRAM_ID as TOKENISED_BONDS_PROGRAM_ID, } from "./generated/reflect_tokenised_bonds";
+export * from "./generated/reflect_main/accounts";
+export * from "./generated/reflect_main/errors";
+export * from "./generated/reflect_main/instructions";
+export * from "./generated/reflect_main/types";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+exports.TOKENISED_BONDS_PROGRAM_ID = exports.DELTA_NEUTRAL_PROGRAM_ID = void 0;
+__exportStar(require("./stablecoins"), exports);
+__exportStar(require("./classes"), exports);
+var reflect_main_1 = require("./generated/reflect_main");
+Object.defineProperty(exports, "DELTA_NEUTRAL_PROGRAM_ID", { enumerable: true, get: function () { return reflect_main_1.PROGRAM_ID; } });
+var reflect_tokenised_bonds_1 = require("./generated/reflect_tokenised_bonds");
+Object.defineProperty(exports, "TOKENISED_BONDS_PROGRAM_ID", { enumerable: true, get: function () { return reflect_tokenised_bonds_1.PROGRAM_ID; } });
+__exportStar(require("./generated/reflect_main/accounts"), exports);
+__exportStar(require("./generated/reflect_main/errors"), exports);
+__exportStar(require("./generated/reflect_main/instructions"), exports);
+__exportStar(require("./generated/reflect_main/types"), exports);

package/dist/stablecoins/JlpStablecoin.d.ts

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

package/dist/stablecoins/JlpStablecoin.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/LstStablecoin.d.ts

@@ -0,0 +1,19 @@
+import { Stablecoin } from "../classes/Stablecoin";
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { DriftLstData } from "../generated/reflect_main";
+import BN from "bn.js";
+export declare class LstStablecoin extends Stablecoin {
+    lstMap: DriftLstData[];
+    constructor(connection: Connection, stablecoinMintOverride?: PublicKey, collateralMintsOverride?: PublicKey[]);
+    load(connection: Connection): Promise<void>;
+    initialize(signer: PublicKey, cap: BN, mint: PublicKey, recipientAddresses: PublicKey[], recipientCuts: number[]): Promise<TransactionInstruction[]>;
+    constructAccounts<T>(signer: PublicKey, lst: PublicKey): Promise<T>;
+    constructRemainingAccounts(): Promise<{
+        pubkey: PublicKey;
+        isWritable: boolean;
+        isSigner: boolean;
+    }[]>;
+    mint(signer: PublicKey, amount: BN | number, minimumReceived: number | BN, lst: PublicKey): Promise<TransactionInstruction[]>;
+    redeem(signer: PublicKey, amount: BN | number, minimumReceived: number | BN, lst: PublicKey): Promise<TransactionInstruction[]>;
+    rebalance(): Promise<TransactionInstruction[]>;
+}

package/dist/stablecoins/LstStablecoin.js

@@ -0,0 +1,169 @@
+"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.LstStablecoin = 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 spl_token_1 = require("@solana/spl-token");
+const nodewallet_1 = __importDefault(require("@coral-xyz/anchor/dist/cjs/nodewallet"));
+class LstStablecoin extends Stablecoin_1.Stablecoin {
+    constructor(connection, stablecoinMintOverride, collateralMintsOverride) {
+        super(2, "Single-Sided LST Delta-Neutral", connection);
+        this.driftClient = new sdk_1.DriftClient({
+            connection,
+            env: "mainnet-beta",
+            wallet: new nodewallet_1.default(web3_js_1.Keypair.generate())
+        });
+        // Otherwise has to be loaded first.
+        if (stablecoinMintOverride)
+            this.stablecoinMint = stablecoinMintOverride;
+        if (collateralMintsOverride)
+            this.collaterals = collateralMintsOverride.map(mint => ({ mint, oracle: "" }));
+    }
+    load(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { lsts, baseStrategy: { mint } } = yield reflect_main_1.DriftLstController.fromAccountAddress(connection, this.controller);
+            this.stablecoinMint = mint;
+            this.lstMap = lsts;
+            this.collaterals = lsts.map(({ marketIndex }) => {
+                var _a;
+                const market = sdk_1.SpotMarkets["mainnet-beta"]
+                    .find(({ marketIndex: index }) => index === marketIndex);
+                return { mint: market === null || market === void 0 ? void 0 : market.mint, oracle: ((_a = market === null || market === void 0 ? void 0 : market.oracle) === null || _a === void 0 ? void 0 : _a.toBase58()) || "" };
+            });
+        });
+    }
+    initialize(signer, cap, mint, recipientAddresses, recipientCuts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createInitDriftControllerS3Instruction)({
+                admin: signer,
+                adminPermissions: classes_1.PdaClient.derivePermissions(signer),
+                main: classes_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                driftLstController: this.controller
+            }, {
+                mint,
+                cap,
+                recipientAddresses,
+                recipientCuts
+            }, reflect_main_1.PROGRAM_ID);
+            return [ix];
+        });
+    }
+    constructAccounts(signer, lst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { marketIndex: lstMarketIndex } = sdk_1.SpotMarkets["mainnet-beta"]
+                .find(market => market.mint.equals(lst));
+            const spotMarketVault = yield (0, sdk_1.getSpotMarketVaultPublicKey)(constants_1.DRIFT_PROGRAM_ID, lstMarketIndex);
+            const { subAccountId } = this.lstMap.find(({ marketIndex }) => marketIndex == lstMarketIndex);
+            const userLstAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lst, signer);
+            const controllerLstAta = (0, spl_token_1.getAssociatedTokenAddressSync)(this.controller, signer, true);
+            const userReflectAta = (0, spl_token_1.getAssociatedTokenAddressSync)(this.stablecoinMint, signer);
+            const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, this.controller, subAccountId);
+            const { referrer } = yield (0, sdk_1.fetchUserStatsAccount)(this.connection, this.driftClient.program, userAccount);
+            const referrerUserStats = (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, referrer);
+            const accounts = {
+                adminPermissions: null,
+                drift: constants_1.DRIFT_PROGRAM_ID,
+                main: classes_1.PdaClient.deriveMain(),
+                clock: web3_js_1.SYSVAR_CLOCK_PUBKEY,
+                controllerLstAta,
+                lstController: this.controller,
+                driftVault: constants_1.DRIFT_VAULT,
+                stableMint: this.stablecoinMint,
+                user: signer,
+                userStats: (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, this.controller),
+                referrerUser: referrer,
+                state: yield (0, sdk_1.getDriftStateAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID),
+                referrerUserStats,
+                spotMarketVault,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                userAccount,
+                userLstAta,
+                userReflectAta,
+            };
+            return accounts;
+        });
+    }
+    constructRemainingAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { marketIndex: usdcMarketIndex, oracle: usdcOracle, } = sdk_1.SpotMarkets["mainnet-beta"]
+                .find(({ marketIndex }) => marketIndex === 0);
+            const usdcSpotMarket = yield (0, sdk_1.getSpotMarketPublicKey)(constants_1.DRIFT_PROGRAM_ID, usdcMarketIndex);
+            const { oracle: solanaOracle, } = sdk_1.SpotMarkets["mainnet-beta"]
+                .find(({ marketIndex }) => marketIndex === 1);
+            const { marketIndex: solanaPerpMarketIndex } = sdk_1.PerpMarkets["mainnet-beta"]
+                .find(({ marketIndex }) => marketIndex === 0);
+            const solanaPerpMarket = yield (0, sdk_1.getPerpMarketPublicKey)(constants_1.DRIFT_PROGRAM_ID, solanaPerpMarketIndex);
+            const remainingOracles = [];
+            const remainingSpots = [];
+            this.lstMap.map(({ marketIndex }) => {
+                const oracle = sdk_1.SpotMarkets["mainnet-beta"].find(({ marketIndex: m }) => m == marketIndex).oracle;
+                const spotMarket = (0, sdk_1.getSpotMarketPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, marketIndex);
+                remainingOracles.push(oracle);
+                remainingSpots.push(spotMarket);
+            });
+            const remainingAccounts = [
+                ...remainingOracles,
+                usdcOracle,
+                solanaOracle,
+                ...remainingSpots,
+                usdcSpotMarket,
+                solanaPerpMarket
+            ];
+            return remainingAccounts.map(pubkey => ({
+                pubkey,
+                isWritable: false,
+                isSigner: false
+            }));
+        });
+    }
+    mint(signer, amount, minimumReceived, lst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.constructAccounts(signer, lst);
+            const ix = (0, reflect_main_1.createMintDriftS3Instruction)(Object.assign(Object.assign({}, accounts), { anchorRemainingAccounts: yield this.constructRemainingAccounts() }), {
+                lstAmount: amount,
+                minUsdrAmount: minimumReceived
+            }, reflect_main_1.PROGRAM_ID);
+            return [ix];
+        });
+    }
+    redeem(signer, amount, minimumReceived, lst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.constructAccounts(signer, lst);
+            const ix = (0, reflect_main_1.createRedeemDriftS3Instruction)(Object.assign(Object.assign({}, accounts), { anchorRemainingAccounts: yield this.constructRemainingAccounts() }), {
+                canChill: false,
+                minLstRedeem: minimumReceived,
+                rusdBurnAmount: amount
+            }, reflect_main_1.PROGRAM_ID);
+            return [ix];
+        });
+    }
+    rebalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = new web3_js_1.TransactionInstruction({
+                programId: web3_js_1.Keypair.generate().publicKey,
+                keys: [],
+                data: null
+            });
+            return [ix];
+        });
+    }
+}
+exports.LstStablecoin = LstStablecoin;

package/dist/stablecoins/UsdcStablecoin.d.ts

@@ -0,0 +1,64 @@
+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 UsdcStablecoin 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.
+     * Currently returns a placeholder instruction - implementation needed.
+     *
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    mint(): 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(): Promise<TransactionInstruction[]>;
+    /**
+     * Creates a rebalance instruction for the USDC stablecoin.
+     * Currently returns a placeholder instruction - implementation needed.
+     *
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    rebalance(): Promise<TransactionInstruction[]>;
+}

package/dist/stablecoins/UsdcStablecoin.js

@@ -0,0 +1,145 @@
+"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.UsdcStablecoin = 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 ReflectTokenisedBond_1 = require("../classes/ReflectTokenisedBond");
+/**
+ * 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 UsdcStablecoin 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);
+        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)(Object.assign({}, (yield this.constructAccounts(signer))), {
+                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 accounts = {
+                admin: signer,
+                adminPermissions: classes_1.PdaClient.derivePermissions(signer),
+                main: classes_1.PdaClient.deriveMain(),
+                driftUsdcController: this.controller,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            };
+            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.
+     * Currently returns a placeholder instruction - implementation needed.
+     *
+     * @returns Promise resolving to an array containing a single TransactionInstruction
+     */
+    mint() {
+        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];
+        });
+    }
+    /**
+     * 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() {
+        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];
+        });
+    }
+    /**
+     * Creates a rebalance instruction for the USDC stablecoin.
+     * Currently returns a placeholder instruction - implementation needed.
+     *
+     * @returns Promise resolving to an array containing a single 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.UsdcStablecoin = UsdcStablecoin;

package/dist/stablecoins/index.d.ts

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

package/dist/stablecoins/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./LstStablecoin"), exports);
+__exportStar(require("./UsdcStablecoin"), exports);

package/dist/strategies/JlpStrategy.d.ts

@@ -0,0 +1,17 @@
+import { Strategy } from "../classes/Strategy";
+import { PerpHedge } from "../generated";
+import { AccountMeta, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import BN from "bn.js";
+export declare class JlpStrategy extends Strategy {
+    private perpetuals;
+    constructor(connection: Connection, stablecoinMintOverride?: PublicKey);
+    load(): Promise<void>;
+    initialize(signer: PublicKey, driftPerpMarketsHedge: PerpHedge[], cap: BN, mint: PublicKey, recipientCuts: number[], recipientAddresses: PublicKey[], rebalanceSlippageBps: number): Promise<TransactionInstruction[]>;
+    constructAccounts<T>(signer: PublicKey): Promise<T>;
+    constructRemainingAccounts(): Promise<AccountMeta[]>;
+    constructRemainingAccountsForRebalance(): Promise<AccountMeta[]>;
+    mint(signer: PublicKey, amount: BN | number): Promise<TransactionInstruction[]>;
+    redeem(signer: PublicKey, amount: BN | number, minimumReceived: BN | number): Promise<TransactionInstruction[]>;
+    redeem2(signer: PublicKey, amount: BN | number, minimumReceived: BN | number): Promise<TransactionInstruction[]>;
+    rebalance(signer: PublicKey): Promise<TransactionInstruction[]>;
+}