@reflectmoney/stable.ts 2.9.1 → 3.0.0

package/dist/classes/PdaClient.d.ts

@@ -1,131 +1,109 @@
-import { PublicKey } from "@solana/web3.js";
+import { Address } from "@solana/kit";
 /**
  * Utility class for deriving Program Derived Addresses (PDAs) used throughout the Reflect protocol.
  * Provides static methods to generate deterministic addresses for various program accounts
  * including main program accounts, controllers, permissions, and external protocol integrations.
+ *
+ * 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 PdaClient {
     /**
      * Derives the main program account address.
      * This is the primary account that stores global protocol state.
      *
-     * @returns PublicKey of the main program account
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (ignored if devnet=true)
+     * @returns Promise resolving to Address of the main program account
      */
-    static deriveMain(devnet?: boolean): PublicKey;
+    static deriveMain(devnet?: boolean, mock?: boolean): Promise<Address>;
     /**
      * Derives the permissions account address for a specific user.
      * This account stores the user's role-based permissions within the protocol.
      *
-     * @param user - Public key of the user
-     * @returns PublicKey of the user's permissions account
+     * @param user - Address of the user
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to Address of the user's permissions account
      */
-    static derivePermissions(user: PublicKey, devnet?: boolean): PublicKey;
+    static derivePermissions(user: Address, devnet?: boolean, mock?: boolean): Promise<Address>;
     /**
      * Derives the controller account address for a specific strategy.
      * Each stablecoin strategy has its own controller account.
      *
-     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
-     * @returns PublicKey of the strategy controller account
+     * @param strategy - Strategy index (0: USDC+, 1: USDT+)
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to Address of the strategy controller account
      */
-    static deriveController(strategy: number, devnet?: boolean): PublicKey;
+    static deriveController(strategy: number, devnet?: boolean, mock?: boolean): Promise<Address>;
     /**
      * Derives the controller account address with bump seed for a specific strategy.
-     * Returns both the public key and the bump seed.
+     * Returns both the address and the bump seed.
      *
-     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
-     * @returns Array containing [PublicKey, number] where number is the bump seed
+     * @param strategy - Strategy index (0: USDC+, 1: USDT+)
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to [Address, number] where number is the bump seed
      */
-    static deriveControllerWithBump(strategy: number, devnet?: boolean): [PublicKey, number];
+    static deriveControllerWithBump(strategy: number, devnet?: boolean, mock?: boolean): Promise<[Address, number]>;
     /**
      * Derives the rebalance details account address for a specific strategy.
      * This account stores information about rebalancing operations.
      *
-     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
-     * @returns PublicKey of the rebalance details account
+     * @param strategy - Strategy index (0: USDC+, 1: USDT+)
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to Address of the rebalance details account
      */
-    static deriveRebalanceDetails(strategy: number, devnet?: boolean): PublicKey;
-    /**
-     * Derives the Jupiter Perpetuals program account address.
-     * Used for integration with Jupiter's perpetuals protocol.
-     *
-     * @returns PublicKey of the Jupiter Perpetuals account
-     */
-    static deriveJupiterPerpetuals(devnet?: boolean): PublicKey;
-    /**
-     * Derives the Jupiter LP pool account address.
-     * Used for JLP (Jupiter LP) token operations.
-     *
-     * @returns PublicKey of the JLP pool account
-     */
-    static deriveJlpPool(): PublicKey;
-    /**
-     * Derives the Jupiter event authority account address.
-     * Used for event emission in Jupiter protocol interactions.
-     *
-     * @returns PublicKey of the Jupiter event authority account
-     */
-    static deriveEventAuthority(): PublicKey;
-    /**
-     * Derives the Jupiter transfer authority account address.
-     * Used for token transfer operations in Jupiter protocol.
-     *
-     * @returns PublicKey of the Jupiter transfer authority account
-     */
-    static deriveTransferAuthority(): PublicKey;
+    static deriveRebalanceDetails(strategy: number, devnet?: boolean, mock?: boolean): Promise<Address>;
     /**
      * Gets the Drift vault address for a specific mint.
      * Looks up the market index for the mint and derives the corresponding vault address.
      *
-     * @param mint - Public key of the token mint
-     * @returns Promise resolving to the PublicKey of the Drift vault account
+     * @param mint - Address of the token mint
+     * @returns Promise resolving to the Address of the Drift vault account
      */
-    static getDriftVaultFromMint(mint: PublicKey): Promise<PublicKey>;
+    static getDriftVaultFromMint(mint: Address): Promise<Address>;
     /**
      * Derives the token metadata account address for a mint.
      * Used for storing token metadata information.
      *
-     * @param mint - Public key of the token mint
-     * @returns PublicKey of the metadata account
-     */
-    static deriveMetadataAccount(mint: PublicKey): PublicKey;
-    /**
-     * Derives the custody account address for a pool and token combination.
-     * Used in Jupiter protocol for token custody management.
-     *
-     * @param pool - Public key of the pool
-     * @param token - Public key of the token
-     * @returns PublicKey of the custody account
+     * @param mint - Address of the token mint
+     * @returns Promise resolving to Address of the metadata account
      */
-    static deriveCustody(pool: PublicKey, token: PublicKey): PublicKey;
+    static deriveMetadataAccount(mint: Address): Promise<Address>;
     /**
      * Derives the LP config account address.
      * Used for tokenized bonds program configuration.
      *
-     * @returns PublicKey of the LP config account
+     * @returns Promise resolving to Address of the LP config account
      */
-    static deriveLpConfig(): PublicKey;
+    static deriveLpConfig(): Promise<Address>;
     /**
      * Derives the LP admin account address for a specific admin.
      * Used for tokenized bonds program administration.
      *
-     * @param admin - Public key of the admin
-     * @returns PublicKey of the LP admin account
+     * @param admin - Address of the admin
+     * @returns Promise resolving to Address of the LP admin account
      */
-    static deriveLpAdmin(admin: PublicKey): PublicKey;
+    static deriveLpAdmin(admin: Address): Promise<Address>;
     /**
      * Derives the LP vault account address for a specific vault ID.
      * Used for tokenized bonds vault management.
      *
      * @param vaultId - Numeric identifier for the vault
-     * @returns PublicKey of the LP vault account
+     * @returns Promise resolving to Address of the LP vault account
      */
-    static deriveLpVault(vaultId: number): PublicKey;
+    static deriveLpVault(vaultId: number): Promise<Address>;
     /**
      * Derives the LP vault pool account address for a specific vault ID.
      * Used for tokenized bonds vault pool management.
      *
      * @param vaultId - Numeric identifier for the vault
-     * @returns PublicKey of the LP vault pool account
+     * @returns Promise resolving to Address of the LP vault pool account
      */
-    static deriveLpVaultPool(vaultId: number): PublicKey;
+    static deriveLpVaultPool(vaultId: number): Promise<Address>;
 }

package/dist/classes/PdaClient.js

@@ -13,232 +13,252 @@ var __importDefault = (this && this.__importDefault) || function (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 devnet_1 = require("../constants/devnet");
+const kit_1 = require("@solana/kit");
 const reflect_tokenised_bonds_1 = require("../generated/reflect_tokenised_bonds");
 const constants_1 = require("../constants");
+const getProgramAddress_1 = require("../utils/getProgramAddress");
 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");
+const web3_js_1 = require("@solana/web3.js");
+// Token Metadata Program ID
+const TOKEN_METADATA_PROGRAM_ID = (0, kit_1.address)("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
 /**
  * Utility class for deriving Program Derived Addresses (PDAs) used throughout the Reflect protocol.
  * Provides static methods to generate deterministic addresses for various program accounts
  * including main program accounts, controllers, permissions, and external protocol integrations.
+ *
+ * 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 PdaClient {
     /**
      * Derives the main program account address.
      * This is the primary account that stores global protocol state.
      *
-     * @returns PublicKey of the main program account
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (ignored if devnet=true)
+     * @returns Promise resolving to Address of the main program account
      */
-    static deriveMain(devnet) {
-        const [main] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("main")], devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return main;
+    static deriveMain(devnet, mock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const programId = (0, getProgramAddress_1.getProgramAddress)({ devnet, mock });
+            const [main] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: programId,
+                seeds: [Buffer.from("main")],
+            });
+            return main;
+        });
     }
     /**
      * Derives the permissions account address for a specific user.
      * This account stores the user's role-based permissions within the protocol.
      *
-     * @param user - Public key of the user
-     * @returns PublicKey of the user's permissions account
+     * @param user - Address of the user
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to Address of the user's permissions account
      */
-    static derivePermissions(user, devnet) {
-        const [permissions] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("user_permission"),
-            user.toBuffer()
-        ], devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return permissions;
+    static derivePermissions(user, devnet, mock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const programId = (0, getProgramAddress_1.getProgramAddress)({ devnet, mock });
+            const encoder = (0, kit_1.getAddressEncoder)();
+            const userBytes = encoder.encode(user);
+            const [permissions] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: programId,
+                seeds: [
+                    "user_permission",
+                    userBytes
+                ],
+            });
+            return permissions;
+        });
     }
     /**
      * Derives the controller account address for a specific strategy.
      * Each stablecoin strategy has its own controller account.
      *
-     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
-     * @returns PublicKey of the strategy controller account
+     * @param strategy - Strategy index (0: USDC+, 1: USDT+)
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to Address of the strategy controller account
      */
-    static deriveController(strategy, devnet) {
-        const [controller] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("dex_controller"),
-            Buffer.from([strategy])
-        ], devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return controller;
+    static deriveController(strategy, devnet, mock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const programId = (0, getProgramAddress_1.getProgramAddress)({ devnet, mock });
+            const [controller] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: programId,
+                seeds: [
+                    Buffer.from("dex_controller"),
+                    Buffer.from([strategy])
+                ],
+            });
+            return controller;
+        });
     }
     /**
      * Derives the controller account address with bump seed for a specific strategy.
-     * Returns both the public key and the bump seed.
+     * Returns both the address and the bump seed.
      *
-     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
-     * @returns Array containing [PublicKey, number] where number is the bump seed
+     * @param strategy - Strategy index (0: USDC+, 1: USDT+)
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to [Address, number] where number is the bump seed
      */
-    static deriveControllerWithBump(strategy, devnet) {
-        return web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("dex_controller"),
-            Buffer.from([strategy])
-        ], devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
+    static deriveControllerWithBump(strategy, devnet, mock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const programId = (0, getProgramAddress_1.getProgramAddress)({ devnet, mock });
+            const [controller, bump] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: programId,
+                seeds: [
+                    Buffer.from("dex_controller"),
+                    Buffer.from([strategy])
+                ],
+            });
+            return [controller, bump];
+        });
     }
     /**
      * Derives the rebalance details account address for a specific strategy.
      * This account stores information about rebalancing operations.
      *
-     * @param strategy - Strategy index (0: USDC+, 1: JLP, 2: LST)
-     * @returns PublicKey of the rebalance details account
-     */
-    static deriveRebalanceDetails(strategy, devnet) {
-        const [rebalanceDetails] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("rebalance_details"),
-            this.deriveController(strategy).toBuffer()
-        ], devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return rebalanceDetails;
-    }
-    /**
-     * Derives the Jupiter Perpetuals program account address.
-     * Used for integration with Jupiter's perpetuals protocol.
-     *
-     * @returns PublicKey of the Jupiter Perpetuals account
-     */
-    static deriveJupiterPerpetuals(devnet) {
-        const [perpetuals] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("perpetuals")
-        ], devnet ? devnet_1.DEVNET_PROGRAM_ID : constants_1.JUPITER_PROGRAM_ID);
-        return perpetuals;
-    }
-    /**
-     * Derives the Jupiter LP pool account address.
-     * Used for JLP (Jupiter LP) token operations.
-     *
-     * @returns PublicKey of the JLP pool account
-     */
-    static deriveJlpPool() {
-        const [jlpPool] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("pool"),
-            Buffer.from("Pool")
-        ], constants_1.JUPITER_PROGRAM_ID);
-        return jlpPool;
-    }
-    /**
-     * Derives the Jupiter event authority account address.
-     * Used for event emission in Jupiter protocol interactions.
-     *
-     * @returns PublicKey of the Jupiter event authority account
-     */
-    static deriveEventAuthority() {
-        const [eventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("__event_authority"),
-        ], constants_1.JUPITER_PROGRAM_ID);
-        return eventAuthority;
-    }
-    /**
-     * Derives the Jupiter transfer authority account address.
-     * Used for token transfer operations in Jupiter protocol.
-     *
-     * @returns PublicKey of the Jupiter transfer authority account
+     * @param strategy - Strategy index (0: USDC+, 1: USDT+)
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet
+     * @returns Promise resolving to Address of the rebalance details account
      */
-    static deriveTransferAuthority() {
-        const [transferAuthority] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("transfer_authority"),
-        ], constants_1.JUPITER_PROGRAM_ID);
-        return transferAuthority;
+    static deriveRebalanceDetails(strategy, devnet, mock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const programId = (0, getProgramAddress_1.getProgramAddress)({ devnet, mock });
+            const controller = yield this.deriveController(strategy, devnet, mock);
+            const encoder = (0, kit_1.getAddressEncoder)();
+            const controllerBytes = encoder.encode(controller);
+            const [rebalanceDetails] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: programId,
+                seeds: [
+                    "rebalance_details",
+                    controllerBytes
+                ],
+            });
+            return rebalanceDetails;
+        });
     }
     /**
      * Gets the Drift vault address for a specific mint.
      * Looks up the market index for the mint and derives the corresponding vault address.
      *
-     * @param mint - Public key of the token mint
-     * @returns Promise resolving to the PublicKey of the Drift vault account
+     * @param mint - Address of the token mint
+     * @returns Promise resolving to the Address of the Drift vault account
      */
     static getDriftVaultFromMint(mint) {
         return __awaiter(this, void 0, void 0, function* () {
+            const mintPubkey = new web3_js_1.PublicKey(mint);
             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);
+                .find(({ mint: marketMint }) => marketMint.equals(mintPubkey));
+            const vaultPubkey = yield (0, sdk_1.getSpotMarketVaultPublicKey)(new web3_js_1.PublicKey(constants_1.DRIFT_PROGRAM_ID), marketIndex);
+            return (0, kit_1.address)(vaultPubkey.toBase58());
         });
     }
     /**
      * Derives the token metadata account address for a mint.
      * Used for storing token metadata information.
      *
-     * @param mint - Public key of the token mint
-     * @returns PublicKey of the metadata account
+     * @param mint - Address of the token mint
+     * @returns Promise resolving to Address of the metadata account
      */
     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;
-    }
-    /**
-     * Derives the custody account address for a pool and token combination.
-     * Used in Jupiter protocol for token custody management.
-     *
-     * @param pool - Public key of the pool
-     * @param token - Public key of the token
-     * @returns PublicKey of the custody account
-     */
-    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;
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoder = (0, kit_1.getAddressEncoder)();
+            const metadataProgramBytes = encoder.encode(TOKEN_METADATA_PROGRAM_ID);
+            const mintBytes = encoder.encode(mint);
+            const [metadata] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: TOKEN_METADATA_PROGRAM_ID,
+                seeds: [
+                    "metadata",
+                    metadataProgramBytes,
+                    mintBytes,
+                ],
+            });
+            return metadata;
+        });
     }
     /**
      * Derives the LP config account address.
      * Used for tokenized bonds program configuration.
      *
-     * @returns PublicKey of the LP config account
+     * @returns Promise resolving to Address of the LP config account
      */
     static deriveLpConfig() {
-        const [config] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("config")
-        ], reflect_tokenised_bonds_1.PROGRAM_ID);
-        return config;
+        return __awaiter(this, void 0, void 0, function* () {
+            const [config] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: (0, kit_1.address)(reflect_tokenised_bonds_1.PROGRAM_ID.toBase58()),
+                seeds: [Buffer.from("config")],
+            });
+            return config;
+        });
     }
     /**
      * Derives the LP admin account address for a specific admin.
      * Used for tokenized bonds program administration.
      *
-     * @param admin - Public key of the admin
-     * @returns PublicKey of the LP admin account
+     * @param admin - Address of the admin
+     * @returns Promise resolving to Address of the LP admin account
      */
     static deriveLpAdmin(admin) {
-        const [adminPda] = web3_js_1.PublicKey.findProgramAddressSync([
-            Buffer.from("admin"),
-            admin.toBuffer()
-        ], reflect_tokenised_bonds_1.PROGRAM_ID);
-        return adminPda;
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoder = (0, kit_1.getAddressEncoder)();
+            const adminBytes = encoder.encode(admin);
+            const [adminPda] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: (0, kit_1.address)(reflect_tokenised_bonds_1.PROGRAM_ID.toBase58()),
+                seeds: [
+                    "admin",
+                    adminBytes
+                ],
+            });
+            return adminPda;
+        });
     }
     /**
      * Derives the LP vault account address for a specific vault ID.
      * Used for tokenized bonds vault management.
      *
      * @param vaultId - Numeric identifier for the vault
-     * @returns PublicKey of the LP vault account
+     * @returns Promise resolving to Address of the LP vault account
      */
     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;
+        return __awaiter(this, void 0, void 0, function* () {
+            const [vault] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: (0, kit_1.address)(reflect_tokenised_bonds_1.PROGRAM_ID.toBase58()),
+                seeds: [
+                    Buffer.from("vault"),
+                    new bn_js_1.default(vaultId).toArrayLike(Buffer, "le", 8)
+                ],
+            });
+            return vault;
+        });
     }
     /**
      * Derives the LP vault pool account address for a specific vault ID.
      * Used for tokenized bonds vault pool management.
      *
      * @param vaultId - Numeric identifier for the vault
-     * @returns PublicKey of the LP vault pool account
+     * @returns Promise resolving to Address of the LP vault pool account
      */
     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;
+        return __awaiter(this, void 0, void 0, function* () {
+            const vault = yield this.deriveLpVault(vaultId);
+            const encoder = (0, kit_1.getAddressEncoder)();
+            const vaultBytes = encoder.encode(vault);
+            const [pool] = yield (0, kit_1.getProgramDerivedAddress)({
+                programAddress: (0, kit_1.address)(reflect_tokenised_bonds_1.PROGRAM_ID.toBase58()),
+                seeds: [
+                    "vault_pool",
+                    vaultBytes
+                ],
+            });
+            return pool;
+        });
     }
 }
 exports.PdaClient = PdaClient;

package/dist/classes/Reflect.d.ts

@@ -1,7 +1,21 @@
-import { Connection } from "@solana/web3.js";
-import { Main } from "../generated/reflect_main";
+import { Rpc, SolanaRpcApi, Address } from "@solana/kit";
+/**
+ * Main Reflect protocol client for reading protocol state
+ */
 export declare class Reflect {
-    connection: Connection;
-    constructor(connection: Connection);
-    fetchMain(): Promise<Main>;
+    rpc: Rpc<SolanaRpcApi>;
+    devnet: boolean;
+    mock: boolean;
+    constructor(rpc: Rpc<SolanaRpcApi>, devnet?: boolean, mock?: boolean);
+    /**
+     * Get the main account address
+     */
+    getMainAddress(): Promise<Address>;
+    /**
+     * Fetch the main account data
+     * Note: Actual account fetching needs to be implemented with proper decoding
+     */
+    fetchMain(): Promise<{
+        address: Address;
+    }>;
 }

package/dist/classes/Reflect.js

@@ -11,16 +11,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reflect = void 0;
 const PdaClient_1 = require("./PdaClient");
-const reflect_main_1 = require("../generated/reflect_main");
+/**
+ * Main Reflect protocol client for reading protocol state
+ */
 class Reflect {
-    constructor(connection) {
-        this.connection = connection;
+    constructor(rpc, devnet = false, mock = false) {
+        this.rpc = rpc;
+        this.devnet = devnet;
+        this.mock = mock;
     }
+    /**
+     * Get the main account address
+     */
+    getMainAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return PdaClient_1.PdaClient.deriveMain(this.devnet);
+        });
+    }
+    /**
+     * Fetch the main account data
+     * Note: Actual account fetching needs to be implemented with proper decoding
+     */
     fetchMain() {
         return __awaiter(this, void 0, void 0, function* () {
-            const main = PdaClient_1.PdaClient.deriveMain();
-            const mainAccount = yield reflect_main_1.Main.fromAccountAddress(this.connection, main);
-            return mainAccount;
+            const main = yield PdaClient_1.PdaClient.deriveMain(this.devnet);
+            // Account fetching would be done here using the RPC
+            // This is a placeholder - actual implementation depends on account structure
+            return { address: main };
         });
     }
 }