@drift-labs/vaults-sdk 0.1.0

package/cli/commands/viewVault.ts

@@ -0,0 +1,30 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext, printVault } from "../utils";
+import { QUOTE_PRECISION, convertToNumber } from "@drift-labs/sdk";
+
+export const viewVault = async (program: Command, cmdOpts: OptionValues) => {
+
+    let address: PublicKey;
+    try {
+        address = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const vault = await driftVault.getVault(address);
+    printVault(vault);
+    const vaultEquity = await driftVault.calculateVaultEquity({
+        vault,
+    });
+    console.log(`vaultEquity: ${convertToNumber(vaultEquity, QUOTE_PRECISION)}`);
+    console.log("Done!");
+};

package/cli/commands/viewVaultDepositor.ts

@@ -0,0 +1,37 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext, printVaultDepositor } from "../utils";
+import { getVaultDepositorAddressSync } from "../../src";
+
+export const viewVaultDepositor = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultDepositorAddress: PublicKey;
+
+    const {
+        driftVault
+    } = await getCommandContext(program, false);
+
+    try {
+        if (cmdOpts.vaultDepositorAddress !== undefined) {
+            vaultDepositorAddress = new PublicKey(cmdOpts.vaultDepositorAddress as string);
+        } else if (cmdOpts.authority !== undefined && cmdOpts.vaultAddress !== undefined) {
+            vaultDepositorAddress = getVaultDepositorAddressSync(
+                driftVault.program.programId,
+                new PublicKey(cmdOpts.vaultAddress as string),
+                new PublicKey(cmdOpts.authority as string));
+        } else {
+            console.error("Must supply --vault-depositor-address or --authority and --vault-address");
+            process.exit(1);
+        }
+    } catch (err) {
+        console.error("Failed to load VaultDepositor address");
+        process.exit(1);
+    }
+
+    const vaultDepositor = await driftVault.getVaultDepositor(vaultDepositorAddress);
+    printVaultDepositor(vaultDepositor);
+    console.log("Done!");
+};

package/cli/commands/withdraw.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+
+export const withdraw = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultDepositorAddress: PublicKey;
+    try {
+        vaultDepositorAddress = new PublicKey(cmdOpts.vaultDepositorAddress as string);
+    } catch (err) {
+        console.error("Invalid vault depositor address");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const tx = await driftVault.withdraw(vaultDepositorAddress);
+    console.log(`Withdrew from vault: ${tx}`);
+    console.log("Done!");
+};

package/cli/utils.ts

@@ -0,0 +1,119 @@
+import { DriftClient, PublicKey, Wallet, loadKeypair } from "@drift-labs/sdk";
+import { Vault, VaultClient, decodeName } from "../src";
+import { Command } from "commander";
+import { Connection, Keypair } from "@solana/web3.js";
+import { AnchorProvider } from "@coral-xyz/anchor";
+import * as anchor from '@coral-xyz/anchor';
+import { IDL } from "../src/types/drift_vaults";
+
+export function printVault(vault: Vault) {
+    console.log(`vault: ${decodeName(vault.name)}`);
+    console.log(`pubkey:         ${vault.pubkey.toBase58()}`);
+    console.log(`manager:         ${vault.manager.toBase58()}`);
+    console.log(`tokenAccount:    ${vault.tokenAccount.toBase58()}`);
+    console.log(`driftUserStats:  ${vault.userStats.toBase58()}`);
+    console.log(`driftUser:       ${vault.user.toBase58()}`);
+    console.log(`delegate:        ${vault.delegate.toBase58()}`);
+    console.log(`liqDelegate:     ${vault.liquidationDelegate.toBase58()}`);
+    console.log(`userShares:      ${vault.userShares.toString()}`);
+    console.log(`totalShares:     ${vault.totalShares.toString()}`);
+    const managerShares = vault.totalShares.sub(vault.userShares);
+    console.log(`  [managerShares]: ${managerShares.toString()} (${(managerShares.toNumber() / vault.totalShares.toNumber() * 100.0).toFixed(4)}%)`);
+    console.log(`totalShares:     ${vault.totalShares.toString()}`);
+    console.log(`lastFeeUpdateTs:    ${vault.lastFeeUpdateTs.toString()}`);
+    console.log(`liquidationStartTs: ${vault.liquidationStartTs.toString()}`);
+    console.log(`redeemPeriod:            ${vault.redeemPeriod.toString()}`);
+    console.log(`totalWithdrawRequested:  ${vault.totalWithdrawRequested.toString()}`);
+    console.log(`maxTokens:               ${vault.maxTokens.toString()}`);
+    console.log(`sharesBase:              ${vault.sharesBase}`);
+    console.log(`managementFee:           ${vault.managementFee.toString()}`);
+    console.log(`initTs:                  ${vault.initTs.toString()}`);
+    console.log(`netDeposits:             ${vault.netDeposits.toString()}`);
+    console.log(`managerNetDeposits:      ${vault.managerNetDeposits.toString()}`);
+    console.log(`totalDeposits:           ${vault.totalDeposits.toString()}`);
+    console.log(`totalWithdraws:          ${vault.totalWithdraws.toString()}`);
+    console.log(`managerTotalDeposits:    ${vault.managerTotalDeposits.toString()}`);
+    console.log(`managerTotalWithdraws:   ${vault.managerTotalWithdraws.toString()}`);
+    console.log(`managerTotalFee:         ${vault.managerTotalFee.toString()}`);
+    console.log(`managerTotalProfitShare: ${vault.managerTotalProfitShare.toString()}`);
+    console.log(`lastManagerWithdrawRequest:`);
+    console.log(`  shares: ${vault.lastManagerWithdrawRequest.shares.toString()}`);
+    console.log(`  values: ${vault.lastManagerWithdrawRequest.value.toString()}`);
+    console.log(`  ts:     ${vault.lastManagerWithdrawRequest.ts.toString()}`);
+
+    console.log(`minDepositAmount:  ${vault.minDepositAmount.toString()}`);
+    console.log(`profitShare:       ${vault.profitShare}`);
+    console.log(`hurdleRate:        ${vault.hurdleRate}`);
+    console.log(`spotMarketIndex:   ${vault.spotMarketIndex}`);
+    console.log(`permissioned:      ${vault.permissioned}`);
+}
+
+export function printVaultDepositor(vaultDepositor) {
+    console.log(`vault:          ${vaultDepositor.vault.toBase58()}`);
+    console.log(`pubkey:         ${vaultDepositor.pubkey.toBase58()}`);
+    console.log(`authority:      ${vaultDepositor.authority.toBase58()}`);
+    console.log(`vaultShares:    ${vaultDepositor.vaultShares.toString()}`);
+    console.log(`lastWithdrawRequestShares:   ${vaultDepositor.lastWithdrawRequestShares.toString()}`);
+    console.log(`lastWithdrawRequestValue:    ${vaultDepositor.lastWithdrawRequestValue.toString()}`);
+    console.log(`lastWithdrawRequestTs:       ${vaultDepositor.lastWithdrawRequestTs.toString()}`);
+    console.log(`lastValidTs:                 ${vaultDepositor.lastValidTs.toString()}`);
+    console.log(`netDeposits:                 ${vaultDepositor.netDeposits.toString()}`);
+    console.log(`totalDeposits:               ${vaultDepositor.totalDeposits.toString()}`);
+    console.log(`totalWithdraws:              ${vaultDepositor.totalWithdraws.toString()}`);
+    console.log(`cumulativeProfitShareAmount: ${vaultDepositor.cumulativeProfitShareAmount.toString()}`);
+    console.log(`vaultSharesBase:             ${vaultDepositor.vaultSharesBase.toString()}`);
+}
+
+export async function getCommandContext(program: Command, needToSign: boolean): Promise<{
+    driftClient: DriftClient,
+    driftVault: VaultClient,
+}> {
+
+    const opts = program.opts();
+
+    let keypair: Keypair;
+    if (needToSign) {
+        try {
+            keypair = loadKeypair(opts.keypair as string);
+        } catch (e) {
+            console.error(`Need to provide a valid keypair: ${e}`);
+            process.exit(1);
+        }
+    } else {
+        keypair = Keypair.generate();
+    }
+
+    const wallet = new Wallet(keypair);
+    console.log(`Signing wallet address (need to sign: ${needToSign}): `, wallet.publicKey.toBase58());
+
+    const connection = new Connection(opts.rpc, {
+        commitment: opts.commitment,
+    });
+    const driftClient = new DriftClient({
+        connection,
+        wallet,
+        env: "mainnet-beta",
+        opts: {
+            commitment: opts.commitment,
+            skipPreflight: false,
+            preflightCommitment: opts.commitment,
+        },
+    });
+    await driftClient.subscribe();
+
+    const provider = new AnchorProvider(connection, wallet, {});
+    anchor.setProvider(provider);
+    const vaultProgramId = new PublicKey("vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR");
+    const vaultProgram = new anchor.Program(IDL, vaultProgramId, provider);
+
+    const driftVault = new VaultClient({
+        driftClient,
+        program: vaultProgram,
+        cliMode: true
+    });
+
+    return {
+        driftClient,
+        driftVault,
+    };
+}

package/lib/accountSubscribers/index.d.ts

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

package/lib/accountSubscribers/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pollingVaultDepositorSubscriber"), exports);
+__exportStar(require("./pollingVaultSubscriber"), exports);

package/lib/accountSubscribers/pollingVaultDepositorSubscriber.d.ts

@@ -0,0 +1,7 @@
+import { VaultDepositor, VaultDepositorAccountEvents, VaultDepositorAccountSubscriber } from '../types/types';
+import { PollingVaultsProgramAccountSubscriber } from './pollingVaultsProgramAccountSubscriber';
+export declare class PollingVaultDepositorSubscriber extends PollingVaultsProgramAccountSubscriber<VaultDepositor, VaultDepositorAccountEvents> implements VaultDepositorAccountSubscriber {
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    updateData(vaultDepositorAcc: VaultDepositor, slot: number): void;
+}

package/lib/accountSubscribers/pollingVaultDepositorSubscriber.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingVaultDepositorSubscriber = void 0;
+const pollingVaultsProgramAccountSubscriber_1 = require("./pollingVaultsProgramAccountSubscriber");
+class PollingVaultDepositorSubscriber extends pollingVaultsProgramAccountSubscriber_1.PollingVaultsProgramAccountSubscriber {
+    async addToAccountLoader() {
+        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() {
+        var _a, _b;
+        await this.accountLoader.load();
+        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.pubkey);
+        const currentSlot = (_b = (_a = this.account) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0;
+        if (buffer && slot > currentSlot) {
+            const account = this.program.account.vaultDepositor.coder.accounts.decode('vaultDepositor', buffer);
+            this.account = { data: account, slot };
+        }
+    }
+    updateData(vaultDepositorAcc, slot) {
+        if (!this.account || this.account.slot < slot) {
+            this.account = { data: vaultDepositorAcc, slot };
+            this._eventEmitter.emit('vaultDepositorUpdate', vaultDepositorAcc);
+            this._eventEmitter.emit('update');
+        }
+    }
+}
+exports.PollingVaultDepositorSubscriber = PollingVaultDepositorSubscriber;

package/lib/accountSubscribers/pollingVaultSubscriber.d.ts

@@ -0,0 +1,7 @@
+import { Vault, VaultAccountEvents, VaultAccountSubscriber } from '../types/types';
+import { PollingVaultsProgramAccountSubscriber } from './pollingVaultsProgramAccountSubscriber';
+export declare class PollingVaultSubscriber extends PollingVaultsProgramAccountSubscriber<Vault, VaultAccountEvents> implements VaultAccountSubscriber {
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    updateData(vaultAcc: Vault, slot: number): void;
+}

package/lib/accountSubscribers/pollingVaultSubscriber.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingVaultSubscriber = void 0;
+const pollingVaultsProgramAccountSubscriber_1 = require("./pollingVaultsProgramAccountSubscriber");
+class PollingVaultSubscriber extends pollingVaultsProgramAccountSubscriber_1.PollingVaultsProgramAccountSubscriber {
+    async addToAccountLoader() {
+        if (this.callbackId) {
+            console.log('Account for vault 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.vault.coder.accounts.decode('vault', buffer);
+            this.account = { data: account, slot };
+            this._eventEmitter.emit('vaultUpdate', account);
+            this._eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this._eventEmitter.emit('error', error);
+        });
+    }
+    async fetch() {
+        var _a, _b;
+        await this.accountLoader.load();
+        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.pubkey);
+        const currentSlot = (_b = (_a = this.account) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0;
+        if (buffer && slot > currentSlot) {
+            const account = this.program.account.vault.coder.accounts.decode('vault', buffer);
+            this.account = { data: account, slot };
+        }
+    }
+    updateData(vaultAcc, slot) {
+        if (!this.account || this.account.slot < slot) {
+            this.account = { data: vaultAcc, slot };
+            this._eventEmitter.emit('vaultUpdate', vaultAcc);
+            this._eventEmitter.emit('update');
+        }
+    }
+}
+exports.PollingVaultSubscriber = PollingVaultSubscriber;

package/lib/accountSubscribers/pollingVaultsProgramAccountSubscriber.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { BulkAccountLoader, DataAndSlot, PublicKey } from '@drift-labs/sdk';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { DriftVaults } from '../types/drift_vaults';
+import { VaultsProgramAccountBaseEvents, VaultsProgramAccountSubscriber } from '../types/types';
+export declare abstract class PollingVaultsProgramAccountSubscriber<Account, AccountEvents extends VaultsProgramAccountBaseEvents> implements VaultsProgramAccountSubscriber<Account, AccountEvents> {
+    protected program: Program<DriftVaults>;
+    protected _isSubscribed: boolean;
+    protected pubkey: PublicKey;
+    protected account?: DataAndSlot<Account>;
+    protected _eventEmitter: StrictEventEmitter<EventEmitter, AccountEvents>;
+    protected accountLoader: BulkAccountLoader;
+    protected callbackId: string | null;
+    protected errorCallbackId: string | null;
+    constructor(program: Program<DriftVaults>, accountPubkey: PublicKey, accountLoader: BulkAccountLoader);
+    get isSubscribed(): boolean;
+    get eventEmitter(): StrictEventEmitter<EventEmitter, AccountEvents>;
+    subscribe(): Promise<boolean>;
+    unsubscribe(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    assertIsSubscribed(): void;
+    getAccountAndSlot(): DataAndSlot<Account>;
+    abstract addToAccountLoader(): Promise<void>;
+    abstract fetch(): Promise<void>;
+    abstract updateData(account: Account, slot: number): void;
+}

package/lib/accountSubscribers/pollingVaultsProgramAccountSubscriber.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingVaultsProgramAccountSubscriber = void 0;
+const sdk_1 = require("@drift-labs/sdk");
+const events_1 = require("events");
+class PollingVaultsProgramAccountSubscriber {
+    constructor(program, accountPubkey, accountLoader) {
+        this.callbackId = null;
+        this.errorCallbackId = null;
+        this.accountLoader = accountLoader;
+        this._isSubscribed = false;
+        this.pubkey = accountPubkey;
+        this.program = program;
+        // @ts-ignore
+        this._eventEmitter = new events_1.EventEmitter();
+    }
+    get isSubscribed() {
+        return this._isSubscribed;
+    }
+    get eventEmitter() {
+        return this._eventEmitter;
+    }
+    async subscribe() {
+        if (this._isSubscribed) {
+            return true;
+        }
+        try {
+            await this.addToAccountLoader();
+            await this.fetchIfUnloaded();
+            if (this.account) {
+                // @ts-ignore
+                this._eventEmitter.emit('update');
+            }
+            this._isSubscribed = true;
+            return true;
+        }
+        catch (err) {
+            console.error(err);
+            this._isSubscribed = false;
+            return false;
+        }
+    }
+    async unsubscribe() {
+        if (!this._isSubscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.pubkey, this.callbackId);
+        this.callbackId = undefined;
+        this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+        this.errorCallbackId = undefined;
+        this._isSubscribed = false;
+    }
+    async fetchIfUnloaded() {
+        if (this.account === undefined) {
+            await this.fetch();
+        }
+    }
+    assertIsSubscribed() {
+        if (!this._isSubscribed) {
+            throw new sdk_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.account;
+    }
+}
+exports.PollingVaultsProgramAccountSubscriber = PollingVaultsProgramAccountSubscriber;

package/lib/accounts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './vaultDepositorAccount';
+export * from './vaultAccount';

package/lib/accounts/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./vaultDepositorAccount"), exports);
+__exportStar(require("./vaultAccount"), exports);

package/lib/accounts/vaultAccount.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="bn.js" />
+import { BN, Program } from '@coral-xyz/anchor';
+import { BulkAccountLoader } from '@drift-labs/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { DriftVaults } from '../types/drift_vaults';
+import { Vault, VaultAccountEvents } from '../types/types';
+import { VaultsProgramAccount } from './vaultsProgramAccount';
+export declare class VaultAccount extends VaultsProgramAccount<Vault, VaultAccountEvents> {
+    constructor(program: Program<DriftVaults>, vaultPubkey: PublicKey, accountLoader: BulkAccountLoader, accountSubscriptionType?: 'polling' | 'websocket');
+    static getAddressSync(programId: PublicKey, vaultName: string): PublicKey;
+    calcSharesAfterManagementFee(vaultEquity: BN): {
+        totalShares: BN;
+        managementFeeShares: BN;
+    };
+}

package/lib/accounts/vaultAccount.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultAccount = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const sdk_1 = require("@drift-labs/sdk");
+const accountSubscribers_1 = require("../accountSubscribers");
+const vaultsProgramAccount_1 = require("./vaultsProgramAccount");
+const addresses_1 = require("../addresses");
+const name_1 = require("../name");
+class VaultAccount extends vaultsProgramAccount_1.VaultsProgramAccount {
+    constructor(program, vaultPubkey, accountLoader, accountSubscriptionType = 'polling') {
+        super();
+        if (accountSubscriptionType === 'polling') {
+            this.accountSubscriber = new accountSubscribers_1.PollingVaultSubscriber(program, vaultPubkey, accountLoader);
+        }
+        else {
+            throw new Error('Websocket subscription not yet implemented');
+        }
+    }
+    static getAddressSync(programId, vaultName) {
+        return addresses_1.getVaultAddressSync(programId, name_1.encodeName(vaultName));
+    }
+    calcSharesAfterManagementFee(vaultEquity) {
+        const accountData = this.accountSubscriber.getAccountAndSlot().data;
+        const depositorsEquity = accountData.userShares
+            .mul(vaultEquity)
+            .div(accountData.totalShares);
+        if (accountData.managementFee.eq(sdk_1.ZERO) || depositorsEquity.lte(sdk_1.ZERO)) {
+            return {
+                totalShares: accountData.totalShares,
+                managementFeeShares: sdk_1.ZERO,
+            };
+        }
+        const now = new anchor_1.BN(Date.now() / 1000);
+        const sinceLast = now.sub(accountData.lastFeeUpdateTs);
+        let managementFeeAmount = depositorsEquity
+            .mul(accountData.managementFee)
+            .div(sdk_1.PERCENTAGE_PRECISION)
+            .mul(sinceLast)
+            .div(sdk_1.ONE_YEAR);
+        managementFeeAmount = anchor_1.BN.min(managementFeeAmount, depositorsEquity.sub(sdk_1.ONE));
+        const newTotalSharesFactor = depositorsEquity
+            .mul(sdk_1.PERCENTAGE_PRECISION)
+            .div(depositorsEquity.sub(managementFeeAmount));
+        let newTotalShares = accountData.totalShares
+            .mul(newTotalSharesFactor)
+            .div(sdk_1.PERCENTAGE_PRECISION);
+        newTotalShares = anchor_1.BN.max(newTotalShares, accountData.userShares);
+        const managementFeeShares = newTotalShares.sub(accountData.totalShares);
+        return { totalShares: newTotalShares, managementFeeShares };
+    }
+}
+exports.VaultAccount = VaultAccount;

package/lib/accounts/vaultDepositorAccount.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="bn.js" />
+import { BN, Program } from '@coral-xyz/anchor';
+import { BulkAccountLoader } from '@drift-labs/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { DriftVaults } from '../types/drift_vaults';
+import { VaultDepositor, VaultDepositorAccountEvents } from '../types/types';
+import { VaultsProgramAccount } from './vaultsProgramAccount';
+export declare class VaultDepositorAccount extends VaultsProgramAccount<VaultDepositor, VaultDepositorAccountEvents> {
+    constructor(program: Program<DriftVaults>, vaultDepositorPubkey: PublicKey, accountLoader: BulkAccountLoader, accountSubscriptionType?: 'polling' | 'websocket');
+    static getAddressSync(programId: PublicKey, vault: PublicKey, authority: PublicKey): PublicKey;
+    /**
+     * Calculates the percentage of a depositor's equity that will be paid as profit share fees.
+     *
+     * @param vaultProfitShare Vault's profit share fee
+     * @param depositorEquity Vault depositor's equity amount
+     */
+    calcProfitShareFeesPct(vaultProfitShare: BN, depositorEquity: BN): BN;
+}

package/lib/accounts/vaultDepositorAccount.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultDepositorAccount = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const sdk_1 = require("@drift-labs/sdk");
+const accountSubscribers_1 = require("../accountSubscribers");
+const vaultsProgramAccount_1 = require("./vaultsProgramAccount");
+const addresses_1 = require("../addresses");
+class VaultDepositorAccount extends vaultsProgramAccount_1.VaultsProgramAccount {
+    constructor(program, vaultDepositorPubkey, accountLoader, accountSubscriptionType = 'polling') {
+        super();
+        if (accountSubscriptionType === 'polling') {
+            this.accountSubscriber = new accountSubscribers_1.PollingVaultDepositorSubscriber(program, vaultDepositorPubkey, accountLoader);
+        }
+        else {
+            throw new Error('Websocket subscription not yet implemented');
+        }
+    }
+    static getAddressSync(programId, vault, authority) {
+        return addresses_1.getVaultDepositorAddressSync(programId, vault, authority);
+    }
+    /**
+     * Calculates the percentage of a depositor's equity that will be paid as profit share fees.
+     *
+     * @param vaultProfitShare Vault's profit share fee
+     * @param depositorEquity Vault depositor's equity amount
+     */
+    calcProfitShareFeesPct(vaultProfitShare, depositorEquity) {
+        const accountData = this.accountSubscriber.getAccountAndSlot().data;
+        const profit = depositorEquity
+            .sub(accountData.netDeposits)
+            .sub(accountData.cumulativeProfitShareAmount);
+        if (profit.lte(new anchor_1.BN(0))) {
+            return sdk_1.ZERO;
+        }
+        const profitShareAmount = profit
+            .mul(vaultProfitShare)
+            .div(sdk_1.PERCENTAGE_PRECISION);
+        const profitShareProportion = profitShareAmount
+            .mul(sdk_1.PERCENTAGE_PRECISION)
+            .div(depositorEquity);
+        return profitShareProportion;
+    }
+}
+exports.VaultDepositorAccount = VaultDepositorAccount;

package/lib/accounts/vaultsProgramAccount.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { VaultsProgramAccountBaseEvents, VaultsProgramAccountSubscriber } from '../types/types';
+export declare abstract class VaultsProgramAccount<Account, AccountEvents extends VaultsProgramAccountBaseEvents> {
+    accountSubscriber: VaultsProgramAccountSubscriber<Account, AccountEvents>;
+    get isSubscribed(): boolean;
+    get eventEmitter(): StrictEventEmitter<EventEmitter, AccountEvents>;
+    subscribe(): Promise<boolean>;
+    unsubscribe(): Promise<void>;
+    getData(): Account;
+    updateData(newData: Account, slot: number): Promise<void>;
+}

package/lib/accounts/vaultsProgramAccount.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultsProgramAccount = void 0;
+class VaultsProgramAccount {
+    get isSubscribed() {
+        return this.accountSubscriber.isSubscribed;
+    }
+    get eventEmitter() {
+        return this.accountSubscriber.eventEmitter;
+    }
+    async subscribe() {
+        return await this.accountSubscriber.subscribe();
+    }
+    async unsubscribe() {
+        return await this.accountSubscriber.unsubscribe();
+    }
+    getData() {
+        var _a;
+        return (_a = this.accountSubscriber.getAccountAndSlot()) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    async updateData(newData, slot) {
+        return await this.accountSubscriber.updateData(newData, slot);
+    }
+}
+exports.VaultsProgramAccount = VaultsProgramAccount;

package/lib/addresses.d.ts

@@ -0,0 +1,4 @@
+import { PublicKey } from '@solana/web3.js';
+export declare function getVaultAddressSync(programId: PublicKey, encodedName: number[]): PublicKey;
+export declare function getVaultDepositorAddressSync(programId: PublicKey, vault: PublicKey, authority: PublicKey): PublicKey;
+export declare function getTokenVaultAddressSync(programId: PublicKey, vault: PublicKey): PublicKey;