@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.12

package/src/clearingHouse.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, BN, Idl, Program } from '@project-serum/anchor';
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import {
 	StateAccount,
 	IWallet,
@@ -27,6 +27,10 @@ import {
 	Transaction,
 	TransactionInstruction,
 	AccountMeta,
+	Keypair,
+	LAMPORTS_PER_SOL,
+	Signer,
+	SystemProgram,
 } from '@solana/web3.js';
 
 import { TokenFaucet } from './tokenFaucet';
@@ -57,6 +61,7 @@ import { RetryTxSender } from './tx/retryTxSender';
 import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
 import { getMarketsBanksAndOraclesForSubscription } from './config';
+import { WRAPPED_SOL_MINT } from './constants/banks';
 
 /**
  * # ClearingHouse
@@ -399,6 +404,7 @@ export class ClearingHouse {
 	getRemainingAccounts(params: {
 		writableMarketIndex?: BN;
 		writableBankIndex?: BN;
+		readableMarketIndex?: BN;
 	}): AccountMeta[] {
 		const userAccountAndSlot = this.getUserAccountAndSlot();
 		if (!userAccountAndSlot) {
@@ -439,8 +445,7 @@ export class ClearingHouse {
 				marketAccountMap.set(marketIndexNum, {
 					pubkey: marketAccount.pubkey,
 					isSigner: false,
-					// isWritable: false, // TODO
-					isWritable: true,
+					isWritable: false,
 				});
 				oracleAccountMap.set(marketAccount.pubkey.toString(), {
 					pubkey: marketAccount.amm.oracle,
@@ -450,6 +455,22 @@ export class ClearingHouse {
 			}
 		}
 
+		if (params.readableMarketIndex) {
+			const marketAccount = this.getMarketAccount(
+				params.readableMarketIndex.toNumber()
+			);
+			marketAccountMap.set(params.readableMarketIndex.toNumber(), {
+				pubkey: marketAccount.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
+			oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+				pubkey: marketAccount.amm.oracle,
+				isSigner: false,
+				isWritable: false,
+			});
+		}
+
 		if (params.writableMarketIndex) {
 			const marketAccount = this.getMarketAccount(
 				params.writableMarketIndex.toNumber()
@@ -527,6 +548,31 @@ export class ClearingHouse {
 		userId?: number,
 		reduceOnly = false
 	): Promise<TransactionSignature> {
+		const tx = new Transaction();
+		const additionalSigners: Array<Signer> = [];
+
+		const bank = this.getBankAccount(bankIndex);
+
+		const isSolBank = bank.mint.equals(WRAPPED_SOL_MINT);
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolBank && collateralAccountPublicKey.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount);
+
+			collateralAccountPublicKey = pubkey;
+
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
+
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
 			bankIndex,
@@ -536,9 +582,26 @@ export class ClearingHouse {
 			true
 		);
 
-		const tx = new Transaction().add(depositCollateralIx);
+		tx.add(depositCollateralIx);
+
+		// Close the wrapped sol account at the end of the transaction
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
+					collateralAccountPublicKey,
+					authority,
+					authority,
+					[]
+				)
+			);
+		}
 
-		const { txSig } = await this.txSender.send(tx);
+		const { txSig } = await this.txSender.send(
+			tx,
+			additionalSigners,
+			this.opts
+		);
 		return txSig;
 	}
 
@@ -600,12 +663,119 @@ export class ClearingHouse {
 		);
 	}
 
+	private async checkIfAccountExists(account: PublicKey) {
+		try {
+			const accountInfo = await this.connection.getAccountInfo(account);
+			return accountInfo && true;
+		} catch (e) {
+			// Doesn't already exist
+			return false;
+		}
+	}
+
+	private async getSolWithdrawalIxs(
+		bankIndex: BN,
+		amount: BN
+	): Promise<{
+		ixs: anchor.web3.TransactionInstruction[];
+		signers: Signer[];
+		pubkey: PublicKey;
+	}> {
+		const result = {
+			ixs: [],
+			signers: [],
+			pubkey: PublicKey.default,
+		};
+
+		// Create a temporary wrapped SOL account to store the SOL that we're withdrawing
+
+		const authority = this.wallet.publicKey;
+
+		const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(
+			amount
+		);
+		result.pubkey = pubkey;
+
+		ixs.forEach((ix) => {
+			result.ixs.push(ix);
+		});
+
+		signers.forEach((ix) => {
+			result.signers.push(ix);
+		});
+
+		const withdrawIx = await this.getWithdrawIx(
+			amount,
+			bankIndex,
+			pubkey,
+			true
+		);
+
+		result.ixs.push(withdrawIx);
+
+		result.ixs.push(
+			Token.createCloseAccountInstruction(
+				TOKEN_PROGRAM_ID,
+				pubkey,
+				authority,
+				authority,
+				[]
+			)
+		);
+
+		return result;
+	}
+
+	private async getWrappedSolAccountCreationIxs(amount: BN): Promise<{
+		ixs: anchor.web3.TransactionInstruction[];
+		signers: Signer[];
+		pubkey: PublicKey;
+	}> {
+		const wrappedSolAccount = new Keypair();
+
+		const result = {
+			ixs: [],
+			signers: [],
+			pubkey: wrappedSolAccount.publicKey,
+		};
+
+		const rentSpaceLamports = new BN(LAMPORTS_PER_SOL / 100);
+
+		const depositAmountLamports = amount.add(rentSpaceLamports);
+
+		const authority = this.wallet.publicKey;
+
+		result.ixs.push(
+			SystemProgram.createAccount({
+				fromPubkey: authority,
+				newAccountPubkey: wrappedSolAccount.publicKey,
+				lamports: depositAmountLamports.toNumber(),
+				space: 165,
+				programId: TOKEN_PROGRAM_ID,
+			})
+		);
+
+		result.ixs.push(
+			Token.createInitAccountInstruction(
+				TOKEN_PROGRAM_ID,
+				WRAPPED_SOL_MINT,
+				wrappedSolAccount.publicKey,
+				authority
+			)
+		);
+
+		result.signers.push(wrappedSolAccount);
+
+		return result;
+	}
+
 	/**
 	 * Creates the Clearing House User account for a user, and deposits some initial collateral
-	 * @param userId
-	 * @param name
 	 * @param amount
 	 * @param userTokenAccount
+	 * @param bankIndex
+	 * @param userId
+	 * @param name
 	 * @param fromUserId
 	 * @returns
 	 */
@@ -620,6 +790,35 @@ export class ClearingHouse {
 		const [userAccountPublicKey, initializeUserAccountIx] =
 			await this.getInitializeUserInstructions(userId, name);
 
+		const additionalSigners: Array<Signer> = [];
+
+		const bank = this.getBankAccount(bankIndex);
+
+		const isSolBank = bank.mint.equals(WRAPPED_SOL_MINT);
+
+		const tx = new Transaction();
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolBank && userTokenAccount.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const {
+				ixs: startIxs,
+				signers,
+				pubkey,
+			} = await this.getWrappedSolAccountCreationIxs(amount);
+
+			userTokenAccount = pubkey;
+
+			startIxs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
+
 		const depositCollateralIx =
 			fromUserId != null
 				? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
@@ -632,11 +831,26 @@ export class ClearingHouse {
 						false
 				  );
 
-		const tx = new Transaction()
-			.add(initializeUserAccountIx)
-			.add(depositCollateralIx);
+		tx.add(initializeUserAccountIx).add(depositCollateralIx);
 
-		const { txSig } = await this.txSender.send(tx, []);
+		// Close the wrapped sol account at the end of the transaction
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
+					userTokenAccount,
+					authority,
+					authority,
+					[]
+				)
+			);
+		}
+
+		const { txSig } = await this.txSender.send(
+			tx,
+			additionalSigners,
+			this.opts
+		);
 
 		return [txSig, userAccountPublicKey];
 	}
@@ -683,16 +897,56 @@ export class ClearingHouse {
 		userTokenAccount: PublicKey,
 		reduceOnly = false
 	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getWithdrawIx(
-					amount,
-					bankIndex,
+		const tx = new Transaction();
+		const additionalSigners: Array<Signer> = [];
+
+		const bank = this.getBankAccount(bankIndex);
+
+		const isSolBank = bank.mint.equals(WRAPPED_SOL_MINT);
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolBank && userTokenAccount.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount);
+
+			userTokenAccount = pubkey;
+
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
+
+		const withdrawCollateral = await this.getWithdrawIx(
+			amount,
+			bank.bankIndex,
+			userTokenAccount,
+			reduceOnly
+		);
+
+		tx.add(withdrawCollateral);
+
+		// Close the wrapped sol account at the end of the transaction
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
 					userTokenAccount,
-					reduceOnly
+					authority,
+					authority,
+					[]
 				)
-			),
-			[],
+			);
+		}
+
+		const { txSig } = await this.txSender.send(
+			tx,
+			additionalSigners,
 			this.opts
 		);
 		return txSig;
@@ -840,7 +1094,7 @@ export class ClearingHouse {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableMarketIndex: orderParams.marketIndex,
+			readableMarketIndex: orderParams.marketIndex,
 		});
 
 		return await this.program.instruction.placeOrder(orderParams, {
@@ -983,24 +1237,13 @@ export class ClearingHouse {
 		const bankAccountMap = new Map<number, AccountMeta>();
 		const marketAccountMap = new Map<number, AccountMeta>();
 
-		marketAccountMap.set(marketIndex.toNumber(), {
-			pubkey: marketAccount.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isWritable: false,
-			isSigner: false,
-		});
-
 		for (const bankBalance of userAccount.bankBalances) {
 			if (!bankBalance.balance.eq(ZERO)) {
 				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
 				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
 					pubkey: bankAccount.pubkey,
 					isSigner: false,
-					isWritable: true,
+					isWritable: false,
 				});
 
 				if (!bankAccount.oracle.equals(PublicKey.default)) {
@@ -1021,7 +1264,7 @@ export class ClearingHouse {
 				const market = this.getMarketAccount(position.marketIndex);
 				marketAccountMap.set(position.marketIndex.toNumber(), {
 					pubkey: market.pubkey,
-					isWritable: true,
+					isWritable: false,
 					isSigner: false,
 				});
 				oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -1032,6 +1275,17 @@ export class ClearingHouse {
 			}
 		}
 
+		marketAccountMap.set(marketIndex.toNumber(), {
+			pubkey: marketAccount.pubkey,
+			isWritable: true,
+			isSigner: false,
+		});
+		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+			pubkey: marketAccount.amm.oracle,
+			isWritable: false,
+			isSigner: false,
+		});
+
 		const remainingAccounts = [
 			...oracleAccountMap.values(),
 			...bankAccountMap.values(),
@@ -1087,24 +1341,13 @@ export class ClearingHouse {
 		const bankAccountMap = new Map<number, AccountMeta>();
 		const marketAccountMap = new Map<number, AccountMeta>();
 
-		marketAccountMap.set(marketIndex.toNumber(), {
-			pubkey: marketAccount.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isWritable: false,
-			isSigner: false,
-		});
-
 		for (const bankBalance of userAccount.bankBalances) {
 			if (!bankBalance.balance.eq(ZERO)) {
 				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
 				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
 					pubkey: bankAccount.pubkey,
 					isSigner: false,
-					isWritable: true,
+					isWritable: false,
 				});
 
 				if (!bankAccount.oracle.equals(PublicKey.default)) {
@@ -1125,7 +1368,7 @@ export class ClearingHouse {
 				const market = this.getMarketAccount(position.marketIndex);
 				marketAccountMap.set(position.marketIndex.toNumber(), {
 					pubkey: market.pubkey,
-					isWritable: true,
+					isWritable: false,
 					isSigner: false,
 				});
 				oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -1136,6 +1379,17 @@ export class ClearingHouse {
 			}
 		}
 
+		marketAccountMap.set(marketIndex.toNumber(), {
+			pubkey: marketAccount.pubkey,
+			isWritable: true,
+			isSigner: false,
+		});
+		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+			pubkey: marketAccount.amm.oracle,
+			isWritable: false,
+			isSigner: false,
+		});
+
 		const remainingAccounts = [
 			...oracleAccountMap.values(),
 			...bankAccountMap.values(),
@@ -1328,7 +1582,7 @@ export class ClearingHouse {
 				const market = this.getMarketAccount(position.marketIndex);
 				marketAccountMap.set(position.marketIndex.toNumber(), {
 					pubkey: market.pubkey,
-					isWritable: true, // TODO
+					isWritable: false,
 					isSigner: false,
 				});
 				oracleAccountMap.set(market.amm.oracle.toString(), {

package/src/clearingHouseConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });