@drift-labs/sdk 0.2.0-temp.2 → 2.0.0

package/src/serum/serumFulfillmentConfigMap.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from '@solana/web3.js';
+import { SerumV3FulfillmentConfigAccount } from '../types';
+import { DriftClient } from '../driftClient';
+
+export class SerumFulfillmentConfigMap {
+	driftClient: DriftClient;
+	map = new Map<number, SerumV3FulfillmentConfigAccount>();
+
+	public constructor(driftClient: DriftClient) {
+		this.driftClient = driftClient;
+	}
+
+	public async add(
+		marketIndex: number,
+		serumMarketAddress: PublicKey
+	): Promise<void> {
+		const account = await this.driftClient.getSerumV3FulfillmentConfig(
+			serumMarketAddress
+		);
+		this.map.set(marketIndex, account);
+	}
+
+	public get(marketIndex: number): SerumV3FulfillmentConfigAccount {
+		return this.map.get(marketIndex);
+	}
+}

package/src/serum/serumSubscriber.ts

@@ -0,0 +1,99 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Market, Orderbook } from '@project-serum/serum';
+import { SerumMarketSubscriberConfig } from './types';
+import { BN } from '@project-serum/anchor';
+import { PRICE_PRECISION } from '../constants/numericConstants';
+
+export class SerumSubscriber {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	accountLoader: BulkAccountLoader;
+	market: Market;
+
+	subscribed: boolean;
+
+	asksAddress: PublicKey;
+	asks: Orderbook;
+	asksCallbackId: string;
+	lastAsksSlot: number;
+
+	bidsAddress: PublicKey;
+	bids: Orderbook;
+	bidsCallbackId: string;
+	lastBidsSlot: number;
+
+	public constructor(config: SerumMarketSubscriberConfig) {
+		this.connection = config.connection;
+		this.programId = config.programId;
+		this.marketAddress = config.marketAddress;
+		this.accountLoader = config.accountSubscription.accountLoader;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscribed) {
+			return;
+		}
+
+		this.market = await Market.load(
+			this.connection,
+			this.marketAddress,
+			undefined,
+			this.programId
+		);
+
+		this.asksAddress = this.market.asksAddress;
+		this.asks = await this.market.loadAsks(this.connection);
+
+		this.asksCallbackId = this.accountLoader.addAccount(
+			this.asksAddress,
+			(buffer, slot) => {
+				this.lastAsksSlot = slot;
+				this.asks = Orderbook.decode(this.market, buffer);
+			}
+		);
+
+		this.bidsAddress = this.market.bidsAddress;
+		this.bids = await this.market.loadBids(this.connection);
+
+		this.bidsCallbackId = this.accountLoader.addAccount(
+			this.bidsAddress,
+			(buffer, slot) => {
+				this.lastBidsSlot = slot;
+				this.bids = Orderbook.decode(this.market, buffer);
+			}
+		);
+
+		this.subscribed = true;
+	}
+
+	public getBestBid(): BN | undefined {
+		const bestBid = this.bids.getL2(1)[0];
+		if (!bestBid) {
+			return undefined;
+		}
+
+		return new BN(bestBid[0] * PRICE_PRECISION.toNumber());
+	}
+
+	public getBestAsk(): BN | undefined {
+		const bestAsk = this.asks.getL2(1)[0];
+		if (!bestAsk) {
+			return undefined;
+		}
+
+		return new BN(bestAsk[0] * PRICE_PRECISION.toNumber());
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+		this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+
+		this.subscribed = false;
+	}
+}

package/src/serum/types.ts

@@ -0,0 +1,13 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+
+export type SerumMarketSubscriberConfig = {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	accountSubscription: {
+		// enables use to add web sockets in the future
+		type: 'polling';
+		accountLoader: BulkAccountLoader;
+	};
+};

package/src/tokenFaucet.ts

@@ -92,11 +92,8 @@ export class TokenFaucet {
 		);
 	}
 
-	public async mintToUser(
-		userTokenAccount: PublicKey,
-		amount: BN
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.mintToUser(amount, {
+	private async mintToUserIx(userTokenAccount: PublicKey, amount: BN) {
+		return this.program.instruction.mintToUser(amount, {
 			accounts: {
 				faucetConfig: await this.getFaucetConfigPublicKey(),
 				mintAccount: this.mint,
@@ -107,6 +104,19 @@ export class TokenFaucet {
 		});
 	}
 
+	public async mintToUser(
+		userTokenAccount: PublicKey,
+		amount: BN
+	): Promise<TransactionSignature> {
+		const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+
+		const tx = new Transaction().add(mintIx);
+
+		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+
+		return txSig;
+	}
+
 	public async transferMintAuthority(): Promise<TransactionSignature> {
 		return await this.program.rpc.transferMintAuthority({
 			accounts: {
@@ -123,12 +133,33 @@ export class TokenFaucet {
 		userPublicKey: PublicKey,
 		amount: BN
 	): Promise<[PublicKey, TransactionSignature]> {
+		const tx = new Transaction();
+
 		const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] =
 			await this.createAssociatedTokenAccountAndMintToInstructions(
 				userPublicKey,
 				amount
 			);
-		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToTx);
+
+		let associatedTokenAccountExists = false;
+
+		try {
+			const assosciatedTokenAccount = await this.connection.getAccountInfo(
+				associatedTokenPublicKey
+			);
+
+			associatedTokenAccountExists = !!assosciatedTokenAccount;
+		} catch (e) {
+			// token account doesn't exist
+			associatedTokenAccountExists = false;
+		}
+
+		const skipAccountCreation = associatedTokenAccountExists;
+
+		if (!skipAccountCreation) tx.add(createAssociatedAccountIx);
+
+		tx.add(mintToTx);
+
 		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
 		return [associatedTokenPublicKey, txSig];
 	}
@@ -153,15 +184,7 @@ export class TokenFaucet {
 				this.wallet.publicKey
 			);
 
-		const mintToIx = await this.program.instruction.mintToUser(amount, {
-			accounts: {
-				faucetConfig: await this.getFaucetConfigPublicKey(),
-				mintAccount: state.mint,
-				userTokenAccount: associateTokenPublicKey,
-				mintAuthority: state.mintAuthority,
-				tokenProgram: TOKEN_PROGRAM_ID,
-			},
-		});
+		const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
 
 		return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
 	}

package/src/tx/retryTxSender.ts

@@ -42,7 +42,8 @@ export class RetryTxSender implements TxSender {
 	async send(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		preSigned?: boolean
 	): Promise<TxSigAndSlot> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
@@ -51,14 +52,24 @@ export class RetryTxSender implements TxSender {
 			opts = this.provider.opts;
 		}
 
-		await this.prepareTx(tx, additionalSigners, opts);
+		if (!preSigned) {
+			await this.prepareTx(tx, additionalSigners, opts);
+		}
 
 		const rawTransaction = tx.serialize();
 		const startTime = this.getTimestamp();
 
-		const txid: TransactionSignature =
-			await this.provider.connection.sendRawTransaction(rawTransaction, opts);
-		this.sendToAdditionalConnections(rawTransaction, opts);
+		let txid: TransactionSignature;
+		try {
+			txid = await this.provider.connection.sendRawTransaction(
+				rawTransaction,
+				opts
+			);
+			this.sendToAdditionalConnections(rawTransaction, opts);
+		} catch (e) {
+			console.error(e);
+			throw e;
+		}
 
 		let done = false;
 		const resolveReference: ResolveReference = {

package/src/tx/types.ts

@@ -17,6 +17,7 @@ export interface TxSender {
 	send(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		preSigned?: boolean
 	): Promise<TxSigAndSlot>;
 }