@drift-labs/vaults-sdk 0.1.531 → 0.1.533

package/cli/cli.ts

@@ -16,6 +16,7 @@ import {
     requestWithdraw,
     withdraw,
     forceWithdraw,
+    forceWithdrawAll,
     listDepositorsForVault,
     managerUpdateMarginTradingEnabled,
     decodeLogs,
@@ -148,6 +149,11 @@ program
     .addOption(new Option("--vault-depositor-authority <vaultDepositorAuthority>", "Authority address of VaultDepositor, must also provide --vault-address").makeOptionMandatory(false))
     .addOption(new Option("--vault-address <vaultAddress>", "Address of vault, must required if only --vault-deposit-authority is provided").makeOptionMandatory(false))
     .action((opts) => forceWithdraw(program, opts));
+program
+    .command("force-withdraw-all")
+    .description("Processes all pending withdrawals that are ready to be redeemed")
+    .addOption(new Option("--vault-address <vaultAddress>", "Address of vault, must required if only --vault-deposit-authority is provided").makeOptionMandatory(true))
+    .action((opts) => forceWithdrawAll(program, opts));
 program
     .command("decode-logs")
     .description("Decode program logs from a txid")

package/cli/commands/applyProfitShare.ts

@@ -1,4 +1,4 @@
-import { ComputeBudgetProgram, PublicKey, TransactionInstruction, VersionedTransactionResponse } from "@solana/web3.js";
+import { ComputeBudgetProgram, PublicKey, SendTransactionError, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
 import {
     OptionValues,
     Command
@@ -21,6 +21,7 @@ export const applyProfitShare = async (program: Command, cmdOpts: OptionValues)
     const {
         driftVault,
         driftClient,
+        wallet,
     } = await getCommandContext(program, true);
 
     const vault = await driftVault.getVault(vaultAddress);
@@ -72,24 +73,21 @@ export const applyProfitShare = async (program: Command, cmdOpts: OptionValues)
                 units: 170_000,
             }));
 
-            const tx = await driftClient.txSender.getVersionedTransaction(ixs, [], undefined, undefined);
+            const message = new TransactionMessage({
+                payerKey: driftClient.wallet.publicKey,
+                recentBlockhash: (await driftClient.connection.getLatestBlockhash('finalized')).blockhash,
+                instructions: ixs,
+            }).compileToV0Message();
 
-            let attempt = 0;
-            let txResp: VersionedTransactionResponse | null = null;
-            while (txResp === null) {
-                attempt++;
-                const { txSig } = await driftClient.txSender.sendVersionedTransaction(
-                    tx,
-                );
-                console.log(`[${i}]: https://solscan.io/tx/${txSig} (attempt ${attempt})`);
+            const tx = await wallet.signVersionedTransaction(new VersionedTransaction(message));
 
-                await new Promise(resolve => setTimeout(resolve, 1000));
-
-                txResp = await driftClient.connection.getTransaction(txSig, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 });
+            try {
+                const txid = await driftClient.connection.sendTransaction(tx);
+                console.log(`Sent chunk: ${txid}`);
+            } catch (e) {
+                console.error(`Error sending chunk: ${e}`);
+                console.log((e as SendTransactionError).logs);
             }
-            console.log(txResp);
-
-
         } catch (e) {
             console.error(e);
             continue;

package/cli/commands/forceWithdrawAll.ts

@@ -0,0 +1,101 @@
+import { ComputeBudgetProgram, PublicKey, SendTransactionError, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { VaultDepositor } from "../../src";
+import {
+    BN,
+    convertToNumber
+} from "@drift-labs/sdk";
+import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
+
+export const forceWithdrawAll = async (program: Command, cmdOpts: OptionValues) => {
+    let vaultAddress: PublicKey | undefined;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        throw new Error("Must provide --vault-address");
+    }
+
+    if (!vaultAddress) {
+        throw new Error("Failed to derive vault depositor address");
+    }
+
+    const {
+        driftVault,
+        driftClient,
+        wallet,
+    } = await getCommandContext(program, true);
+
+    const vault = await driftVault.getVault(vaultAddress);
+    const allVaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+    const spotMarket = driftVault.driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+    const spotPrecision = new BN(10).pow(new BN(spotMarket!.decimals));
+
+    const withdrawables: Array<PublicKey> = [];
+    for (const vd of allVaultDepositors) {
+        const vdAccount = vd.account as VaultDepositor;
+        if (vdAccount.lastWithdrawRequest.shares.gt(new BN(0))) {
+            const withdrawRequested = vdAccount.lastWithdrawRequest.ts.toNumber();
+            const secToWithdrawal = withdrawRequested + vault.redeemPeriod.toNumber() - Date.now() / 1000;
+            const withdrawAvailable = secToWithdrawal < 0;
+            const pct = vdAccount.lastWithdrawRequest.shares.toNumber() / vd.account.vaultShares.toNumber();
+            const daysUntilWithdraw = Math.floor(secToWithdrawal / 86400);
+            const hoursUntilWithdraw = Math.floor((secToWithdrawal % 86400) / 3600);
+
+            if (secToWithdrawal < 0) {
+                console.log(`Withdraw available for ${vdAccount.authority.toBase58()}`);
+                console.log(`  - pending withdrawal: ${vdAccount.lastWithdrawRequest.shares.toString()} ($${convertToNumber(vd.account.lastWithdrawRequest.value, spotPrecision)}), ${(pct * 100.00).toFixed(2)}% of their deposit ${withdrawAvailable ? "<--- WITHDRAWABLE" : ""}`);
+                console.log(`    - requested at: ${new Date(withdrawRequested * 1000).toISOString()}`);
+                console.log(`    - can withdraw in: ${daysUntilWithdraw} days and ${hoursUntilWithdraw} hours`);
+            }
+
+            withdrawables.push(vdAccount.pubkey);
+        }
+    }
+
+    console.log(`Withdrawing ${withdrawables.length} depositors`);
+    const chunkSize = 3;
+    for (let i = 0; i < withdrawables.length; i += chunkSize) {
+        const chunk = withdrawables.slice(i, i + chunkSize);
+        console.log(`Processing chunk ${i / chunkSize + 1} of ${Math.ceil(withdrawables.length / chunkSize)}`);
+        const ixs = [];
+        for (const depositorAddress of chunk) {
+            try {
+                ixs.push(...await driftVault.getForceWithdrawIx(depositorAddress));
+            } catch (error) {
+                console.error(`Error withdrawing for ${depositorAddress.toBase58()}:`, error);
+            }
+        }
+
+        const message = new TransactionMessage({
+            payerKey: driftClient.wallet.publicKey,
+            recentBlockhash: (await driftClient.connection.getLatestBlockhash('finalized')).blockhash,
+            instructions: [
+                ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 600_000,
+                }),
+                ComputeBudgetProgram.setComputeUnitPrice({
+                    microLamports: 10_000,
+                }),
+                ...ixs
+            ],
+        }).compileToV0Message();
+
+        const tx = await wallet.signVersionedTransaction(new VersionedTransaction(message));
+
+        console.log(`Sending chunk: ${bs58.encode(tx.signatures[0])}`);
+        try {
+            const txid = await driftClient.connection.sendTransaction(tx);
+            console.log(`Sent chunk: ${txid}`);
+        } catch (e) {
+            console.error(`Error sending chunk: ${e}`);
+            console.log((e as SendTransactionError).logs);
+        }
+    }
+
+    // const tx = await driftVault.forceWithdraw(vaultDepositorAddress);
+    // console.log(`Forced withdraw from vault: ${tx}`);
+};

package/cli/commands/index.ts

@@ -12,6 +12,7 @@ export * from './initVaultDepositor';
 export * from './deposit';
 export * from './requestWithdraw';
 export * from './forceWithdraw';
+export * from './forceWithdrawAll';
 export * from './withdraw';
 export * from './listDepositorsForVault';
 export * from './managerUpdateMarginTradingEnabled';

package/cli/utils.ts

@@ -116,6 +116,7 @@ export function printVaultDepositor(vaultDepositor: VaultDepositor) {
 export async function getCommandContext(program: Command, needToSign: boolean): Promise<{
     driftClient: DriftClient,
     driftVault: VaultClient,
+    wallet: Wallet,
 }> {
 
     const opts = program.opts();
@@ -189,5 +190,6 @@ export async function getCommandContext(program: Command, needToSign: boolean):
     return {
         driftClient,
         driftVault,
+        wallet,
     };
 }

package/lib/addresses.d.ts

@@ -2,4 +2,7 @@ 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;
+export declare function getInsuranceFundTokenVaultAddressSync(programId: PublicKey, vault: PublicKey, marketIndex: number): PublicKey;
 export declare function getVaultProtocolAddressSync(programId: PublicKey, vault: PublicKey): PublicKey;
+export declare function getTokenizedVaultAddressSync(programId: PublicKey, vault: PublicKey, sharesBase: number): PublicKey;
+export declare function getTokenizedVaultMintAddressSync(programId: PublicKey, vault: PublicKey, sharesBase: number): PublicKey;

package/lib/addresses.js

@@ -26,7 +26,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVaultAddressSync = getVaultAddressSync;
 exports.getVaultDepositorAddressSync = getVaultDepositorAddressSync;
 exports.getTokenVaultAddressSync = getTokenVaultAddressSync;
+exports.getInsuranceFundTokenVaultAddressSync = getInsuranceFundTokenVaultAddressSync;
 exports.getVaultProtocolAddressSync = getVaultProtocolAddressSync;
+exports.getTokenizedVaultAddressSync = getTokenizedVaultAddressSync;
+exports.getTokenizedVaultMintAddressSync = getTokenizedVaultMintAddressSync;
 const web3_js_1 = require("@solana/web3.js");
 const anchor = __importStar(require("@coral-xyz/anchor"));
 function getVaultAddressSync(programId, encodedName) {
@@ -48,9 +51,30 @@ function getTokenVaultAddressSync(programId, vault) {
         vault.toBuffer(),
     ], programId)[0];
 }
+function getInsuranceFundTokenVaultAddressSync(programId, vault, marketIndex) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('vault_token_account')),
+        vault.toBuffer(),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
 function getVaultProtocolAddressSync(programId, vault) {
     return web3_js_1.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('vault_protocol')),
         vault.toBuffer(),
     ], programId)[0];
 }
+function getTokenizedVaultAddressSync(programId, vault, sharesBase) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('tokenized_vault_depositor')),
+        vault.toBuffer(),
+        Buffer.from(anchor.utils.bytes.utf8.encode(sharesBase.toString())),
+    ], programId)[0];
+}
+function getTokenizedVaultMintAddressSync(programId, vault, sharesBase) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('mint')),
+        vault.toBuffer(),
+        Buffer.from(anchor.utils.bytes.utf8.encode(sharesBase.toString())),
+    ], programId)[0];
+}