@drift-labs/vaults-sdk 0.1.0

package/lib/types/types.d.ts

@@ -0,0 +1,137 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+import { BN, DataAndSlot, Event } from '@drift-labs/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+export declare const VAULT_PROGRAM_ID: PublicKey;
+export declare class WithdrawUnit {
+    static readonly SHARES: {
+        shares: {};
+    };
+    static readonly TOKEN: {
+        token: {};
+    };
+    static readonly SHARES_PERCENT: {
+        sharesPercent: {};
+    };
+}
+export declare type WithdrawRequest = {
+    shares: BN;
+    value: BN;
+    ts: BN;
+};
+export declare type Vault = {
+    name: number[];
+    pubkey: PublicKey;
+    manager: PublicKey;
+    tokenAccount: PublicKey;
+    userStats: PublicKey;
+    user: PublicKey;
+    delegate: PublicKey;
+    liquidationDelegate: PublicKey;
+    userShares: BN;
+    totalShares: BN;
+    lastFeeUpdateTs: BN;
+    liquidationStartTs: BN;
+    redeemPeriod: BN;
+    totalWithdrawRequested: BN;
+    maxTokens: BN;
+    sharesBase: number;
+    managementFee: BN;
+    initTs: BN;
+    netDeposits: BN;
+    managerNetDeposits: BN;
+    totalDeposits: BN;
+    totalWithdraws: BN;
+    managerTotalDeposits: BN;
+    managerTotalWithdraws: BN;
+    managerTotalFee: BN;
+    managerTotalProfitShare: BN;
+    minDepositAmount: BN;
+    profitShare: number;
+    hurdleRate: number;
+    spotMarketIndex: number;
+    bump: number;
+    permissioned: boolean;
+    lastManagerWithdrawRequest: WithdrawRequest;
+};
+export declare type VaultDepositor = {
+    vault: PublicKey;
+    pubkey: PublicKey;
+    authority: PublicKey;
+    vaultShares: BN;
+    lastWithdrawRequest: WithdrawRequest;
+    lastValidTs: BN;
+    netDeposits: BN;
+    totalDeposits: BN;
+    totalWithdraws: BN;
+    cumulativeProfitShareAmount: BN;
+    vaultSharesBase: number;
+    profitShareFeePaid: BN;
+    padding: number[];
+};
+export declare type VaultsProgramAccountBaseEvents = {
+    update: void;
+    error: (e: Error) => void;
+};
+export declare type VaultDepositorAccountEvents = {
+    vaultDepositorUpdate: (payload: VaultDepositor) => void;
+} & VaultsProgramAccountBaseEvents;
+export declare type VaultAccountEvents = {
+    vaultUpdate: (payload: Vault) => void;
+} & VaultsProgramAccountBaseEvents;
+export interface VaultsProgramAccountSubscriber<Account, AccountEvents extends VaultsProgramAccountBaseEvents> {
+    eventEmitter: StrictEventEmitter<EventEmitter, AccountEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    updateData(account: Account, slot: number): void;
+    unsubscribe(): Promise<void>;
+    getAccountAndSlot(): DataAndSlot<Account>;
+}
+export declare type VaultAccountSubscriber = VaultsProgramAccountSubscriber<Vault, VaultAccountEvents>;
+export declare type VaultDepositorAccountSubscriber = VaultsProgramAccountSubscriber<VaultDepositor, VaultDepositorAccountEvents>;
+export declare class VaultDepositorAction {
+    static readonly DEPOSIT: {
+        deposit: {};
+    };
+    static readonly WITHDRAW: {
+        withdraw: {};
+    };
+    static readonly WITHDRAW_REQUEST: {
+        withdrawRequest: {};
+    };
+    static readonly CANCEL_WITHDRAW_REQUEST: {
+        cancelWithdrawRequest: {};
+    };
+    static readonly FEE_PAYMENT: {
+        feePayment: {};
+    };
+}
+export declare type VaultDepositorRecord = {
+    ts: BN;
+    vault: PublicKey;
+    depositorAuthority: PublicKey;
+    action: VaultDepositorAction;
+    amount: BN;
+    spotMarketIndex: number;
+    vaultSharesBefore: BN;
+    vaultSharesAfter: BN;
+    vaultEquityBefore: BN;
+    userVaultSharesBefore: BN;
+    totalVaultSharesBefore: BN;
+    userVaultSharesAfter: BN;
+    totalVaultSharesAfter: BN;
+    profitShare: BN;
+    managementFee: BN;
+    managementFeeShares: BN;
+};
+export declare type VaultsEventMap = {
+    VaultDepositorRecord: Event<VaultDepositorRecord>;
+};
+export declare type EventType = keyof VaultsEventMap;
+export declare type WrappedEvent<Type extends EventType> = VaultsEventMap[Type] & {
+    eventType: Type;
+};
+export declare type WrappedEvents = WrappedEvent<EventType>[];

package/lib/types/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultDepositorAction = exports.WithdrawUnit = exports.VAULT_PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.VAULT_PROGRAM_ID = new web3_js_1.PublicKey('vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR');
+class WithdrawUnit {
+}
+exports.WithdrawUnit = WithdrawUnit;
+WithdrawUnit.SHARES = { shares: {} };
+WithdrawUnit.TOKEN = { token: {} };
+WithdrawUnit.SHARES_PERCENT = { sharesPercent: {} };
+// Logs/Records
+class VaultDepositorAction {
+}
+exports.VaultDepositorAction = VaultDepositorAction;
+VaultDepositorAction.DEPOSIT = { deposit: {} };
+VaultDepositorAction.WITHDRAW = { withdraw: {} };
+VaultDepositorAction.WITHDRAW_REQUEST = { withdrawRequest: {} };
+VaultDepositorAction.CANCEL_WITHDRAW_REQUEST = { cancelWithdrawRequest: {} };
+VaultDepositorAction.FEE_PAYMENT = { feePayment: {} };

package/lib/utils.d.ts

@@ -0,0 +1,7 @@
+import { DriftClient, IWallet } from '@drift-labs/sdk';
+import { Connection } from '@solana/web3.js';
+import { DriftVaults } from './types/drift_vaults';
+import { VaultClient } from './vaultClient';
+import * as anchor from '@coral-xyz/anchor';
+export declare const getDriftVaultProgram: (connection: Connection, wallet: IWallet) => anchor.Program<DriftVaults>;
+export declare const getVaultClient: (connection: Connection, wallet: IWallet, driftClient: DriftClient) => VaultClient;

package/lib/utils.js

@@ -0,0 +1,43 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVaultClient = exports.getDriftVaultProgram = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const drift_vaults_1 = require("./types/drift_vaults");
+const vaultClient_1 = require("./vaultClient");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const types_1 = require("./types/types");
+const getDriftVaultProgram = (connection, wallet) => {
+    const provider = new anchor_1.AnchorProvider(connection, wallet, {});
+    anchor.setProvider(provider);
+    const vaultProgram = new anchor.Program(drift_vaults_1.IDL, types_1.VAULT_PROGRAM_ID, provider);
+    return vaultProgram;
+};
+exports.getDriftVaultProgram = getDriftVaultProgram;
+const getVaultClient = (connection, wallet, driftClient) => {
+    const vaultProgram = exports.getDriftVaultProgram(connection, wallet);
+    const vaultClient = new vaultClient_1.VaultClient({
+        driftClient,
+        program: vaultProgram,
+    });
+    return vaultClient;
+};
+exports.getVaultClient = getVaultClient;

package/lib/vaultClient.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="bn.js" />
+import { BN, DriftClient } from '@drift-labs/sdk';
+import { Program, ProgramAccount } from '@coral-xyz/anchor';
+import { DriftVaults } from './types/drift_vaults';
+import { PublicKey, SetComputeUnitLimitParams, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { Vault, VaultDepositor, WithdrawUnit } from './types/types';
+export declare class VaultClient {
+    driftClient: DriftClient;
+    program: Program<DriftVaults>;
+    cliMode: boolean;
+    constructor({ driftClient, program, cliMode, }: {
+        driftClient: DriftClient;
+        program: Program<DriftVaults>;
+        cliMode?: boolean;
+    });
+    getVault(vault: PublicKey): Promise<Vault>;
+    getVaultDepositor(vaultDepositor: PublicKey): Promise<any>;
+    getAllVaultDepositors(vault: PublicKey): Promise<ProgramAccount<VaultDepositor>[]>;
+    /**
+     *
+     * @param vault pubkey
+     * @returns vault equity, in QUOTE_PRECISION
+     */
+    calculateVaultEquity(params: {
+        address?: PublicKey;
+        vault?: Vault;
+    }): Promise<BN>;
+    initializeVault(params: {
+        name: number[];
+        spotMarketIndex: number;
+        redeemPeriod: BN;
+        maxTokens: BN;
+        minDepositAmount: BN;
+        managementFee: BN;
+        profitShare: number;
+        hurdleRate: number;
+        permissioned: boolean;
+    }): Promise<TransactionSignature>;
+    /**
+     * 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
+     */
+    updateDelegate(vault: PublicKey, delegate: PublicKey): Promise<TransactionSignature>;
+    /**
+     *
+     * @param vault vault address to deposit to
+     * @param amount amount to deposit
+     * @returns
+     */
+    managerDeposit(vault: PublicKey, amount: BN): Promise<TransactionSignature>;
+    managerRequestWithdraw(vault: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
+    managerCancelWithdrawRequest(vault: PublicKey): Promise<TransactionSignature>;
+    managerWithdraw(vault: PublicKey): Promise<TransactionSignature>;
+    managerUpdateVault(vault: PublicKey, params: {
+        redeemPeriod: BN | null;
+        maxTokens: BN | null;
+        managementFee: BN | null;
+        minDepositAmount: BN | null;
+        profitShare: number | null;
+        hurdleRate: number | null;
+        permissioned: boolean | null;
+    }): Promise<TransactionSignature>;
+    getApplyProfitShareIx(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionInstruction>;
+    private createInitVaultDepositorIx;
+    /**
+     * 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
+     */
+    initializeVaultDepositor(vault: PublicKey, authority?: PublicKey): Promise<TransactionSignature>;
+    /**
+     * Depositor funds into the specified vault.
+     * @param vaultDepositor
+     * @param amount
+     * @param initVaultDepositor If true, will initialize the vault depositor account
+     * @returns
+     */
+    deposit(vaultDepositor: PublicKey, amount: BN, initVaultDepositor?: {
+        authority: PublicKey;
+        vault: PublicKey;
+    }): Promise<TransactionSignature>;
+    requestWithdraw(vaultDepositor: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
+    withdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    cancelRequestWithdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    /**
+     * Liquidates (become delegate for) a vault.
+     * @param
+     * @param
+     * @returns
+     */
+    liquidate(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    /**
+     * Used for UI wallet adapters compatibility
+     */
+    createAndSendTxn(ixs: TransactionInstruction[], computeUnitParams?: SetComputeUnitLimitParams): Promise<TransactionSignature>;
+}