@velocity-exchange/sdk 0.2.5 → 0.3.0

package/src/orderSubscriber/OrderSubscriber.ts

@@ -19,6 +19,16 @@ import { grpcSubscription } from './grpcSubscription';
 import { calculateOrderBaseAssetAmount } from '../math/orders';
 import { ZERO } from '../constants/numericConstants';
 
+/*
+ * Byte offset of `lastActiveSlot` (u64) in the `User` account, used here to
+ * cheaply detect stale updates without fully decoding the buffer. Must match
+ * the on-chain `User` layout (see `decode/user.ts`). The previous value (4328)
+ * was for the older 4376-byte layout; the current Velocity layout is 4496
+ * bytes, shifting this field +120 bytes. With the wrong offset this read 8
+ * zero-padding bytes, so the staleness guard rejected every post-load update.
+ */
+const USER_LAST_ACTIVE_SLOT_OFFSET = 4448;
+
 export class OrderSubscriber {
 	velocityClient: VelocityClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
@@ -176,7 +186,10 @@ export class OrderSubscriber {
 				const buffer = Buffer.from(data[0], data[1]);
 
 				const newLastActiveSlot = new BN(
-					buffer.subarray(4328, 4328 + 8),
+					buffer.subarray(
+						USER_LAST_ACTIVE_SLOT_OFFSET,
+						USER_LAST_ACTIVE_SLOT_OFFSET + 8
+					),
 					undefined,
 					'le'
 				);
@@ -191,7 +204,10 @@ export class OrderSubscriber {
 			} else if (dataType === 'buffer') {
 				const buffer: Buffer = data as Buffer;
 				const newLastActiveSlot = new BN(
-					buffer.subarray(4328, 4328 + 8),
+					buffer.subarray(
+						USER_LAST_ACTIVE_SLOT_OFFSET,
+						USER_LAST_ACTIVE_SLOT_OFFSET + 8
+					),
 					undefined,
 					'le'
 				);

package/src/swift/swiftOrderSubscriber.ts

@@ -161,8 +161,8 @@ export class SwiftOrderSubscriber {
 		const endpoint =
 			this.config.endpoint ??
 			(env === 'devnet'
-				? 'wss://master.swift.drift.trade/ws'
-				: 'wss://swift.drift.trade/ws');
+				? 'wss://swift.master.velocity.exchange/ws'
+				: 'wss://swift.velocity.exchange/ws');
 		const ws = new WebSocket(
 			endpoint + '?pubkey=' + this.config.keypair.publicKey.toBase58()
 		);

package/src/tokenFaucet.ts

@@ -1,5 +1,5 @@
-import * as anchor from './isomorphic/anchor29';
-import { AnchorProvider, Idl, Program } from './isomorphic/anchor29';
+import * as anchor from './isomorphic/anchor';
+import { AnchorProvider, Idl, Program } from './isomorphic/anchor';
 import {
 	TOKEN_PROGRAM_ID,
 	Account,
@@ -51,11 +51,14 @@ export class TokenFaucet {
 			this.opts
 		);
 		this.provider = provider;
-		this.program = new Program(
-			tokenFaucet as unknown as Idl,
-			programId,
-			provider
-		);
+		// Anchor (>= 0.30) reads the program id from `idl.address` rather than a
+		// constructor argument. Override it with the caller-provided `programId`
+		// so PDAs and instructions target the intended program.
+		const idl = {
+			...(tokenFaucet as unknown as Idl),
+			address: programId.toBase58(),
+		} as Idl;
+		this.program = new Program(idl, provider);
 		this.mint = mint;
 	}
 

package/src/types.ts

@@ -39,6 +39,13 @@ export enum ExchangeStatus {
 	PAUSED = 255,
 }
 
+// Mirror of the Rust `SolvencyStatus` bitflag (State.solvencyStatus). Gates
+// internal solvency-repair flows independently of ExchangeStatus.WITHDRAW_PAUSED.
+export enum SolvencyStatus {
+	ACTIVE = 0,
+	SOLVENCY_REPAIR_PAUSED = 1,
+}
+
 export enum FeatureBitFlags {
 	MM_ORACLE_UPDATE = 1,
 	MEDIAN_TRIGGER_PRICE = 2,
@@ -771,6 +778,7 @@ export type StateAccount = {
 	maxInitializeUserFee: number;
 	featureBitFlags: number;
 	lpPoolFeatureBitFlags: number;
+	solvencyStatus: number;
 };
 
 export type PerpMarketAccount = {

package/src/velocityClient.ts

@@ -2304,7 +2304,7 @@ export class VelocityClient {
 		subAccountId = subAccountId ?? this.activeSubAccountId;
 		authority = authority ?? this.authority;
 		if (subAccountId === undefined || authority === undefined) {
-			throw new Error('Subaccount ID and authority are required');
+			return false;
 		}
 		const userMapKey = this.getUserMapKey(subAccountId, authority);
 
@@ -10329,7 +10329,11 @@ export class VelocityClient {
 		);
 
 		const tx = await this.buildTransaction(updateMmOracleIx, {
-			computeUnits: 1000,
+			// Headroom for the native handler's owner + discriminator validation
+			// of the state + perp-market accounts (was 1000 when it bytemuck-cast
+			// the market without any checks). Measured ~1.3k CU; 2000 leaves
+			// margin for the production-only signer check.
+			computeUnits: 2000,
 			computeUnitsPrice: 0,
 		});
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
@@ -10337,16 +10341,19 @@ export class VelocityClient {
 		return txSig;
 	}
 
-	public getUpdateAmmSpreadAdjustmentNativeIx(
+	public async getUpdateAmmSpreadAdjustmentNativeIx(
 		marketIndex: number,
 		ammSpreadAdjustment: number // i8
-	): TransactionInstruction {
+	): Promise<TransactionInstruction> {
 		const discriminatorBuffer = createNativeInstructionDiscriminatorBuffer(1);
 		const data = Buffer.alloc(discriminatorBuffer.length + 4);
 		data.set(discriminatorBuffer, 0);
 		data.writeInt8(ammSpreadAdjustment, 5); // next byte
 
-		// Build the instruction manually
+		// Build the instruction manually. The native handler re-establishes the
+		// account guarantees Anchor would normally provide: it loads `state` as
+		// the program-owned State account and authenticates the signer against
+		// `state.hotAmmSpreadAdjust`, so the state account is required at index 2.
 		return new TransactionInstruction({
 			programId: this.program.programId,
 			keys: [
@@ -10360,6 +10367,11 @@ export class VelocityClient {
 					isWritable: false,
 					isSigner: true,
 				},
+				{
+					pubkey: await this.getStatePublicKey(),
+					isWritable: false,
+					isSigner: false,
+				},
 			],
 			data,
 		});

package/tests/dlob/helpers.ts

@@ -560,6 +560,7 @@ export const mockStateAccount: StateAccount = {
 	protocolFeeRecipientSpot: PublicKey.default,
 	featureBitFlags: 0,
 	lpPoolFeatureBitFlags: 0,
+	solvencyStatus: 0,
 	defaultMarketOrderTimeInForce: 0,
 	defaultSpotAuctionDuration: 0,
 	discountMint: PublicKey.default,