@reflectmoney/stable.ts 2.9.1 → 3.0.0

package/dist/classes/ReflectKeeper.d.ts

@@ -1,5 +1,4 @@
-import { Connection, PublicKey } from "@solana/web3.js";
-import { Action, Role, Update, UserPermissions } from "../generated/reflect_main";
+import { Address, TransactionSigner, Rpc, SolanaRpcApi } from "@solana/kit";
 /**
  * Administrative client for the Reflect protocol.
  * Provides functionality for protocol-level administration including:
@@ -10,110 +9,124 @@ import { Action, Role, Update, UserPermissions } from "../generated/reflect_main
  *
  * This class is used by protocol administrators to manage global settings,
  * user permissions, and protocol-wide configurations.
+ *
+ * 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 ReflectKeeper {
-    /** Public key of the admin user */
+    /** Address of the admin user */
     private admin;
-    /** Public key of the main program account */
+    /** Address of the main program account */
     private main;
-    /** Solana connection instance for RPC communication */
-    private connection;
+    /** Solana RPC instance for communication */
+    private rpc;
+    /** Whether to use devnet program */
     private devnet;
+    /** Whether to use mock program on mainnet (only applies when devnet=false) */
+    private mock;
     /**
      * Creates a new ReflectKeeper instance.
      *
-     * @param admin - Public key of the admin user
-     * @param connection - Solana connection instance
+     * @param admin - Address of the admin user
+     * @param rpc - Solana RPC instance
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
      */
-    constructor({ admin, connection, devnet, }: {
-        admin: PublicKey;
-        connection: Connection;
+    constructor({ admin, rpc, devnet, mock, }: {
+        admin: Address;
+        rpc: Rpc<SolanaRpcApi>;
         devnet?: boolean;
+        mock?: boolean;
     });
+    /**
+     * Initialize the keeper by deriving necessary PDAs
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the program address based on network configuration.
+     * - devnet=true → devnet program
+     * - devnet=false, mock=true → mock program on mainnet
+     * - devnet=false, mock=false → production mainnet program
+     */
+    get programAddress(): Address;
     /**
      * Creates the main program account. This is the initial step of protocol setup.
      *
-     * @param admin - Public key of the initial admin
-     * @returns TransactionInstruction for initializing the main account
+     * @param admin - TransactionSigner of the initial admin
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
+     * @returns Instruction for initializing the main account
      */
-    static initializeMain(admin: PublicKey, devnet?: boolean): import("@solana/web3.js").TransactionInstruction;
-    getPermissionAccount(): Promise<UserPermissions>;
+    static initializeMain(admin: TransactionSigner, devnet?: boolean, mock?: boolean): Promise<import("../generated/reflect_main").InitMainInstruction<Address, string, string, string, string, []>>;
     /**
      * Freezes or unfreezes a specific protocol action.
      *
+     * @param admin - TransactionSigner of the admin
      * @param freeze - Whether to freeze (true) or unfreeze (false) the action
-     * @param action - The action to freeze/unfreeze
-     * @returns TransactionInstruction
+     * @param action - The action to freeze/unfreeze (as u8)
+     * @returns Instruction
      */
-    freezeProtocolAction(freeze: boolean, action: Action): import("@solana/web3.js").TransactionInstruction;
+    freezeProtocolAction(admin: TransactionSigner, freeze: boolean, action: number): Promise<import("../generated/reflect_main").FreezeProtocolActionInstruction<Address, string, string, string, string, []>>;
     /**
      * Freezes or unfreezes a specific DEX program.
      *
+     * @param admin - TransactionSigner of the admin
      * @param freeze - Whether to freeze (true) or unfreeze (false) the program
      * @param programIndex - Index of the program to freeze/unfreeze
-     * @returns TransactionInstruction
+     * @returns Instruction
      */
-    freezeDex(freeze: boolean, programIndex: number): import("@solana/web3.js").TransactionInstruction;
+    freezeDex(admin: TransactionSigner, freeze: boolean, programIndex: number): Promise<import("../generated/reflect_main").FreezeProgramInstruction<Address, string, string, string, string, []>>;
     /**
      * Creates a new admin account with specified permissions.
      *
-     * @param signer - Public key of the caller (must be existing admin)
-     * @param newAdmin - Public key of the new admin to create
-     * @returns TransactionInstruction
+     * @param caller - TransactionSigner of the caller (must be existing admin)
+     * @param newAdmin - Address of the new admin to create
+     * @param roles - Number of roles to allocate
+     * @returns Instruction
      */
-    createAdminAccount(signer: PublicKey, newAdmin: PublicKey, roles?: number): import("@solana/web3.js").TransactionInstruction;
+    createAdminAccount(caller: TransactionSigner, newAdmin: Address, roles?: number): Promise<import("../generated/reflect_main").CreateAdminAccountInstruction<Address, string, string, string, []>>;
     /**
      * Updates role holder permissions at the protocol level.
      *
-     * @param signer - Public key of the admin signer
-     * @param adminToUpdate - Public key of the admin whose permissions are being updated
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param admin - TransactionSigner of the admin
+     * @param adminToUpdate - Address of the admin whose permissions are being updated
+     * @param accessLevel - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateRoleHolderProtocol(signer: PublicKey, adminToUpdate: PublicKey, affectedRole: Role, update: Update): import("@solana/web3.js").TransactionInstruction;
+    updateRoleHolderProtocol(admin: TransactionSigner, adminToUpdate: Address, accessLevel: number, update: number): Promise<import("../generated/reflect_main").UpdateRoleHolderProtocolInstruction<Address, string, string, string, string, string, string, []>>;
     /**
      * Updates role holder permissions for a specific strategy.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @param strategyId - ID of the strategy to update permissions for
-     * @param adminToUpdate - Public key of the admin whose permissions are being updated
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param adminToUpdate - Address of the admin whose permissions are being updated
+     * @param role - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateRoleHolderStrategy(signer: PublicKey, strategyId: number, adminToUpdate: PublicKey, affectedRole: Role, update: Update): import("@solana/web3.js").TransactionInstruction;
+    updateRoleHolderStrategy(admin: TransactionSigner, strategyId: number, adminToUpdate: Address, role: number, update: number): Promise<import("../generated/reflect_main").UpdateRoleHolderStrategyInstruction<Address, string, string, string, string, string, string, []>>;
     /**
      * Updates action role permissions for a specific strategy.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @param strategyId - ID of the strategy to update permissions for
-     * @param action - The action being modified
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param action - The action being modified (as u8)
+     * @param role - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateActionRoleStrategy(signer: PublicKey, strategyId: number, action: Action, affectedRole: Role, update: Update): import("@solana/web3.js").TransactionInstruction;
+    updateActionRoleStrategy(admin: TransactionSigner, strategyId: number, action: number, role: number, update: number): Promise<import("../generated/reflect_main").UpdateActionRoleStrategyInstruction<Address, string, string, string, string, string, []>>;
     /**
      * Updates action role permissions at the protocol level.
      *
-     * @param signer - Public key of the admin signer
-     * @param action - The action being modified
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param admin - TransactionSigner of the admin
+     * @param action - The action being modified (as u8)
+     * @param role - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateActionRoleProtocol(signer: PublicKey, action: Action, affectedRole: Role, update: Update): import("@solana/web3.js").TransactionInstruction;
-    fetchAllAdminAccounts(): Promise<{
-        pubkey: PublicKey;
-        account: UserPermissions;
-    }[]>;
-    fetchAdminByRole(role: Role): Promise<{
-        pubkey: PublicKey;
-        account: UserPermissions;
-    }[]>;
-    fetchAdminByStrategyRole(strategy: number, role: Role): Promise<{
-        pubkey: PublicKey;
-        account: UserPermissions;
-    }[]>;
+    updateActionRoleProtocol(admin: TransactionSigner, action: number, role: number, update: number): Promise<import("../generated/reflect_main").UpdateActionRoleProtocolInstruction<Address, string, string, string, string, []>>;
 }

package/dist/classes/ReflectKeeper.js

@@ -10,10 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReflectKeeper = void 0;
-const web3_js_1 = require("@solana/web3.js");
 const reflect_main_1 = require("../generated/reflect_main");
+const getProgramAddress_1 = require("../utils/getProgramAddress");
 const PdaClient_1 = require("./PdaClient");
-const devnet_1 = require("../constants/devnet");
 /**
  * Administrative client for the Reflect protocol.
  * Provides functionality for protocol-level administration including:
@@ -24,224 +23,242 @@ const devnet_1 = require("../constants/devnet");
  *
  * This class is used by protocol administrators to manage global settings,
  * user permissions, and protocol-wide configurations.
+ *
+ * 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 ReflectKeeper {
     /**
      * Creates a new ReflectKeeper instance.
      *
-     * @param admin - Public key of the admin user
-     * @param connection - Solana connection instance
+     * @param admin - Address of the admin user
+     * @param rpc - Solana RPC instance
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
      */
-    constructor({ admin, connection, devnet = false, }) {
+    constructor({ admin, rpc, devnet = false, mock = false, }) {
+        /** Address of the main program account */
+        this.main = null;
         this.admin = admin;
-        this.connection = connection;
+        this.rpc = rpc;
         this.devnet = devnet;
-        this.main = PdaClient_1.PdaClient.deriveMain(devnet);
+        this.mock = mock;
+    }
+    /**
+     * Initialize the keeper by deriving necessary PDAs
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.main = yield PdaClient_1.PdaClient.deriveMain(this.devnet, this.mock);
+        });
+    }
+    /**
+     * Get the program address based on network configuration.
+     * - devnet=true → devnet program
+     * - devnet=false, mock=true → mock program on mainnet
+     * - devnet=false, mock=false → production mainnet program
+     */
+    get programAddress() {
+        return (0, getProgramAddress_1.getProgramAddress)({ devnet: this.devnet, mock: this.mock });
     }
     /**
      * Creates the main program account. This is the initial step of protocol setup.
      *
-     * @param admin - Public key of the initial admin
-     * @returns TransactionInstruction for initializing the main account
+     * @param admin - TransactionSigner of the initial admin
+     * @param devnet - Whether to use devnet program
+     * @param mock - Whether to use mock program on mainnet (only applies when devnet=false)
+     * @returns Instruction for initializing the main account
      */
-    static initializeMain(admin, devnet) {
-        const [main] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("main")], devnet ? devnet_1.DEVNET_PROGRAM_ID : 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, devnet),
-        }, devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
-    }
-    getPermissionAccount() {
+    static initializeMain(admin, devnet, mock) {
         return __awaiter(this, void 0, void 0, function* () {
-            const permissions = PdaClient_1.PdaClient.derivePermissions(this.admin, this.devnet);
-            const permissionsAccount = yield reflect_main_1.UserPermissions.fromAccountAddress(this.connection, permissions);
-            return permissionsAccount;
+            const main = yield PdaClient_1.PdaClient.deriveMain(devnet, mock);
+            const creds = yield PdaClient_1.PdaClient.derivePermissions(admin.address, devnet, mock);
+            const programAddress = (0, getProgramAddress_1.getProgramAddress)({ devnet, mock });
+            const ix = (0, reflect_main_1.getInitMainInstruction)({
+                main,
+                admin,
+                creds,
+            }, { programAddress });
+            return ix;
         });
     }
     /**
      * Freezes or unfreezes a specific protocol action.
      *
+     * @param admin - TransactionSigner of the admin
      * @param freeze - Whether to freeze (true) or unfreeze (false) the action
-     * @param action - The action to freeze/unfreeze
-     * @returns TransactionInstruction
+     * @param action - The action to freeze/unfreeze (as u8)
+     * @returns Instruction
      */
-    freezeProtocolAction(freeze, action) {
-        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, this.devnet),
-        }, {
-            freeze,
-            action,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
+    freezeProtocolAction(admin, freeze, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.main)
+                yield this.initialize();
+            const adminPermissions = yield PdaClient_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getFreezeProtocolActionInstruction)({
+                admin,
+                main: this.main,
+                adminPermissions,
+                freeze,
+                action,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
     }
     /**
      * Freezes or unfreezes a specific DEX program.
      *
+     * @param admin - TransactionSigner of the admin
      * @param freeze - Whether to freeze (true) or unfreeze (false) the program
      * @param programIndex - Index of the program to freeze/unfreeze
-     * @returns TransactionInstruction
+     * @returns Instruction
      */
-    freezeDex(freeze, programIndex) {
-        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, this.devnet),
-        }, {
-            freeze,
-            programIndex,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
+    freezeDex(admin, freeze, programIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.main)
+                yield this.initialize();
+            const adminPermissions = yield PdaClient_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getFreezeProgramInstruction)({
+                admin,
+                main: this.main,
+                adminPermissions,
+                freeze,
+                programIndex,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
     }
     /**
      * Creates a new admin account with specified permissions.
      *
-     * @param signer - Public key of the caller (must be existing admin)
-     * @param newAdmin - Public key of the new admin to create
-     * @returns TransactionInstruction
+     * @param caller - TransactionSigner of the caller (must be existing admin)
+     * @param newAdmin - Address of the new admin to create
+     * @param roles - Number of roles to allocate
+     * @returns Instruction
      */
-    createAdminAccount(signer, newAdmin, roles = 18) {
-        const ix = (0, reflect_main_1.createCreateAdminAccountInstruction)({
-            caller: signer,
-            newCreds: PdaClient_1.PdaClient.derivePermissions(newAdmin, this.devnet),
-            systemProgram: web3_js_1.SystemProgram.programId,
-        }, {
-            newAdmin,
-            roles,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
+    createAdminAccount(caller_1, newAdmin_1) {
+        return __awaiter(this, arguments, void 0, function* (caller, newAdmin, roles = 18) {
+            const newCreds = yield PdaClient_1.PdaClient.derivePermissions(newAdmin, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getCreateAdminAccountInstruction)({
+                caller,
+                newCreds,
+                newAdmin,
+                roles,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
     }
     /**
      * Updates role holder permissions at the protocol level.
      *
-     * @param signer - Public key of the admin signer
-     * @param adminToUpdate - Public key of the admin whose permissions are being updated
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param admin - TransactionSigner of the admin
+     * @param adminToUpdate - Address of the admin whose permissions are being updated
+     * @param accessLevel - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateRoleHolderProtocol(signer, adminToUpdate, affectedRole, update) {
-        const ix = (0, reflect_main_1.createUpdateRoleHolderProtocolInstruction)({
-            admin: signer,
-            adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer, this.devnet),
-            main: PdaClient_1.PdaClient.deriveMain(this.devnet),
-            systemProgram: web3_js_1.SystemProgram.programId,
-            updateAdminPermissions: PdaClient_1.PdaClient.derivePermissions(adminToUpdate, this.devnet),
-            // Dummy strategy account.
-            strategy: PdaClient_1.PdaClient.deriveController(0, this.devnet),
-        }, {
-            update,
-            accessLevel: affectedRole,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
+    updateRoleHolderProtocol(admin, adminToUpdate, accessLevel, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.main)
+                yield this.initialize();
+            const adminPermissions = yield PdaClient_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const updateAdminPermissions = yield PdaClient_1.PdaClient.derivePermissions(adminToUpdate, this.devnet, this.mock);
+            // Dummy strategy account
+            const strategy = yield PdaClient_1.PdaClient.deriveController(0, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getUpdateRoleHolderProtocolInstruction)({
+                admin,
+                adminPermissions,
+                main: this.main,
+                updateAdminPermissions,
+                strategy,
+                accessLevel,
+                update,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
     }
     /**
      * Updates role holder permissions for a specific strategy.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @param strategyId - ID of the strategy to update permissions for
-     * @param adminToUpdate - Public key of the admin whose permissions are being updated
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param adminToUpdate - Address of the admin whose permissions are being updated
+     * @param role - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateRoleHolderStrategy(signer, strategyId, adminToUpdate, affectedRole, update) {
-        const ix = (0, reflect_main_1.createUpdateRoleHolderStrategyInstruction)({
-            admin: signer,
-            adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer, this.devnet),
-            main: PdaClient_1.PdaClient.deriveMain(this.devnet),
-            systemProgram: web3_js_1.SystemProgram.programId,
-            updateAdminPermissions: PdaClient_1.PdaClient.derivePermissions(adminToUpdate, this.devnet),
-            strategy: PdaClient_1.PdaClient.deriveController(strategyId, this.devnet),
-        }, {
-            update,
-            role: affectedRole,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
+    updateRoleHolderStrategy(admin, strategyId, adminToUpdate, role, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.main)
+                yield this.initialize();
+            const adminPermissions = yield PdaClient_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const updateAdminPermissions = yield PdaClient_1.PdaClient.derivePermissions(adminToUpdate, this.devnet, this.mock);
+            const strategy = yield PdaClient_1.PdaClient.deriveController(strategyId, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getUpdateRoleHolderStrategyInstruction)({
+                admin,
+                adminPermissions,
+                main: this.main,
+                updateAdminPermissions,
+                strategy,
+                role,
+                update,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
     }
     /**
      * Updates action role permissions for a specific strategy.
      *
-     * @param signer - Public key of the admin signer
+     * @param admin - TransactionSigner of the admin
      * @param strategyId - ID of the strategy to update permissions for
-     * @param action - The action being modified
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param action - The action being modified (as u8)
+     * @param role - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateActionRoleStrategy(signer, strategyId, action, affectedRole, update) {
-        const ix = (0, reflect_main_1.createUpdateActionRoleStrategyInstruction)({
-            admin: signer,
-            adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer, this.devnet),
-            main: PdaClient_1.PdaClient.deriveMain(this.devnet),
-            systemProgram: web3_js_1.SystemProgram.programId,
-            strategy: PdaClient_1.PdaClient.deriveController(strategyId, this.devnet),
-        }, {
-            update,
-            role: affectedRole,
-            action,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
+    updateActionRoleStrategy(admin, strategyId, action, role, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.main)
+                yield this.initialize();
+            const adminPermissions = yield PdaClient_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const strategy = yield PdaClient_1.PdaClient.deriveController(strategyId, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getUpdateActionRoleStrategyInstruction)({
+                admin,
+                adminPermissions,
+                main: this.main,
+                strategy,
+                action,
+                role,
+                update,
+            }, { programAddress: this.programAddress });
+            return ix;
+        });
     }
     /**
      * Updates action role permissions at the protocol level.
      *
-     * @param signer - Public key of the admin signer
-     * @param action - The action being modified
-     * @param affectedRole - The role being modified
-     * @param update - The type of update (Grant or Revoke)
-     * @returns TransactionInstruction
+     * @param admin - TransactionSigner of the admin
+     * @param action - The action being modified (as u8)
+     * @param role - The role being modified (as u8)
+     * @param update - The type of update: 0 = Add, 1 = Remove
+     * @returns Instruction
      */
-    updateActionRoleProtocol(signer, action, affectedRole, update) {
-        const ix = (0, reflect_main_1.createUpdateActionRoleProtocolInstruction)({
-            admin: signer,
-            adminPermissions: PdaClient_1.PdaClient.derivePermissions(signer, this.devnet),
-            main: PdaClient_1.PdaClient.deriveMain(this.devnet),
-            systemProgram: web3_js_1.SystemProgram.programId,
-        }, {
-            action,
-            role: affectedRole,
-            update,
-        }, this.devnet ? devnet_1.DEVNET_PROGRAM_ID : reflect_main_1.PROGRAM_ID);
-        return ix;
-    }
-    fetchAllAdminAccounts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield reflect_main_1.UserPermissions.gpaBuilder(reflect_main_1.PROGRAM_ID)
-                .addFilter("accountDiscriminator", reflect_main_1.userPermissionsDiscriminator)
-                .run(this.connection);
-            return data
-                .map(({ pubkey, account: { data } }) => {
-                const [account] = reflect_main_1.UserPermissions.deserialize(data);
-                return {
-                    pubkey,
-                    account,
-                };
-            });
-        });
-    }
-    fetchAdminByRole(role) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.fetchAllAdminAccounts();
-            return data.filter(({ account }) => account.protocolRoles.roles.includes(role));
-        });
-    }
-    fetchAdminByStrategyRole(strategy, role) {
+    updateActionRoleProtocol(admin, action, role, update) {
         return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.fetchAllAdminAccounts();
-            const strategyPermissionAccounts = data
-                .filter(({ account }) => account.strategyRoles.some(({ strategyId }) => strategyId === strategy));
-            return strategyPermissionAccounts.filter(({ account }) => {
-                var _a;
-                return (_a = account.strategyRoles
-                    .find(({ strategyId }) => strategyId === strategy)) === null || _a === void 0 ? void 0 : _a.roles.roles.includes(role);
-            });
+            if (!this.main)
+                yield this.initialize();
+            const adminPermissions = yield PdaClient_1.PdaClient.derivePermissions(admin.address, this.devnet, this.mock);
+            const ix = (0, reflect_main_1.getUpdateActionRoleProtocolInstruction)({
+                admin,
+                adminPermissions,
+                main: this.main,
+                action,
+                role,
+                update,
+            }, { programAddress: this.programAddress });
+            return ix;
         });
     }
 }