@drift-labs/vaults-sdk 0.1.0

package/lib/vaultClient.js

@@ -0,0 +1,596 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultClient = void 0;
+const sdk_1 = require("@drift-labs/sdk");
+const anchor_1 = require("@coral-xyz/anchor");
+const addresses_1 = require("./addresses");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+class VaultClient {
+    constructor({ driftClient, program, cliMode, }) {
+        this.driftClient = driftClient;
+        this.program = program;
+        this.cliMode = !!cliMode;
+    }
+    async getVault(vault) {
+        return await this.program.account.vault.fetch(vault);
+    }
+    async getVaultDepositor(vaultDepositor) {
+        return await this.program.account.vaultDepositor.fetch(vaultDepositor);
+    }
+    async getAllVaultDepositors(vault) {
+        const filters = [
+            {
+                // discriminator = VaultDepositor
+                memcmp: {
+                    offset: 0,
+                    bytes: bytes_1.bs58.encode(anchor_1.BorshAccountsCoder.accountDiscriminator('VaultDepositor')),
+                },
+            },
+            {
+                // vault = vault
+                memcmp: {
+                    offset: 8,
+                    bytes: vault.toBase58(),
+                },
+            },
+            {
+                // last_withdraw_request_ts = 0
+                memcmp: {
+                    offset: 144,
+                    bytes: bytes_1.bs58.encode(Uint8Array.from([0])),
+                },
+            },
+        ];
+        // @ts-ignore
+        return (await this.program.account.vaultDepositor.all(filters));
+    }
+    /**
+     *
+     * @param vault pubkey
+     * @returns vault equity, in QUOTE_PRECISION
+     */
+    async calculateVaultEquity(params) {
+        let vaultAccount;
+        if (params.address !== undefined) {
+            vaultAccount = await this.program.account.vault.fetch(params.address);
+        }
+        else if (params.vault !== undefined) {
+            vaultAccount = params.vault;
+        }
+        else {
+            throw new Error('Must supply address or vault');
+        }
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const netSpotValue = user.getNetSpotMarketValue();
+        const unrealizedPnl = user.getUnrealizedPNL(true, undefined, undefined);
+        return netSpotValue.add(unrealizedPnl);
+    }
+    async initializeVault(params) {
+        const vault = addresses_1.getVaultAddressSync(this.program.programId, params.name);
+        const tokenAccount = addresses_1.getTokenVaultAddressSync(this.program.programId, vault);
+        const driftState = await this.driftClient.getStatePublicKey();
+        const spotMarket = this.driftClient.getSpotMarketAccount(params.spotMarketIndex);
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vault);
+        const userKey = sdk_1.getUserAccountPublicKeySync(this.driftClient.program.programId, vault);
+        const accounts = {
+            driftSpotMarket: spotMarket.pubkey,
+            driftSpotMarketMint: spotMarket.mint,
+            driftUserStats: userStatsKey,
+            driftUser: userKey,
+            driftState,
+            vault,
+            tokenAccount,
+            driftProgram: this.driftClient.program.programId,
+        };
+        return await this.program.methods
+            .initializeVault(params)
+            .accounts(accounts)
+            .rpc();
+    }
+    /**
+     * Updates the delegate address for a vault. The delegate address will be allowed to trade
+     * on behalf of the vault.
+     * @param vault vault address to update
+     * @param delegate delegate address to update to
+     * @returns
+     */
+    async updateDelegate(vault, delegate) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        return await this.program.methods
+            .updateDelegate(delegate)
+            .accounts({
+            vault: vault,
+            driftUser: vaultAccount.user,
+            driftProgram: this.driftClient.program.programId,
+        })
+            .rpc();
+    }
+    /**
+     *
+     * @param vault vault address to deposit to
+     * @param amount amount to deposit
+     * @returns
+     */
+    async managerDeposit(vault, amount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const driftSpotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        return await this.program.methods
+            .managerDeposit(amount)
+            .accounts({
+            vault,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUser: await sdk_1.getUserAccountPublicKey(this.driftClient.program.programId, vault),
+            driftProgram: this.driftClient.program.programId,
+            driftUserStats: sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vault),
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSpotMarketVault: driftSpotMarket.vault,
+            userTokenAccount: spl_token_1.getAssociatedTokenAddressSync(driftSpotMarket.mint, this.driftClient.wallet.publicKey),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .remainingAccounts(remainingAccounts)
+            .rpc();
+    }
+    async managerRequestWithdraw(vault, amount, withdrawUnit) {
+        const vaultAccount = (await this.program.account.vault.fetch(vault));
+        if (!this.driftClient.wallet.publicKey.equals(vaultAccount.manager)) {
+            throw new Error(`Only the manager of the vault can request a withdraw.`);
+        }
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vault);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            vault,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .managerRequestWithdraw(amount, withdrawUnit)
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const requestWithdrawIx = this.program.instruction.managerRequestWithdraw(amount, withdrawUnit, {
+                accounts: {
+                    manager: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([requestWithdrawIx]);
+        }
+    }
+    async managerCancelWithdrawRequest(vault) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vault);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            manager: this.driftClient.wallet.publicKey,
+            vault,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+        };
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+        });
+        if (this.cliMode) {
+            return await this.program.methods
+                .mangerCancelWithdrawRequest()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const cancelRequestWithdrawIx = this.program.instruction.mangerCancelWithdrawRequest({
+                accounts: {
+                    manager: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+        }
+    }
+    async managerWithdraw(vault) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        if (!this.driftClient.wallet.publicKey.equals(vaultAccount.manager)) {
+            throw new Error(`Only the manager of the vault can request a withdraw.`);
+        }
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const ix = this.program.instruction.managerWithdraw({
+            accounts: {
+                vault,
+                manager: this.driftClient.wallet.publicKey,
+                vaultTokenAccount: vaultAccount.tokenAccount,
+                driftUser: await sdk_1.getUserAccountPublicKey(this.driftClient.program.programId, vault),
+                driftProgram: this.driftClient.program.programId,
+                driftUserStats: sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vault),
+                driftState: await this.driftClient.getStatePublicKey(),
+                driftSpotMarketVault: spotMarket.vault,
+                userTokenAccount: spl_token_1.getAssociatedTokenAddressSync(spotMarket.mint, this.driftClient.wallet.publicKey),
+                driftSigner: this.driftClient.getStateAccount().signer,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+        return this.createAndSendTxn([ix], {
+            units: 1000000,
+        });
+    }
+    async managerUpdateVault(vault, params) {
+        return await this.program.methods
+            .updateVault(params)
+            .accounts({
+            vault,
+            manager: this.driftClient.wallet.publicKey,
+        })
+            .rpc();
+    }
+    async getApplyProfitShareIx(vault, vaultDepositor) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        const accounts = {
+            vault,
+            vaultDepositor,
+            manager: this.driftClient.wallet.publicKey,
+            driftUserStats: sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vault),
+            driftUser: await sdk_1.getUserAccountPublicKey(this.driftClient.program.programId, vault),
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSigner: this.driftClient.getStateAccount().signer,
+            driftProgram: this.driftClient.program.programId,
+        };
+        return this.program.instruction.applyProfitShare({
+            accounts: {
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+    }
+    createInitVaultDepositorIx(vault, authority) {
+        const vaultDepositor = addresses_1.getVaultDepositorAddressSync(this.program.programId, vault, authority);
+        const accounts = {
+            vaultDepositor,
+            vault,
+            authority: authority || this.driftClient.wallet.publicKey,
+        };
+        const initIx = this.program.instruction.initializeVaultDepositor({
+            accounts: {
+                ...accounts,
+                payer: authority || this.driftClient.wallet.publicKey,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            },
+        });
+        return initIx;
+    }
+    /**
+     * Initializes the vault depositor account. This account is used to deposit funds into a vault.
+     * @param vault the vault address to deposit into
+     * @param authority the authority allowed to make deposits into the vault
+     * @returns
+     */
+    async initializeVaultDepositor(vault, authority) {
+        const vaultDepositor = addresses_1.getVaultDepositorAddressSync(this.program.programId, vault, authority);
+        const accounts = {
+            vaultDepositor,
+            vault,
+            authority: authority || this.driftClient.wallet.publicKey,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .initializeVaultDepositor()
+                .accounts(accounts)
+                .rpc();
+        }
+        else {
+            const initIx = this.createInitVaultDepositorIx(vault, authority);
+            return await this.createAndSendTxn([initIx]);
+        }
+    }
+    /**
+     * Depositor funds into the specified vault.
+     * @param vaultDepositor
+     * @param amount
+     * @param initVaultDepositor If true, will initialize the vault depositor account
+     * @returns
+     */
+    async deposit(vaultDepositor, amount, initVaultDepositor) {
+        let vaultPubKey;
+        if (initVaultDepositor) {
+            vaultPubKey = initVaultDepositor.vault;
+        }
+        else {
+            const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+            vaultPubKey = vaultDepositorAccount.vault;
+        }
+        const vaultAccount = await this.program.account.vault.fetch(vaultPubKey);
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vaultPubKey);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        const accounts = {
+            vault: vaultPubKey,
+            vaultDepositor,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftSpotMarketVault: spotMarket.vault,
+            userTokenAccount: spl_token_1.getAssociatedTokenAddressSync(spotMarket.mint, this.driftClient.wallet.publicKey, true),
+            driftProgram: this.driftClient.program.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        if (this.cliMode) {
+            if (initVaultDepositor) {
+                await this.initializeVaultDepositor(vaultAccount.pubkey, initVaultDepositor.authority);
+            }
+            return await this.program.methods
+                .deposit(amount)
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const depositIx = this.program.instruction.deposit(amount, {
+                accounts: {
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            if (initVaultDepositor) {
+                const initIx = this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority);
+                return await this.createAndSendTxn([initIx, depositIx]);
+            }
+            else {
+                return await this.createAndSendTxn([depositIx]);
+            }
+        }
+    }
+    async requestWithdraw(vaultDepositor, amount, withdrawUnit) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+        });
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .requestWithdraw(amount, withdrawUnit)
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const requestWithdrawIx = this.program.instruction.requestWithdraw(amount, withdrawUnit, {
+                accounts: {
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([requestWithdrawIx]);
+        }
+    }
+    async withdraw(vaultDepositor) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        const accounts = {
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftSpotMarketVault: spotMarket.vault,
+            driftSigner: this.driftClient.getStateAccount().signer,
+            userTokenAccount: spl_token_1.getAssociatedTokenAddressSync(spotMarket.mint, this.driftClient.wallet.publicKey, true),
+            driftProgram: this.driftClient.program.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .withdraw()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const withdrawIx = this.program.instruction.withdraw({
+                accounts: {
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([withdrawIx]);
+        }
+    }
+    async cancelRequestWithdraw(vaultDepositor) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+        };
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+        });
+        if (this.cliMode) {
+            return await this.program.methods
+                .cancelRequestWithdraw()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const cancelRequestWithdrawIx = this.program.instruction.cancelRequestWithdraw({
+                accounts: {
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+        }
+    }
+    /**
+     * Liquidates (become delegate for) a vault.
+     * @param
+     * @param
+     * @returns
+     */
+    async liquidate(vaultDepositor) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultPubKey = vaultDepositorAccount.vault;
+        const vaultAccount = await this.program.account.vault.fetch(vaultPubKey);
+        const user = new sdk_1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey: vaultAccount.user,
+        });
+        await user.subscribe();
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        const userStatsKey = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, vaultPubKey);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            vault: vaultPubKey,
+            vaultDepositor,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftProgram: this.driftClient.program.programId,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .liquidate()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const liquidateIx = this.program.instruction.liquidate({
+                accounts: {
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([liquidateIx]);
+        }
+    }
+    /**
+     * Used for UI wallet adapters compatibility
+     */
+    async createAndSendTxn(ixs, computeUnitParams) {
+        const tx = new web3_js_1.Transaction();
+        tx.add(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit(computeUnitParams || {
+            units: 400000,
+        }));
+        tx.add(...ixs);
+        const { txSig } = await this.driftClient.sendTransaction(tx, [], this.driftClient.opts);
+        return txSig;
+    }
+}
+exports.VaultClient = VaultClient;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@drift-labs/vaults-sdk",
+  "version": "0.1.0",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "directories": {
+    "lib": "lib"
+  },
+  "peerDependencies": {
+    "@drift-labs/sdk": "2.40.0-beta.1"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.26.0",
+    "@solana/web3.js": "1.73.2",
+    "commander": "^11.0.0",
+    "dotenv": "^16.3.1",
+    "strict-event-emitter-types": "^2.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "cli": "ts-node cli/cli.ts",
+    "clean": "rm -rf lib",
+    "build": "yarn clean && tsc"
+  }
+}

package/src/accountSubscribers/index.ts

@@ -0,0 +1,2 @@
+export * from './pollingVaultDepositorSubscriber';
+export * from './pollingVaultSubscriber';

package/src/accountSubscribers/pollingVaultDepositorSubscriber.ts

@@ -0,0 +1,68 @@
+import {
+	VaultDepositor,
+	VaultDepositorAccountEvents,
+	VaultDepositorAccountSubscriber,
+} from '../types/types';
+import { PollingVaultsProgramAccountSubscriber } from './pollingVaultsProgramAccountSubscriber';
+
+export class PollingVaultDepositorSubscriber
+	extends PollingVaultsProgramAccountSubscriber<
+		VaultDepositor,
+		VaultDepositorAccountEvents
+	>
+	implements VaultDepositorAccountSubscriber
+{
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			console.log(
+				'Account for vault depositor already added to account loader'
+			);
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.pubkey,
+			(buffer, slot) => {
+				if (!buffer) return;
+
+				if (this.account && this.account.slot > slot) {
+					return;
+				}
+
+				const account =
+					this.program.account.vaultDepositor.coder.accounts.decode(
+						'vaultDepositor',
+						buffer
+					);
+				this.account = { data: account, slot };
+				this._eventEmitter.emit('vaultDepositorUpdate', account);
+				this._eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this._eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.pubkey);
+		const currentSlot = this.account?.slot ?? 0;
+		if (buffer && slot > currentSlot) {
+			const account = this.program.account.vaultDepositor.coder.accounts.decode(
+				'vaultDepositor',
+				buffer
+			);
+			this.account = { data: account, slot };
+		}
+	}
+
+	updateData(vaultDepositorAcc: VaultDepositor, slot: number): void {
+		if (!this.account || this.account.slot < slot) {
+			this.account = { data: vaultDepositorAcc, slot };
+			this._eventEmitter.emit('vaultDepositorUpdate', vaultDepositorAcc);
+			this._eventEmitter.emit('update');
+		}
+	}
+}