@velocity-exchange/vaults-sdk 0.0.1

package/cli/commands/viewVault.ts

@@ -0,0 +1,50 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext, printVault } from "../utils";
+import { FeeUpdate, getFeeUpdateAddressSync } from "../../src";
+
+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,
+        driftClient,
+    } = await getCommandContext(program, false);
+
+
+    const vaultAndSlot = await driftVault.getVaultAndSlot(address);
+    const vault = vaultAndSlot.vault;
+    const spotMarket = driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+    if (!spotMarket) {
+        throw new Error(`Spot market ${vault.spotMarketIndex} not found`);
+    }
+    const spotOracle = driftClient.getOracleDataForSpotMarket(vault.spotMarketIndex);
+    if (!spotOracle) {
+        throw new Error(`Spot oracle ${vault.spotMarketIndex} not found`);
+    }
+    const vaultEquity = await driftVault.calculateVaultEquity({
+        vault,
+    });
+
+    let feeUpdateAccount: FeeUpdate | null = null;
+
+    try {
+        const feeUpdatePubkey = getFeeUpdateAddressSync(driftVault.program.programId, address);
+        feeUpdateAccount = await driftVault.getFeeUpdate(feeUpdatePubkey);
+    } catch (err) {
+        feeUpdateAccount = null;
+    }
+
+    await printVault(vaultAndSlot.slot, driftClient, vault, vaultEquity, spotMarket, spotOracle, feeUpdateAccount);
+};
+

package/cli/commands/viewVaultDepositor.ts

@@ -0,0 +1,36 @@
+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);
+};

package/cli/commands/withdraw.ts

@@ -0,0 +1,40 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { getVaultDepositorAddressSync, VAULT_PROGRAM_ID } from "../../src";
+
+export const withdraw = async (program: Command, cmdOpts: OptionValues) => {
+
+    // verify correct args provided
+    if (!cmdOpts.vaultDepositorAddress) {
+        if (!cmdOpts.vaultAddress || !cmdOpts.authority) {
+            console.error("Must provide --vault-address and --authority if not providing --vault-depositor-address");
+            process.exit(1);
+        }
+    }
+
+    const {
+        driftVault,
+        driftClient
+    } = await getCommandContext(program, true);
+
+    let vaultDepositorAddress: PublicKey;
+    if (cmdOpts.vaultDepositorAddress) {
+        try {
+            vaultDepositorAddress = new PublicKey(cmdOpts.vaultDepositorAddress as string);
+        } catch (err) {
+            console.error("Invalid vault depositor address");
+            process.exit(1);
+        }
+    } else {
+        const vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+        const authority = new PublicKey(cmdOpts.authority as string);
+        vaultDepositorAddress = getVaultDepositorAddressSync(VAULT_PROGRAM_ID, vaultAddress, authority);
+    }
+
+    const tx = await driftVault.withdraw(vaultDepositorAddress);
+    console.log(`Withdrew from vault: https://solana.fm/tx/${tx}${driftClient.env === "devnet" ? "?cluster=devnet-solana" : ""}`);
+};

package/cli/ledgerWallet.test.ts

@@ -0,0 +1,49 @@
+import assert from 'assert';
+
+import { parseKeypairUrl } from './ledgerWallet';
+
+assert.deepStrictEqual(parseKeypairUrl(''), {
+  walletId: undefined,
+  account: undefined,
+  change: undefined,
+});
+
+assert.deepStrictEqual(parseKeypairUrl('usb://ledger'), {
+  walletId: undefined,
+  account: undefined,
+  change: undefined,
+});
+
+assert.deepStrictEqual(parseKeypairUrl('usb://ledger?key=1'), {
+  walletId: undefined,
+  account: 1,
+  change: undefined,
+});
+
+assert.deepStrictEqual(parseKeypairUrl('usb://ledger?key=1/2'), {
+  walletId: undefined,
+  account: 1,
+  change: 2,
+});
+
+assert.deepStrictEqual(
+  parseKeypairUrl(
+    'usb://ledger/BsNsvfXqQTtJnagwFWdBS7FBXgnsK8VZ5CmuznN85swK?key=0'
+  ),
+  {
+    walletId: 'BsNsvfXqQTtJnagwFWdBS7FBXgnsK8VZ5CmuznN85swK',
+    account: 0,
+    change: undefined,
+  }
+);
+
+assert.deepStrictEqual(
+  parseKeypairUrl(
+    'usb://ledger/BsNsvfXqQTtJnagwFWdBS7FBXgnsK8VZ5CmuznN85swK?key=0/0'
+  ),
+  {
+    walletId: 'BsNsvfXqQTtJnagwFWdBS7FBXgnsK8VZ5CmuznN85swK',
+    account: 0,
+    change: 0,
+  }
+);

package/cli/ledgerWallet.ts

@@ -0,0 +1,111 @@
+import Solana from '@ledgerhq/hw-app-solana';
+import type { default as Transport } from '@ledgerhq/hw-transport';
+import TransportNodeHid from '@ledgerhq/hw-transport-node-hid';
+import { getDevices } from '@ledgerhq/hw-transport-node-hid-noevents';
+import {
+	LedgerWalletAdapter,
+	getDerivationPath,
+} from '@solana/wallet-adapter-ledger';
+import { PublicKey, Keypair } from '@solana/web3.js';
+import type { Wallet } from '@velocity-exchange/sdk';
+
+// Follows solana cli url format
+// usb://<MANUFACTURER>[/<WALLET_ID>][?key=<ACCOUNT>[/<CHANGE>]]
+// See: https://docs.solanalabs.com/cli/intro#hardware-wallet
+export const parseKeypairUrl = (
+	url = ''
+): {
+	walletId?: string;
+	account?: number;
+	change?: number;
+} => {
+	const walletId = url.match(/(?<=usb:\/\/ledger\/)(\w+)?/)?.[0];
+	const [account, change] = (url.split('?key=')[1]?.split('/') ?? []).map(
+		Number
+	);
+	return {
+		walletId,
+		account,
+		change,
+	};
+};
+
+async function getPublicKey(
+	transport: Transport,
+	account?: number,
+	change?: number
+): Promise<PublicKey> {
+	const path =
+		"44'/501'" + // Following BIP44 standard
+		(account !== undefined ? `/${account}` : '') +
+		(change !== undefined ? `/${change}` : '');
+
+	const { address } = await new Solana(transport).getAddress(path);
+	return new PublicKey(new Uint8Array(address));
+}
+
+/*
+ * Returns a Drift compatible wallet backed by ledger hardware device
+ * This only works in an nodejs environment, based on the transport used
+ *
+ * Key derivation path is set based on:
+ * See: https://docs.solanalabs.com/cli/intro#hardware-wallet
+ */
+export async function getLedgerWallet(url = ''): Promise<Wallet> {
+	const { account, change, walletId } = parseKeypairUrl(url);
+
+	const derivationPath = getDerivationPath(account, change);
+
+	// Load the first device
+	let transport = await TransportNodeHid.open('');
+
+	// If walletId is specified, we need to loop and correct device.
+	if (walletId) {
+		const devices = getDevices();
+		let correctDeviceFound = false;
+
+		for (const device of devices) {
+			// Wallet id is the public key of the device (with no account or change)
+			const connectedWalletId = await getPublicKey(
+				transport,
+				undefined,
+				undefined
+			);
+
+			if (connectedWalletId.toString() === walletId) {
+				correctDeviceFound = true;
+				break;
+			}
+
+			transport.close();
+			transport = await TransportNodeHid.open(device.path);
+		}
+
+		if (!correctDeviceFound) {
+			throw new Error('Wallet not found');
+		}
+	}
+
+	const publicKey = await getPublicKey(transport, account, change);
+
+	// We can reuse the existing ledger wallet adapter
+	// But we need to inject/hack in our own transport (as we not a browser)
+	const wallet = new LedgerWalletAdapter({ derivationPath });
+
+	// Do some hacky things to get the wallet to work
+	// These are all done in the `connect` of the ledger wallet adapter
+	wallet['_transport'] = transport;
+	wallet['_publicKey'] = publicKey;
+	transport.on('disconnect', wallet['_disconnected']);
+	wallet.emit('connect', publicKey);
+
+	// Return a Drift compatible wallet
+	return {
+		payer: undefined as unknown as Keypair, // Doesn't appear to break things
+		publicKey: publicKey,
+		signTransaction: wallet.signTransaction.bind(wallet),
+		signVersionedTransaction: wallet.signTransaction.bind(wallet),
+		signAllTransactions: wallet.signAllTransactions.bind(wallet),
+		signAllVersionedTransactions: wallet.signAllTransactions.bind(wallet),
+	};
+}

package/cli/utils.ts

@@ -0,0 +1,389 @@
+import {
+	BASE_PRECISION,
+	BN,
+	DriftClient,
+	DriftEnv,
+	OraclePriceData,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+	SpotMarketAccount,
+	TEN,
+	User,
+	Wallet,
+	WhileValidTxSender,
+	convertToNumber,
+	getSignedTokenAmount,
+	getTokenAmount,
+	loadKeypair,
+} from '@velocity-exchange/sdk';
+import {
+	FeeUpdate,
+	Vault,
+	VaultClass,
+	VaultClient,
+	VaultDepositor,
+	decodeName,
+} from '../src';
+import { Command } from 'commander';
+import {
+	Connection,
+	Keypair,
+	PublicKey,
+	Transaction,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import { AnchorProvider, Wallet as AnchorWallet } from '@coral-xyz/anchor';
+import * as anchor from '@coral-xyz/anchor';
+import { IDL } from '../src/utils';
+import { DriftVaults } from '../src/types/drift_vaults';
+import { getLedgerWallet } from './ledgerWallet';
+import fs from 'fs';
+import { bs58 } from '@coral-xyz/anchor/dist/cjs/utils/bytes';
+
+export async function printVault(
+	slot: number,
+	driftClient: DriftClient,
+	vault: Vault,
+	vaultEquity: BN,
+	spotMarket: SpotMarketAccount,
+	spotOracle: OraclePriceData,
+	feeUpdateAccount: FeeUpdate | null = null
+) {
+	const oraclePriceNum = convertToNumber(spotOracle.price, PRICE_PRECISION);
+	const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+	const spotSymbol = decodeName(spotMarket.name);
+
+	console.log(`slot: ${slot}`);
+	console.log(`vault: ${decodeName(vault.name)}`);
+	console.log(`vaultClass:     ${vault.vaultClass}`);
+	if (vault.vaultClass === VaultClass.TRUSTED) {
+		console.log(
+			`  managerBorrowedValue: ${convertToNumber(
+				vault.managerBorrowedValue,
+				spotPrecision
+			)} ${spotSymbol}`
+		);
+	}
+	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);
+	const managerSharePct =
+		managerShares.toNumber() / vault.totalShares.toNumber();
+	console.log(
+		`  [managerShares]: ${managerShares.toString()} (${(
+			managerSharePct * 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:               ${convertToNumber(
+			vault.maxTokens,
+			spotPrecision
+		)} ${spotSymbol} (${vault.maxTokens.toString()})`
+	);
+	console.log(`sharesBase:              ${vault.sharesBase}`);
+	console.log(`managementFee:           ${vault.managementFee.toString()}`);
+	console.log(`initTs:                  ${vault.initTs.toString()}`);
+	console.log(
+		`netDeposits:             ${convertToNumber(
+			vault.netDeposits,
+			spotPrecision
+		)} ${spotSymbol} (${vault.netDeposits.toString()})`
+	);
+	console.log(
+		`totalDeposits:           ${convertToNumber(
+			vault.totalDeposits,
+			spotPrecision
+		)} ${spotSymbol} (${vault.totalDeposits.toString()})`
+	);
+	console.log(
+		`totalWithdraws:          ${convertToNumber(
+			vault.totalWithdraws,
+			spotPrecision
+		)} ${spotSymbol} (${vault.totalWithdraws.toString()})`
+	);
+	console.log(
+		`managerNetDeposits:      ${convertToNumber(
+			vault.managerNetDeposits,
+			spotPrecision
+		)} ${spotSymbol} (${vault.managerNetDeposits.toString()})`
+	);
+	console.log(
+		`managerTotalDeposits:    ${convertToNumber(
+			vault.managerTotalDeposits,
+			spotPrecision
+		)} ${spotSymbol} (${vault.managerTotalDeposits.toString()})`
+	);
+	console.log(
+		`managerTotalWithdraws:   ${convertToNumber(
+			vault.managerTotalWithdraws,
+			spotPrecision
+		)} ${spotSymbol} (${vault.managerTotalWithdraws.toString()})`
+	);
+	console.log(
+		`managerTotalFee:         ${convertToNumber(
+			vault.managerTotalFee,
+			spotPrecision
+		)} ${spotSymbol} (${vault.managerTotalFee.toString()})`
+	);
+	console.log(
+		`managerTotalProfitShare: ${convertToNumber(
+			vault.managerTotalProfitShare,
+			spotPrecision
+		)} ${spotSymbol} (${vault.managerTotalProfitShare.toString()})`
+	);
+	console.log(`lastManagerWithdrawRequest:`);
+	console.log(
+		`  shares: ${vault.lastManagerWithdrawRequest.shares.toString()}`
+	);
+	console.log(
+		`  values: ${convertToNumber(
+			vault.lastManagerWithdrawRequest.value,
+			spotPrecision
+		)} ${spotSymbol} (${vault.lastManagerWithdrawRequest.value.toString()})`
+	);
+	console.log(`  ts:     ${vault.lastManagerWithdrawRequest.ts.toString()}`);
+	console.log(`FeeUpdate Account:`);
+	if (feeUpdateAccount) {
+		const timeUntilUpdate = feeUpdateAccount.incomingUpdateTs.sub(
+			new BN(Date.now() / 1000)
+		);
+		console.log(
+			`  incomingUpdateTs: ${feeUpdateAccount.incomingUpdateTs.toString()} (in ${timeUntilUpdate.toString()} seconds)`
+		);
+		console.log(
+			`  incomingManagementFee: ${vault.managementFee.toString()} -> ${feeUpdateAccount.incomingManagementFee.toString()}`
+		);
+		console.log(
+			`  incomingProfitShare:   ${vault.profitShare} -> ${feeUpdateAccount.incomingProfitShare}`
+		);
+		console.log(
+			`  incomingHurdleRate:    ${vault.hurdleRate} -> ${feeUpdateAccount.incomingHurdleRate}`
+		);
+	} else {
+		console.log(`  None`);
+	}
+	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}`);
+
+	const vaultEquityNum = convertToNumber(vaultEquity, QUOTE_PRECISION);
+	const netDepositsNum = convertToNumber(vault.netDeposits, spotPrecision);
+	console.log(`vaultEquity (USDC):   $${vaultEquityNum}`);
+	console.log(`manager share (USDC): $${managerSharePct * vaultEquityNum}`);
+
+	const vaultEquitySpot = vaultEquityNum / oraclePriceNum;
+
+	const user = new User({
+		// accountSubscription,
+		driftClient,
+		userAccountPublicKey: vault.user,
+	});
+	await user.subscribe();
+
+	for (const spotPos of user.getActiveSpotPositions()) {
+		const sm = driftClient.getSpotMarketAccount(spotPos.marketIndex)!;
+		const prec = TEN.pow(new BN(sm.decimals));
+		const sym = decodeName(sm.name);
+		const bal = getSignedTokenAmount(
+			getTokenAmount(spotPos.scaledBalance, sm, spotPos.balanceType),
+			spotPos.balanceType
+		);
+		console.log(
+			`Spot Position: ${spotPos.marketIndex}, ${convertToNumber(
+				bal,
+				prec
+			)} ${sym}`
+		);
+	}
+
+	for (const perpPos of user.getActivePerpPositions()) {
+		console.log(
+			`Perp Position: ${perpPos.marketIndex}, base: ${convertToNumber(
+				perpPos.baseAssetAmount,
+				BASE_PRECISION
+			)}, quote: ${convertToNumber(perpPos.quoteAssetAmount, QUOTE_PRECISION)}`
+		);
+		const upnl = user.getUnrealizedPNL(true, perpPos.marketIndex);
+		console.log(`  upnl: ${convertToNumber(upnl, QUOTE_PRECISION)}`);
+	}
+
+	console.log(`vaultEquity (${spotSymbol}):   ${vaultEquitySpot}`);
+	console.log(
+		`manager share (${spotSymbol}): ${managerSharePct * vaultEquitySpot}`
+	);
+	console.log(
+		`vault PnL     (${spotSymbol}):   ${vaultEquitySpot - netDepositsNum}`
+	);
+	console.log(
+		`vault PnL (USD) ${convertToNumber(
+			user.getTotalAllTimePnl(),
+			QUOTE_PRECISION
+		)}`
+	);
+	console.log(
+		`vault PnL (spot) ${
+			convertToNumber(user.getTotalAllTimePnl(), QUOTE_PRECISION) /
+			oraclePriceNum
+		}`
+	);
+
+	return {
+		managerShares,
+		managerSharePct,
+	};
+}
+
+export function printVaultDepositor(vaultDepositor: 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(
+		`lastWithdrawRequest.Shares:   ${vaultDepositor.lastWithdrawRequest.shares.toString()}`
+	);
+	console.log(
+		`lastWithdrawRequest.Value:    ${vaultDepositor.lastWithdrawRequest.value.toString()}`
+	);
+	console.log(
+		`lastWithdrawRequest.Ts:       ${vaultDepositor.lastWithdrawRequest.ts.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;
+	wallet: Wallet;
+}> {
+	const opts = program.opts();
+
+	let wallet: Wallet;
+	const isLedgerUrl = opts.keypair.startsWith('usb://ledger');
+	console.log('isLedgerUrl:', isLedgerUrl);
+
+	if (isLedgerUrl || fs.existsSync(opts.keypair)) {
+		console.log('opts.keypair:', opts.keypair);
+	} else {
+		console.log('opts.keypair:', opts.keypair.replace(/./g, '*'));
+	}
+
+	let loadedKeypair = false;
+	wallet = new Wallet(Keypair.generate());
+
+	if (isLedgerUrl) {
+		wallet = (await getLedgerWallet(opts.keypair)) as unknown as Wallet;
+		loadedKeypair = true;
+	} else if (opts.keypair) {
+		try {
+			const keypair = loadKeypair(opts.keypair as string);
+			wallet = new Wallet(keypair);
+			loadedKeypair = true;
+		} catch (e) {
+			console.error(`Need to provide a valid keypair: ${e}`);
+			process.exit(1);
+		}
+	} else {
+		if (needToSign) {
+			throw new Error('Need to provide a keypair.');
+		}
+	}
+
+	const driftEnv = opts.env as DriftEnv;
+	console.log('driftEnv:', driftEnv);
+
+	if (loadedKeypair) {
+		console.log(`Loaded wallet address: ${wallet.publicKey.toBase58()}`);
+	}
+
+	const connection = new Connection(opts.url, {
+		commitment: opts.commitment,
+	});
+
+	const driftClient = new DriftClient({
+		connection,
+		wallet,
+		env: driftEnv as DriftEnv,
+		opts: {
+			commitment: opts.commitment,
+			skipPreflight: false,
+			preflightCommitment: opts.commitment,
+		},
+		txSender: new WhileValidTxSender({
+			connection,
+			wallet,
+			opts: {
+				maxRetries: 0,
+			},
+			retrySleep: 1000,
+		}),
+	});
+	await driftClient.subscribe();
+
+	const provider = new AnchorProvider(connection, wallet as AnchorWallet, {});
+	anchor.setProvider(provider);
+	const vaultProgram = new anchor.Program<DriftVaults>(IDL, provider);
+
+	const driftVault = new VaultClient({
+		driftClient,
+		program: vaultProgram,
+		cliMode: true,
+	});
+
+	return {
+		driftClient,
+		driftVault,
+		wallet,
+	};
+}
+
+/// a valid blockhash to allow tx simulation
+export const BLOCKHASH_PLACEHOLDER =
+	'CHNfFRxxeCTyy1RRnKGsV2dkrJfKwVEa8zE7cZgK4TSe';
+
+export function dumpTransactionMessage(
+	payer: PublicKey,
+	ixs: Array<TransactionInstruction>
+): string {
+	const tx = new Transaction();
+	tx.add(...ixs);
+	tx.feePayer = payer;
+	tx.recentBlockhash = BLOCKHASH_PLACEHOLDER;
+
+	return bs58.encode(tx.serialize({ requireAllSignatures: false }));
+}