@reflectmoney/stable.ts 1.0.0

package/README.md

@@ -0,0 +1,9 @@
+# Reflect SDK
+
+Typescript SDK for interacting with Reflect Protocol Delta-Neutral Program.
+
+## Classes
+SDK provides three classes:
+- `Reflect` - general purpose class for user-level interactions. Mainly for `mint()` and `burn()` of stable.
+- `ReflectAdmin` - admin-level class, allowing for modification of the core protocol settings.
+- `ReflectCrank` - class used for cranking the protocol to capture spreads & funding.

package/dist/classes/PdaClient.d.ts

@@ -0,0 +1,19 @@
+import { PublicKey } from "@solana/web3.js";
+export declare class PdaClient {
+    static deriveMain(): PublicKey;
+    static derivePermissions(user: PublicKey): PublicKey;
+    static deriveController(strategy: number): PublicKey;
+    static deriveControllerWithBump(strategy: number): [PublicKey, number];
+    static deriveRebalanceDetails(strategy: number): PublicKey;
+    static deriveJupiterPerpetuals(): PublicKey;
+    static deriveJlpPool(): PublicKey;
+    static deriveEventAuthority(): PublicKey;
+    static deriveTransferAuthority(): PublicKey;
+    static getDriftVaultFromMint(mint: PublicKey): Promise<PublicKey>;
+    static deriveMetadataAccount(mint: PublicKey): PublicKey;
+    static deriveCustody(pool: PublicKey, token: PublicKey): PublicKey;
+    static deriveLpConfig(): PublicKey;
+    static deriveLpAdmin(admin: PublicKey): PublicKey;
+    static deriveLpVault(vaultId: number): PublicKey;
+    static deriveLpVaultPool(vaultId: number): PublicKey;
+}

package/dist/classes/PdaClient.js

@@ -0,0 +1,131 @@
+"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.PdaClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const reflect_main_1 = require("../generated/reflect_main");
+const reflect_tokenised_bonds_1 = require("../generated/reflect_tokenised_bonds");
+const constants_1 = require("../constants");
+const bn_js_1 = __importDefault(require("bn.js"));
+const sdk_1 = require("@drift-labs/sdk");
+const mpl_token_metadata_1 = require("@metaplex-foundation/mpl-token-metadata");
+class PdaClient {
+    static deriveMain() {
+        const [main] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("main")], reflect_main_1.PROGRAM_ID);
+        return main;
+    }
+    static derivePermissions(user) {
+        const [permissions] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("user_permission"),
+            user.toBuffer()
+        ], reflect_main_1.PROGRAM_ID);
+        return permissions;
+    }
+    static deriveController(strategy) {
+        const [controller] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("dex_controller"),
+            Buffer.from([strategy])
+        ], reflect_main_1.PROGRAM_ID);
+        return controller;
+    }
+    static deriveControllerWithBump(strategy) {
+        return web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("dex_controller"),
+            Buffer.from([strategy])
+        ], reflect_main_1.PROGRAM_ID);
+    }
+    static deriveRebalanceDetails(strategy) {
+        const [rebalanceDetails] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("rebalance_details"),
+            this.deriveController(strategy).toBuffer()
+        ], reflect_main_1.PROGRAM_ID);
+        return rebalanceDetails;
+    }
+    static deriveJupiterPerpetuals() {
+        const [perpetuals] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("perpetuals")
+        ], constants_1.JUPITER_PROGRAM_ID);
+        return perpetuals;
+    }
+    static deriveJlpPool() {
+        const [jlpPool] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("pool"),
+            Buffer.from("Pool")
+        ], constants_1.JUPITER_PROGRAM_ID);
+        return jlpPool;
+    }
+    static deriveEventAuthority() {
+        const [eventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("__event_authority"),
+        ], constants_1.JUPITER_PROGRAM_ID);
+        return eventAuthority;
+    }
+    static deriveTransferAuthority() {
+        const [transferAuthority] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("transfer_authority"),
+        ], constants_1.JUPITER_PROGRAM_ID);
+        return transferAuthority;
+    }
+    static getDriftVaultFromMint(mint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { marketIndex } = sdk_1.SpotMarkets["mainnet-beta"]
+                .find(({ mint: marketMint }) => marketMint.equals(mint));
+            return yield (0, sdk_1.getSpotMarketVaultPublicKey)(constants_1.DRIFT_PROGRAM_ID, marketIndex);
+        });
+    }
+    static deriveMetadataAccount(mint) {
+        const [metadata] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("metadata"),
+            mpl_token_metadata_1.PROGRAM_ID.toBuffer(),
+            mint.toBuffer(),
+        ], mpl_token_metadata_1.PROGRAM_ID);
+        return metadata;
+    }
+    static deriveCustody(pool, token) {
+        const [custody] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("custody"),
+            pool.toBuffer(),
+            token.toBuffer()
+        ], constants_1.JUPITER_PROGRAM_ID);
+        return custody;
+    }
+    static deriveLpConfig() {
+        const [config] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("config")
+        ], reflect_tokenised_bonds_1.PROGRAM_ID);
+        return config;
+    }
+    static deriveLpAdmin(admin) {
+        const [adminPda] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("admin"),
+            admin.toBuffer()
+        ], reflect_tokenised_bonds_1.PROGRAM_ID);
+        return adminPda;
+    }
+    static deriveLpVault(vaultId) {
+        const [vault] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("vault"),
+            new bn_js_1.default(vaultId).toArrayLike(Buffer, "le", 8)
+        ], reflect_tokenised_bonds_1.PROGRAM_ID);
+        return vault;
+    }
+    static deriveLpVaultPool(vaultId) {
+        const [pool] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("vault_pool"),
+            PdaClient.deriveLpVault(vaultId).toBuffer()
+        ], reflect_tokenised_bonds_1.PROGRAM_ID);
+        return pool;
+    }
+}
+exports.PdaClient = PdaClient;

package/dist/classes/ReflectAdmin.d.ts

@@ -0,0 +1,19 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Action, Role, Update } from "../generated/reflect_main";
+export declare class ReflectAdmin {
+    private admin;
+    private main;
+    private connection;
+    constructor({ admin, connection }: {
+        admin: PublicKey;
+        connection: Connection;
+    });
+    static initializeMain(admin: PublicKey): import("@solana/web3.js").TransactionInstruction;
+    freezeProtocolAction(freeze: boolean, action: Action): Promise<import("@solana/web3.js").TransactionInstruction>;
+    freezeDex(freeze: boolean, programIndex: number): Promise<void>;
+    createAdminAccount(signer: PublicKey, newAdmin: PublicKey): Promise<import("@solana/web3.js").TransactionInstruction>;
+    updateRoleHolderProtocol(signer: PublicKey, adminToUpdate: PublicKey, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+    updateRoleHolderStrategy(signer: PublicKey, strategyId: number, adminToUpdate: PublicKey, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+    updateActionRoleStrategy(signer: PublicKey, strategyId: number, action: Action, affectedRole: Role, update: Update): Promise<void>;
+    updateActionRoleProtocol(signer: PublicKey, action: Action, affectedRole: Role, update: Update): Promise<import("@solana/web3.js").TransactionInstruction>;
+}

package/dist/classes/ReflectAdmin.js

@@ -0,0 +1,136 @@
+"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.ReflectAdmin = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const reflect_main_1 = require("../generated/reflect_main");
+const PdaClient_1 = require("./PdaClient");
+class ReflectAdmin {
+    constructor({ admin, connection }) {
+        this.admin = admin;
+        this.connection = connection;
+        this.main = PdaClient_1.PdaClient.deriveMain();
+    }
+    // Create `Main` account. Initial step of the setup
+    static initializeMain(admin) {
+        const [main] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("main")], reflect_main_1.PROGRAM_ID);
+        const ix = (0, reflect_main_1.createInitMainInstruction)({
+            main,
+            admin,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            creds: PdaClient_1.PdaClient.derivePermissions(admin)
+        }, reflect_main_1.PROGRAM_ID);
+        return ix;
+    }
+    freezeProtocolAction(freeze, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createFreezeProtocolActionInstruction)({
+                admin: this.admin,
+                main: this.main,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(this.admin),
+            }, {
+                freeze,
+                action
+            });
+            return ix;
+        });
+    }
+    freezeDex(freeze, programIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createFreezeProgramInstruction)({
+                admin: this.admin,
+                main: this.main,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(this.admin),
+            }, {
+                freeze,
+                programIndex
+            });
+        });
+    }
+    createAdminAccount(signer, newAdmin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createCreateAdminAccountInstruction)({
+                caller: signer,
+                newCreds: PdaClient_1.PdaClient.derivePermissions(newAdmin),
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, {
+                newAdmin
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    updateRoleHolderProtocol(signer, adminToUpdate, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateRoleHolderProtocolInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                updateAdminPermissions: PdaClient_1.PdaClient.derivePermissions(adminToUpdate),
+                // Dummy strategy account.
+                strategy: PdaClient_1.PdaClient.deriveController(0)
+            }, {
+                update,
+                accessLevel: affectedRole,
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    updateRoleHolderStrategy(signer, strategyId, adminToUpdate, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateRoleHolderStrategyInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                updateAdminPermissions: PdaClient_1.PdaClient.derivePermissions(adminToUpdate),
+                strategy: PdaClient_1.PdaClient.deriveController(strategyId)
+            }, {
+                update,
+                role: affectedRole,
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    updateActionRoleStrategy(signer, strategyId, action, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateActionRoleStrategyInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                strategy: PdaClient_1.PdaClient.deriveController(strategyId)
+            }, {
+                update,
+                role: affectedRole,
+                action
+            }, reflect_main_1.PROGRAM_ID);
+        });
+    }
+    updateActionRoleProtocol(signer, action, affectedRole, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = (0, reflect_main_1.createUpdateActionRoleProtocolInstruction)({
+                admin: signer,
+                adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer),
+                main: PdaClient_1.PdaClient.deriveMain(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, {
+                action,
+                role: affectedRole,
+                update
+            }, reflect_main_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+}
+exports.ReflectAdmin = ReflectAdmin;

package/dist/classes/ReflectTokenisedBond.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import { Keypair } from "@solana/web3.js";
+export declare class ReflectTokenisedBond {
+    connection: Connection;
+    constructor(connection: Connection);
+    createReceiptToken(connection: Connection, signer: PublicKey, vault: PublicKey): Promise<{
+        instructions: import("@solana/web3.js").TransactionInstruction[];
+        signers: Keypair[];
+    }>;
+    initialize(signer: PublicKey): Promise<import("@solana/web3.js").TransactionInstruction>;
+    initializeVault(signer: PublicKey, depositMint: PublicKey, receiptMint: PublicKey): Promise<import("@solana/web3.js").TransactionInstruction>;
+    deposit(signer: PublicKey, vaultId: number, amount: BN): Promise<import("@solana/web3.js").TransactionInstruction>;
+    withdraw(signer: PublicKey, vaultId: number, amount: BN): Promise<import("@solana/web3.js").TransactionInstruction>;
+}

package/dist/classes/ReflectTokenisedBond.js

@@ -0,0 +1,125 @@
+"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.ReflectTokenisedBond = void 0;
+const reflect_tokenised_bonds_1 = require("../generated/reflect_tokenised_bonds");
+const PdaClient_1 = require("./PdaClient");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_2 = require("@solana/web3.js");
+class ReflectTokenisedBond {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    createReceiptToken(connection, signer, vault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keypair = web3_js_2.Keypair.generate();
+            const lamports = yield connection.getMinimumBalanceForRentExemption(spl_token_1.MINT_SIZE);
+            const createAccountIx = web3_js_1.SystemProgram.createAccount({
+                newAccountPubkey: keypair.publicKey,
+                fromPubkey: signer,
+                lamports,
+                programId: spl_token_1.TOKEN_PROGRAM_ID,
+                space: spl_token_1.MINT_SIZE
+            });
+            const ix = (0, spl_token_1.createInitializeMintInstruction)(keypair.publicKey, 9, vault, vault);
+            return {
+                instructions: [createAccountIx, ix],
+                signers: [keypair]
+            };
+        });
+    }
+    initialize(signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = PdaClient_1.PdaClient.deriveLpConfig();
+            const admin = PdaClient_1.PdaClient.deriveLpAdmin(signer);
+            const ix = (0, reflect_tokenised_bonds_1.createInitializeInstruction)({
+                config,
+                admin,
+                signer,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, reflect_tokenised_bonds_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    initializeVault(signer, depositMint, receiptMint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = PdaClient_1.PdaClient.deriveLpConfig();
+            const vault = PdaClient_1.PdaClient.deriveLpVault(0);
+            const vaultPool = PdaClient_1.PdaClient.deriveLpVaultPool(0);
+            const ix = (0, reflect_tokenised_bonds_1.createCreateVaultInstruction)({
+                config,
+                depositMint,
+                receiptMint,
+                signer,
+                vault,
+                vaultPool,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            }, reflect_tokenised_bonds_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+    deposit(signer, vaultId, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vault = PdaClient_1.PdaClient.deriveLpVault(0);
+            const vaultPool = PdaClient_1.PdaClient.deriveLpVaultPool(0);
+            const { depositTokenMint, receiptTokenMint } = yield reflect_tokenised_bonds_1.Vault
+                .fromAccountAddress(this.connection, vault);
+            const signerDepositTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(depositTokenMint, signer);
+            const signerReceiptTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(receiptTokenMint, signer);
+            const ix = (0, reflect_tokenised_bonds_1.createDepositInstruction)({
+                vault,
+                depositToken: depositTokenMint,
+                pool: vaultPool,
+                receiptToken: receiptTokenMint,
+                signer,
+                signerDepositTokenAccount,
+                signerReceiptTokenAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            }, {
+                args: {
+                    amount,
+                    isRewards: false,
+                    vaultId
+                }
+            });
+            return ix;
+        });
+    }
+    withdraw(signer, vaultId, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vault = PdaClient_1.PdaClient.deriveLpVault(0);
+            const vaultPool = PdaClient_1.PdaClient.deriveLpVaultPool(0);
+            const { depositTokenMint, receiptTokenMint } = yield reflect_tokenised_bonds_1.Vault
+                .fromAccountAddress(this.connection, vault);
+            const signerDepositTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(depositTokenMint, signer);
+            const signerReceiptTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(receiptTokenMint, signer);
+            const ix = (0, reflect_tokenised_bonds_1.createWithdrawInstruction)({
+                depositMint: depositTokenMint,
+                pool: vaultPool,
+                receiptMint: receiptTokenMint,
+                signer,
+                signerDepositTokenAccount,
+                signerReceiptTokenAccount,
+                vault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            }, {
+                args: {
+                    amount,
+                    vaultId
+                }
+            }, reflect_tokenised_bonds_1.PROGRAM_ID);
+            return ix;
+        });
+    }
+}
+exports.ReflectTokenisedBond = ReflectTokenisedBond;

package/dist/classes/Stablecoin.d.ts

@@ -0,0 +1,30 @@
+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/reflect_main";
+import { StablecoinMetadata, Collateral } from "../types";
+export declare abstract class Stablecoin {
+    index: number;
+    name: string;
+    connection: Connection;
+    controller: PublicKey;
+    collaterals: Collateral[];
+    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>;
+    updateRecipients(signer: PublicKey, recipients: Map<PublicKey, number>): Promise<TransactionInstruction>;
+    initializeStablecoinDriftAccount(signer: PublicKey, subAccountId?: number): Promise<TransactionInstruction>;
+    initializeStablecoinDriftStatsAccount(signer: PublicKey): Promise<TransactionInstruction>;
+    freeze(signer: PublicKey, freeze: boolean, action: Action): Promise<TransactionInstruction>;
+    initializeStablecoin(signer: PublicKey, tokenKeypair: Keypair, metadata?: StablecoinMetadata): Promise<TransactionInstruction[]>;
+    updateRebalanceSlippage(signer: PublicKey, slippage: number): Promise<TransactionInstruction>;
+    getCollateralPrice(mint: PublicKey): Promise<void>;
+    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[]>;
+}