@drift-labs/vaults-sdk 0.1.0

package/.env.example

@@ -0,0 +1,2 @@
+RPC_URL=
+KEYPAIR_PATH=

package/README.md

@@ -0,0 +1,58 @@
+# CLI Usage
+
+This repo has a simple CLI for interacting with the vault (run from this `package.json`):
+
+First create a `.env` and fill it out:
+```
+cp .env.example .env
+```
+
+View available commands, run with `--help` in nested commands to get available options for each command
+```
+yarn cli --help
+```
+
+
+Init a new vault. This will initialize a new vault and update you as the delegate.
+Note that defaults are used for the vault (permissioned, 2% mgmt fee, 20% profit share), take
+care to edit these as required.
+```
+yarn cli init-vault --name="super safe vault"
+```
+
+
+Make a deposit into a vault (as a manager, `DEPOSIT_AMOUNT` in human precision):
+```
+yarn cli manager-deposit --vault-address=<VAULT_ADDRESS> --amount=<DEPOSIT_AMOUNT>
+```
+
+Make a withdraw request from a vault (as a manager, `SHARES` in raw precision):
+```
+yarn cli manager-request-withdraw --vault-address=<VAULT_ADDRESS> --amount=<SHARES>
+```
+
+Manager can trigger a profit share calculation (this looks up all `VaultDepositors` for a vault eligible for profit share and batch processes them):
+```
+yarn cli apply-profit-share-all --vault-address=<VAULT_ADDRESS>
+```
+
+
+For permissioned vaults, initialize a `VaultDepositor` for someone to deposit.
+```
+yarn cli init-vault-depositor --vault-address=<VAULT_ADDRESS> --deposit-authority=<AUTHORITY_TO_ALLOW_DEPOSIT>
+```
+Then send them the `VAULT_DEPOSITOR_ADDRESS`
+
+
+Make a deposit into a vault (as a non-manager, `DEPOSIT_AMOUNT` in human precision):
+```
+yarn cli deposit --vault-depositor-address=<VAULT_DEPOSITOR_ADDRESS> --amount=<DEPOSIT_AMOUNT>
+```
+
+
+To print out the current state of a `Vault` or `VaultDepositor`:
+```
+yarn cli view-vault --vault-address=<VAULT_ADDRESS>
+
+yarn cli view-vault-depositor --vault-depositor-address=<VAULT_DEPOSITOR_ADDRESS>
+```

package/cli/cli.ts

@@ -0,0 +1,105 @@
+import {
+    initVault,
+    viewVault,
+    managerDeposit,
+    managerRequestWithdraw,
+    managerCancelWithdraw,
+    managerWithdraw,
+    managerUpdateVault,
+    applyProfitShare,
+    initVaultDepositor,
+    deposit,
+    requestWithdraw,
+    withdraw,
+    listDepositorsForVault,
+} from "./commands";
+
+import { Command, Option } from 'commander';
+import { viewVaultDepositor } from "./commands/viewVaultDepositor";
+require('dotenv').config();
+
+const program = new Command();
+program
+    .addOption(new Option("-r, --rpc <url>", "RPC URL to use").env("RPC_URL").makeOptionMandatory(true))
+    .addOption(new Option("-k, --keypair <fiilepath>", "Path to keypair file").env("KEYPAIR_PATH"))
+    .addOption(new Option("--commitment <commitment>", "State commitment to use").default("confirmed"));
+program
+    .command("init")
+    .description("Initialize a new vault")
+    .option("-n, --name <vaultName>", "Name of the vault to create", "my new vault")
+    .action((opts) => initVault(program, opts));
+program
+    .command("view-vault")
+    .description("View Vault account details")
+    .addOption(new Option("--vault-address <address>", "Address of the Vault to view").makeOptionMandatory(true))
+    .action((opts) => viewVault(program, opts));
+program
+    .command("view-vault-depositor")
+    .description("View VaultDepositor account details")
+    .addOption(new Option("--vault-depositor-address <address>", "Address of the VaultDepositor to view").makeOptionMandatory(false))
+    .addOption(new Option("--vault-address <address>", "Address of the Vault to view").makeOptionMandatory(false))
+    .addOption(new Option("--authority <vaultDepositorAuthority>", "VaultDepositor authority address").makeOptionMandatory(false))
+    .action((opts) => viewVaultDepositor(program, opts));
+program
+    .command("list-vault-depositors")
+    .description("List VaultDepositors for a Vault")
+    .addOption(new Option("--vault-address <address>", "Address of the Vault to view").makeOptionMandatory(true))
+    .action((opts) => listDepositorsForVault(program, opts));
+program
+    .command("manager-deposit")
+    .description("Make a deposit to your vault")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .addOption(new Option("--amount <amount>", "Amount to deposit (human format, 5 for 5 USDC)").makeOptionMandatory(true))
+    .action((opts) => managerDeposit(program, opts));
+program
+    .command("manager-request-withdraw")
+    .description("Make a withdraw request from your vault")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .addOption(new Option("--shares <shares>", "Amount of shares to withdraw (raw precision, as expected by contract)").makeOptionMandatory(true))
+    .action((opts) => managerRequestWithdraw(program, opts));
+program
+    .command("manager-update-vault")
+    .description("Update vault params for a manager")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .action((opts) => managerUpdateVault(program, opts));
+program
+    .command("manager-withdraw")
+    .description("Make a withdraw from your vault")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .action((opts) => managerWithdraw(program, opts));
+program
+    .command("manager-cancel-withdraw")
+    .description("Cancel a pending manager withdraw withdraw from your vault")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .action((opts) => managerCancelWithdraw(program, opts));
+program
+    .command("apply-profit-share-all")
+    .description("Turn the profit share crank for all depositors")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .action((opts) => applyProfitShare(program, opts));
+program
+    .command("init-vault-depositor")
+    .description("Initialize a VaultDepositor for someone to deposit into your vault")
+    .addOption(new Option("--vault-address <address>", "Address of the vault to create a VaultDepositor for").makeOptionMandatory(true))
+    .addOption(new Option("--deposit-authority <depositAuthority>", "Authority to create the VaultDepositor for, only they can deposit in the vault.").makeOptionMandatory(true))
+    .action((opts) => initVaultDepositor(program, opts));
+program
+    .command("deposit")
+    .description("Deposit into a vault via VaultDepositor")
+    .addOption(new Option("--vault-depositor-address <vaultDepositorAddress>", "VaultDepositor address").makeOptionMandatory(true))
+    .addOption(new Option("--amount <amount>", "Amount to deposit (human format, 5 for 5 USDC)").makeOptionMandatory(true))
+    .action((opts) => deposit(program, opts));
+program
+    .command("request-withdraw")
+    .description("Make a request to withdraw shares from the vaultm, redeem period starts now")
+    .addOption(new Option("--vault-depositor-address <vaultDepositorAddress>", "VaultDepositor address").makeOptionMandatory(true))
+    .addOption(new Option("--amount <amount>", "Amount of shares to withdraw (raw format, as expected in the program)").makeOptionMandatory(true))
+    .action((opts) => requestWithdraw(program, opts));
+program
+    .command("withdraw")
+    .description("Initiate the withdraw, after the redeem period has passed")
+    .addOption(new Option("--vault-depositor-address <vaultDepositorAddress>", "VaultDepositor address").makeOptionMandatory(false))
+    .addOption(new Option("--authority <vaultDepositorAuthority>", "VaultDepositor authority address").makeOptionMandatory(false))
+    .action((opts) => withdraw(program, opts));
+
+program.parseAsync().then(() => { });

package/cli/commands/applyProfitShare.ts

@@ -0,0 +1,48 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+
+export const applyProfitShare = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const allVaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+    // console.log(allVaultDepositors);
+
+    console.log(`Cranking profit share for ${allVaultDepositors.length} depositors...`);
+
+    const chunkSize = 10;
+    const ixChunks: Array<Array<TransactionInstruction>> = [];
+    for (let i = 0; i < allVaultDepositors.length; i += chunkSize) {
+        const chunk = allVaultDepositors.slice(i, i + chunkSize);
+        const ixs = await Promise.all(chunk.map((vaultDepositor) => {
+            return driftVault.getApplyProfitShareIx(vaultAddress, vaultDepositor.publicKey);
+        }));
+
+        ixChunks.push(ixs);
+    }
+    console.log(`Cranking ${ixChunks.length} of ${chunkSize} depositors at a time...`);
+
+    const txs = await Promise.all(ixChunks.map((ixs) => driftVault.createAndSendTxn(ixs)));
+    for (const tx of txs) {
+        console.log(`Crank tx: https://solscan.io/tx/${tx}`);
+    }
+
+
+    // const ix = await driftVault.getApplyProfitShareIx(vaultAddress, );
+    // console.log(`Withrew ${cmdOpts.shares} shares as vault manager: ${tx}`);
+    console.log("Done!");
+};

package/cli/commands/deposit.ts

@@ -0,0 +1,35 @@
+import { BN, TEN } from "@drift-labs/sdk";
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+
+export const deposit = 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 {
+        driftClient,
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const spotMarket = driftClient.getSpotMarketAccount(0); // takes USDC deposits
+    if (!spotMarket) {
+        throw new Error("No spot market found");
+    }
+    const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+    const depositBN = new BN(cmdOpts.amount * spotPrecision.toNumber());
+
+    console.log(`depositing: ${depositBN.toString()}`);
+    const tx = await driftVault.deposit(vaultDepositorAddress, depositBN);
+    console.log(`Deposited ${cmdOpts.amount} to vault as manager: ${tx}`);
+    console.log("Done!");
+};

package/cli/commands/index.ts

@@ -0,0 +1,13 @@
+export * from './initVault';
+export * from './viewVault';
+export * from './managerDeposit';
+export * from './managerRequestWithdraw';
+export * from './managerCancelWithdraw';
+export * from './managerWithdraw';
+export * from './managerUpdateVault';
+export * from './applyProfitShare';
+export * from './initVaultDepositor';
+export * from './deposit';
+export * from './requestWithdraw';
+export * from './withdraw';
+export * from './listDepositorsForVault';

package/cli/commands/initVault.ts

@@ -0,0 +1,61 @@
+import {
+    BN,
+    PERCENTAGE_PRECISION,
+    PublicKey,
+    TEN,
+} from "@drift-labs/sdk";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import {
+    encodeName,
+    getVaultAddressSync,
+} from "../../src";
+import { getCommandContext } from "../utils";
+import { VAULT_PROGRAM_ID } from "../../src/types/types";
+
+export const initVault = async (program: Command, cmdOpts: OptionValues) => {
+    const {
+        driftClient,
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const spotMarket = driftClient.getSpotMarketAccount(0); // takes USDC deposits
+    if (!spotMarket) {
+        throw new Error("No spot market found");
+    }
+    const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+
+    let newVaultName = cmdOpts.name;
+    if (!newVaultName) {
+        newVaultName = "my new vault";
+    }
+    const vaultNameBytes = encodeName(newVaultName!);
+    console.log(`Initializing a new vault named '${newVaultName}'`);
+
+    const initTx = await driftVault.initializeVault({
+        name: vaultNameBytes,
+        spotMarketIndex: 0,
+        redeemPeriod: new BN(3 * 60 * 60), // 3 hours
+        maxTokens: new BN(1000).mul(spotPrecision), // 1000 USDC cap
+        managementFee: PERCENTAGE_PRECISION.div(new BN(50)), // 2%
+        profitShare: PERCENTAGE_PRECISION.div(new BN(5)), // 20%
+        hurdleRate: 0,
+        permissioned: false,
+        minDepositAmount: new BN(10).mul(spotPrecision), // 10 USDC minimum deposit
+    });
+    console.log(`Initialized vault, tx: ${initTx}`);
+
+    const vaultAddress = getVaultAddressSync(VAULT_PROGRAM_ID, vaultNameBytes);
+    console.log(`New vault address: ${vaultAddress}`);
+
+    let delegate = cmdOpts.delegate;
+    if (!delegate) {
+        delegate = driftClient.wallet.publicKey.toBase58();
+    }
+    console.log(`Updating the drift account delegate to: ${delegate}`);
+    const updateDelegateTx = await driftVault.updateDelegate(vaultAddress, new PublicKey(delegate));
+    console.log(`update delegate tx: ${updateDelegateTx}`);
+    console.log("Done!");
+};

package/cli/commands/initVaultDepositor.ts

@@ -0,0 +1,43 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    getVaultDepositorAddressSync
+} from "../../src/addresses";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { VAULT_PROGRAM_ID } from "../../src/types/types";
+
+export const initVaultDepositor = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    let depositAuthority: PublicKey;
+    try {
+        depositAuthority = new PublicKey(cmdOpts.depositAuthority as string);
+    } catch (err) {
+        console.error("Invalid deposit authority");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const vaultDepositorAddress = getVaultDepositorAddressSync(
+        VAULT_PROGRAM_ID,
+        vaultAddress,
+        depositAuthority,
+    );
+    const tx = await driftVault.initializeVaultDepositor(vaultAddress, depositAuthority);
+    console.log(`VaultDepositor initialized for ${depositAuthority}: ${tx}`);
+    console.log(`VaultDepositor address: ${vaultDepositorAddress}`);
+    console.log("Done!");
+};

package/cli/commands/listDepositorsForVault.ts

@@ -0,0 +1,33 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+
+export const listDepositorsForVault = async (program: Command, cmdOpts: OptionValues) => {
+
+    const {
+        driftVault
+    } = await getCommandContext(program, false);
+
+    let vaultAddress: PublicKey | undefined = undefined;
+    try {
+        if (cmdOpts.vaultAddress !== undefined) {
+            vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+        } else {
+            console.error("Must supply --vault-address");
+            process.exit(1);
+        }
+    } catch (err) {
+        console.error("Failed to load VaultDepositor address");
+        process.exit(1);
+    }
+
+    const vaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+    vaultDepositors.forEach((vaultDepositor) => {
+        console.log(vaultDepositor.publicKey.toBase58());
+    });
+    // printVaultDepositor(vaultDepositor);
+    console.log("Done!");
+};

package/cli/commands/managerCancelWithdraw.ts

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

package/cli/commands/managerDeposit.ts

@@ -0,0 +1,34 @@
+import { BN, TEN } from "@drift-labs/sdk";
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+
+export const managerDeposit = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    const {
+        driftClient,
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const spotMarket = driftClient.getSpotMarketAccount(0); // takes USDC deposits
+    if (!spotMarket) {
+        throw new Error("No spot market found");
+    }
+    const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+    const depositBN = new BN(cmdOpts.amount * spotPrecision.toNumber());
+
+    const tx = await driftVault.managerDeposit(vaultAddress, depositBN);
+    console.log(`Deposited ${cmdOpts.amount} to vault as manager: ${tx}`);
+    console.log("Done!");
+};

package/cli/commands/managerRequestWithdraw.ts

@@ -0,0 +1,27 @@
+import { BN } from "@drift-labs/sdk";
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { WithdrawUnit } from "../../src/types/types";
+
+export const managerRequestWithdraw = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const tx = await driftVault.managerRequestWithdraw(vaultAddress, new BN(cmdOpts.shares), WithdrawUnit.SHARES);
+    console.log(`Requested to withraw ${cmdOpts.shares} shares as vault manager: https://solscan.io/tx/${tx}`);
+    console.log("Done!");
+};

package/cli/commands/managerUpdateVault.ts

@@ -0,0 +1,36 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { BN } from "@drift-labs/sdk";
+
+export const managerUpdateVault = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const newParams = {
+        redeemPeriod: new BN(30 * 60 * 60 * 24), // 30 days
+        maxTokens: null,
+        managementFee: null,
+        minDepositAmount: null,
+        profitShare: null,
+        hurdleRate: null,
+        permissioned: null,
+    };
+
+    const tx = await driftVault.managerUpdateVault(vaultAddress, newParams);
+    console.log(`Updated vault params as vault manager: https://solscan.io/tx/${tx}`);
+    console.log("Done!");
+};

package/cli/commands/managerWithdraw.ts

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

package/cli/commands/requestWithdraw.ts

@@ -0,0 +1,29 @@
+import { BN } from "@drift-labs/sdk";
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { WithdrawUnit } from "../../src/types/types";
+
+export const requestWithdraw = 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 withdrawAmountBN = new BN(cmdOpts.amount);
+
+    const tx = await driftVault.requestWithdraw(vaultDepositorAddress, withdrawAmountBN, WithdrawUnit.SHARES);
+    console.log(`Requsted to withdraw ${cmdOpts.amount} shares from the vault: ${tx}`);
+    console.log("Done!");
+};

package/cli/commands/vaultDeposit.ts

@@ -0,0 +1,43 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    getVaultDepositorAddressSync
+} from "../../src/addresses";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { VAULT_PROGRAM_ID } from "../../src/types/types";
+
+export const vaultDeposit = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    let depositAuthority: PublicKey;
+    try {
+        depositAuthority = new PublicKey(cmdOpts.depositAuthority as string);
+    } catch (err) {
+        console.error("Invalid deposit authority");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const vaultDepositorAddress = getVaultDepositorAddressSync(
+        VAULT_PROGRAM_ID,
+        vaultAddress,
+        depositAuthority,
+    );
+    const tx = await driftVault.initializeVaultDepositor(vaultAddress, depositAuthority);
+    console.log(`VaultDepositor initialized for ${depositAuthority}: ${tx}`);
+    console.log(`VaultDepositor address: ${vaultDepositorAddress}`);
+    console.log("Done!");
+};

package/cli/commands/vaultWithdraw.ts

@@ -0,0 +1,43 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    getVaultDepositorAddressSync
+} from "../../src/addresses";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { VAULT_PROGRAM_ID } from "../../src/types/types";
+
+export const vaultWithdraw= async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    let depositAuthority: PublicKey;
+    try {
+        depositAuthority = new PublicKey(cmdOpts.depositAuthority as string);
+    } catch (err) {
+        console.error("Invalid deposit authority");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const vaultDepositorAddress = getVaultDepositorAddressSync(
+        VAULT_PROGRAM_ID,
+        vaultAddress,
+        depositAuthority,
+    );
+    const tx = await driftVault.initializeVaultDepositor(vaultAddress, depositAuthority);
+    console.log(`VaultDepositor initialized for ${depositAuthority}: ${tx}`);
+    console.log(`VaultDepositor address: ${vaultDepositorAddress}`);
+    console.log("Done!");
+};