@velocity-exchange/sdk 0.0.5 → 0.2.0

package/lib/browser/util/TransactionConfirmationManager.js

@@ -156,10 +156,12 @@ class TransactionConfirmationManager {
             }
             if (status.err) {
                 this.pendingConfirmations.delete(request.txSig);
-                request.reject(await (0, reportTransactionError_1.getTransactionErrorFromTxSig)(request.txSig, this.connection));
+                const txError = await (0, reportTransactionError_1.getTransactionErrorFromTxSig)(request.txSig, this.connection);
+                request.reject(txError !== null && txError !== void 0 ? txError : new Error(`Transaction failed but no error could be resolved for signature ${request.txSig}`));
                 continue;
             }
-            if (confirmationStatusValues[status.confirmationStatus] === undefined ||
+            if (status.confirmationStatus === undefined ||
+                confirmationStatusValues[status.confirmationStatus] === undefined ||
                 confirmationStatusValues[request.desiredConfirmationStatus] ===
                     undefined) {
                 throw new Error(`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`);

package/lib/browser/util/chainClock.d.ts

@@ -13,5 +13,5 @@ export declare class ChainClock {
     private _state;
     constructor(props: ChainClickInitialisationProps);
     update(props: ChainClockUpdateProps): void;
-    getState(commitment: Commitment): ChainClockProgress;
+    getState(commitment: Commitment): ChainClockProgress | undefined;
 }

package/lib/browser/util/computeUnits.d.ts

@@ -1,5 +1,5 @@
 import { Connection, Finality, PublicKey, TransactionInstruction } from '@solana/web3.js';
-export declare function findComputeUnitConsumption(programId: PublicKey, connection: Connection, txSignature: string, commitment?: Finality): Promise<number[]>;
+export declare function findComputeUnitConsumption(programId: PublicKey, connection: Connection, txSignature: string, commitment?: Finality): Promise<string[]>;
 export declare function isSetComputeUnitsIx(ix: TransactionInstruction): boolean;
 export declare function isSetComputeUnitPriceIx(ix: TransactionInstruction): boolean;
 export declare function containsComputeUnitIxs(ixs: TransactionInstruction[]): {

package/lib/browser/util/computeUnits.js

@@ -3,10 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.containsComputeUnitIxs = exports.isSetComputeUnitPriceIx = exports.isSetComputeUnitsIx = exports.findComputeUnitConsumption = void 0;
 const web3_js_1 = require("@solana/web3.js");
 async function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    var _a;
     const tx = await connection.getTransaction(txSignature, { commitment });
     const computeUnits = [];
+    const logMessages = (_a = tx === null || tx === void 0 ? void 0 : tx.meta) === null || _a === void 0 ? void 0 : _a.logMessages;
+    if (!logMessages) {
+        return computeUnits;
+    }
     const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
-    tx.meta.logMessages.forEach((logMessage) => {
+    logMessages.forEach((logMessage) => {
         const match = logMessage.match(regex);
         if (match && match[1]) {
             computeUnits.push(match[1]);

package/lib/browser/util/ed25519Utils.d.ts

@@ -1,7 +1,7 @@
 import { TransactionInstruction } from '@solana/web3.js';
 /**
  * Constructs a minimal Ed25519 verification instruction that references the data
- * inside the drift custom instruction (e.g. postPythLazerOracleUpdate, placeSignedMsgTakerOrder).
+ * inside the velocity custom instruction (e.g. postPythLazerOracleUpdate, placeSignedMsgTakerOrder).
  *
  * @param customInstructionIndex The index of the custom instruction in the transaction (e.g. if tx contains compute budget limit, compute budget price, ed25519 verify, custom ix, this would be 3).
  * @param messageOffset The offset within the custom instruction data where the signed message begins.

package/lib/browser/util/ed25519Utils.js

@@ -47,7 +47,7 @@ const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct([
 ]);
 /**
  * Constructs a minimal Ed25519 verification instruction that references the data
- * inside the drift custom instruction (e.g. postPythLazerOracleUpdate, placeSignedMsgTakerOrder).
+ * inside the velocity custom instruction (e.g. postPythLazerOracleUpdate, placeSignedMsgTakerOrder).
  *
  * @param customInstructionIndex The index of the custom instruction in the transaction (e.g. if tx contains compute budget limit, compute budget price, ed25519 verify, custom ix, this would be 3).
  * @param messageOffset The offset within the custom instruction data where the signed message begins.

package/lib/browser/velocityClient.d.ts

@@ -18,7 +18,7 @@
  */
 import { AnchorProvider, BN } from './isomorphic/anchor';
 import type { ProgramAccount } from '@coral-xyz/anchor';
-import { VelocityClientMetricsEvents, IWallet, MakerInfo, MappedRecord, MarketType, ModifyOrderPolicy, OptionalOrderParams, OracleSource, Order, OrderParams, OrderTriggerCondition, PerpMarketAccount, PerpMarketExtendedInfo, PlaceAndTakeOrderSuccessCondition, PositionDirection, ReferrerInfo, ReferrerNameAccount, ScaleOrderParams, SettlePnlMode, SignedTxData, SpotMarketAccount, SpotPosition, StateAccount, SwapReduceOnly, SignedMsgOrderParamsMessage, TxParams, UserAccount, UserStatsAccount, SignedMsgOrderParamsDelegateMessage, PostOnlyParams, LPPoolAccount, ConstituentAccount, ConstituentTargetBaseAccount, AmmCache } from './types';
+import { VelocityClientMetricsEvents, IWallet, MakerInfo, MappedRecord, MarketType, ModifyOrderPolicy, OptionalOrderParams, OracleSource, Order, OrderParams, OrderTriggerCondition, PerpMarketAccount, PerpMarketExtendedInfo, PlaceAndTakeOrderSuccessCondition, PositionDirection, ReferrerInfo, ReferrerNameAccount, RevenueShareEscrowAccount, ScaleOrderParams, SettlePnlMode, SignedTxData, SpotMarketAccount, SpotPosition, StateAccount, SwapReduceOnly, SignedMsgOrderParamsMessage, TxParams, UserAccount, UserStatsAccount, SignedMsgOrderParamsDelegateMessage, PostOnlyParams, LPPoolAccount, ConstituentAccount, ConstituentTargetBaseAccount, AmmCache } from './types';
 import { AccountMeta, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, ConfirmOptions, Connection, Keypair, PublicKey, Signer, Transaction, TransactionInstruction, TransactionSignature, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
@@ -57,11 +57,12 @@ export declare class VelocityClient {
     program: VelocityProgram;
     provider: AnchorProvider;
     env: VelocityEnv;
-    opts?: ConfirmOptions;
+    opts: ConfirmOptions;
     useHotWalletAdmin?: boolean;
     users: Map<string, User>;
     userStats?: UserStats;
-    activeSubAccountId: number;
+    userStatsAccountPublicKey?: PublicKey;
+    activeSubAccountId: number | undefined;
     userAccountSubscriptionConfig: UserSubscriptionConfig;
     userStatsAccountSubscriptionConfig: UserStatsSubscriptionConfig;
     accountSubscriber: VelocityClientAccountSubscriber;
@@ -74,12 +75,8 @@ export declare class VelocityClient {
     mustIncludePerpMarketIndexes: Set<number>;
     mustIncludeSpotMarketIndexes: Set<number>;
     authority: PublicKey;
-    /** @deprecated use marketLookupTables */
-    marketLookupTable: PublicKey;
-    /** @deprecated use lookupTableAccounts */
-    lookupTableAccount: AddressLookupTableAccount;
     marketLookupTables: PublicKey[];
-    lookupTableAccounts: AddressLookupTableAccount[];
+    lookupTableAccounts?: AddressLookupTableAccount[];
     includeDelegates?: boolean;
     authoritySubAccountMap?: Map<string, number[]>;
     skipLoadUsers?: boolean;
@@ -111,6 +108,11 @@ export declare class VelocityClient {
      */
     forceGetStateAccount(): Promise<StateAccount>;
     getPerpMarketAccount(marketIndex: number): PerpMarketAccount | undefined;
+    /**
+     * Like {@link getPerpMarketAccount} but throws if the market is not loaded,
+     * for call sites that require a guaranteed account.
+     */
+    getPerpMarketAccountOrThrow(marketIndex: number): PerpMarketAccount;
     /**
      * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
      * @param marketIndex
@@ -118,6 +120,11 @@ export declare class VelocityClient {
     forceGetPerpMarketAccount(marketIndex: number): Promise<PerpMarketAccount | undefined>;
     getPerpMarketAccounts(): PerpMarketAccount[];
     getSpotMarketAccount(marketIndex: number): SpotMarketAccount | undefined;
+    /**
+     * Like {@link getSpotMarketAccount} but throws if the market is not loaded,
+     * for call sites that require a guaranteed account.
+     */
+    getSpotMarketAccountOrThrow(marketIndex: number): SpotMarketAccount;
     /**
      * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
      * @param marketIndex
@@ -126,12 +133,10 @@ export declare class VelocityClient {
     getSpotMarketAccounts(): SpotMarketAccount[];
     getQuoteSpotMarketAccount(): SpotMarketAccount;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey, oracleSource: OracleSource): DataAndSlot<OraclePriceData> | undefined;
-    /** @deprecated use fetchAllLookupTableAccounts() */
-    fetchMarketLookupTableAccount(): Promise<AddressLookupTableAccount>;
     fetchAllLookupTableAccounts(): Promise<AddressLookupTableAccount[]>;
     private getTxVersionForNewWallet;
     /**
-     * Update the wallet to use for drift transactions and linked user account
+     * Update the wallet to use for velocity transactions and linked user account
      * @param newWallet
      * @param subAccountIds
      * @param activeSubAccountId
@@ -253,6 +258,8 @@ export declare class VelocityClient {
         authority?: PublicKey;
     }): Promise<TransactionInstruction>;
     updateUserDelegate(delegate: PublicKey, subAccountId?: number): Promise<TransactionSignature>;
+    getUpdateUserAllowDelegateTransferIx(allowDelegateTransfer: boolean): Promise<TransactionInstruction>;
+    updateUserAllowDelegateTransfer(allowDelegateTransfer: boolean): Promise<TransactionSignature>;
     updateUserAdvancedLp(updates: {
         advancedLp: boolean;
         subAccountId: number;
@@ -294,12 +301,22 @@ export declare class VelocityClient {
     getUser(subAccountId?: number, authority?: PublicKey): User;
     hasUser(subAccountId?: number, authority?: PublicKey): boolean;
     getUsers(): User[];
-    getUserStats(): UserStats;
+    getUserStats(): UserStats | undefined;
+    /**
+     * Like {@link getUserStats} but throws if there is no UserStats
+     * subscription, for call sites that require a guaranteed account.
+     */
+    getUserStatsOrThrow(): UserStats;
     fetchReferrerNameAccount(name: string): Promise<ReferrerNameAccount | undefined>;
-    userStatsAccountPublicKey: PublicKey;
     getUserStatsAccountPublicKey(): PublicKey;
     getUserAccountPublicKey(subAccountId?: number, authority?: PublicKey): Promise<PublicKey>;
     getUserAccount(subAccountId?: number, authority?: PublicKey): UserAccount | undefined;
+    /**
+     * Like {@link getUserAccount} but throws a named error instead of returning
+     * `undefined` when the account has not been loaded yet. Use at call sites
+     * that structurally require a loaded account.
+     */
+    getUserAccountOrThrow(subAccountId?: number, authority?: PublicKey): UserAccount;
     /**
      * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
      * @param subAccountId
@@ -332,7 +349,7 @@ export declare class VelocityClient {
      */
     convertToPricePrecision(amount: BN | number): BN;
     /**
-     * Each drift instruction must include perp and sport market accounts in the ix remaining accounts.
+     * Each velocity instruction must include perp and sport market accounts in the ix remaining accounts.
      * Use this function to force a subset of markets to be included in the remaining accounts for every ix
      *
      * @param perpMarketIndexes
@@ -342,6 +359,8 @@ export declare class VelocityClient {
         perpMarketIndexes: number[];
         spotMarketIndexes: number[];
     }): void;
+    private cachePerpMarketSlot;
+    private cacheSpotMarketSlot;
     getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
     addPerpMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>, perpMarketAccountMap: Map<number, AccountMeta>): void;
     addSpotMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>): void;
@@ -351,7 +370,29 @@ export declare class VelocityClient {
         spotMarketAccountMap: Map<number, AccountMeta>;
         perpMarketAccountMap: Map<number, AccountMeta>;
     };
-    getOrder(orderId: number, subAccountId?: number): Order | undefined;
+    /**
+     * Look up an open order by its program-assigned order ID from the cached user account.
+     *
+     * `orderId` is the monotonically incrementing u32 counter that the program assigns at
+     * placement time — it is not known until the place instruction executes on-chain. Use
+     * {@link getOrderByUserId} when you need to look up an order by the caller-supplied
+     * `userOrderId` instead.
+     *
+     * Returns `undefined` when the order is not found (already filled, cancelled, or the
+     * account cache is stale).
+     */
+    getOrder(orderId: number | undefined, subAccountId?: number): Order | undefined;
+    /**
+     * Look up an open order by the caller-supplied `userOrderId` from the cached user account.
+     *
+     * `userOrderId` is a 1-255 slot chosen by the caller in {@link OrderParams} and is stable
+     * across the life of the order — useful when you need to reference an order before the
+     * program-assigned {@link Order.orderId} is known (e.g. immediately after placing without
+     * waiting for confirmation). Use {@link getOrder} when you have the program-assigned ID.
+     *
+     * Returns `undefined` when the order is not found (already filled, cancelled, or the
+     * account cache is stale).
+     */
     getOrderByUserId(userOrderId: number, subAccountId?: number): Order | undefined;
     /**
      * Get the associated token address for the given spot market
@@ -462,6 +503,8 @@ export declare class VelocityClient {
      */
     transferDeposit(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number, txParams?: TxParams): Promise<TransactionSignature>;
     getTransferDepositIx(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number): Promise<TransactionInstruction>;
+    transferDepositByDelegate(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getTransferDepositByDelegateIx(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number): Promise<TransactionInstruction>;
     transferPools(depositFromMarketIndex: number, depositToMarketIndex: number, borrowFromMarketIndex: number, borrowToMarketIndex: number, depositAmount: BN | undefined, borrowAmount: BN | undefined, fromSubAccountId: number, toSubAccountId: number, txParams?: TxParams): Promise<TransactionSignature>;
     getTransferPoolsIx(depositFromMarketIndex: number, depositToMarketIndex: number, borrowFromMarketIndex: number, borrowToMarketIndex: number, depositAmount: BN | undefined, borrowAmount: BN | undefined, fromSubAccountId: number, toSubAccountId: number, isToNewSubAccount?: boolean): Promise<TransactionInstruction>;
     transferPerpPosition(fromSubAccountId: number, toSubAccountId: number, marketIndex: number, amount: BN, txParams?: TxParams): Promise<TransactionSignature>;
@@ -482,7 +525,7 @@ export declare class VelocityClient {
      */
     openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN, subAccountId?: number): Promise<TransactionSignature>;
     sendSignedTx(tx: Transaction | VersionedTransaction, opts?: ConfirmOptions): Promise<TransactionSignature>;
-    prepareMarketOrderTxs(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean, positionMaxLev?: number, isolatedPositionDepositAmount?: BN): Promise<{
+    prepareMarketOrderTxs(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], cancelExistingOrders?: boolean, settlePnl?: boolean, positionMaxLev?: number, isolatedPositionDepositAmount?: BN): Promise<{
         cancelExistingOrdersTx?: Transaction | VersionedTransaction;
         settlePnlTx?: Transaction | VersionedTransaction;
         fillTx?: Transaction | VersionedTransaction;
@@ -499,13 +542,31 @@ export declare class VelocityClient {
      * @param cancelExistingOrders - Builds and returns an extra transaciton to cancel the existing orders in the same perp market. Intended use is to auto-cancel TP/SL orders when closing a position. Ignored if orderParams.marketType is not MarketType.PERP
      * @returns
      */
-    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
+    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
         txSig: TransactionSignature;
         signedFillTx?: Transaction;
         signedCancelExistingOrdersTx?: Transaction;
         signedSettlePnlTx?: Transaction;
     }>;
     placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number, isolatedPositionDepositAmount?: BN): Promise<TransactionSignature>;
+    /**
+     * Returns the RevenueShareEscrow account meta for the placing user when `orderParams`
+     * carries a builder code (`builderIdx` + `builderFeeTenthBps`), otherwise `undefined`.
+     * The on-chain handlers peek for this account last in `remaining_accounts`, so callers
+     * must push it after the market/oracle/maker accounts.
+     */
+    private getBuilderEscrowAccountMeta;
+    /**
+     * Returns the AccountMeta for the taker's RevenueShareEscrow when a fill of the
+     * taker's order must include it: the order carries a builder code, or the taker
+     * is referred (their escrow was initialized with a referrer). Returns `undefined`
+     * when neither applies so no account meta is added to the transaction. The
+     * on-chain handlers peek for this account last in `remaining_accounts`, so
+     * callers must push it after the market/oracle/maker accounts.
+     *
+     * Throws when `takerEscrow` does not belong to `takerAuthority`.
+     */
+    private getTakerEscrowAccountMeta;
     getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number, depositToTradeArgs?: {
         isMakingNewAccount: boolean;
         depositMarketIndex: number;
@@ -516,9 +577,38 @@ export declare class VelocityClient {
     getSettleExpiredMarketIx(marketIndex: number): Promise<TransactionInstruction>;
     settleExpiredMarketPoolsToRevenuePool(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getSettleExpiredMarketPoolsToRevenuePoolIx(perpMarketIndex: number): Promise<TransactionInstruction>;
+    /**
+     * Cancel an open order and broadcast the transaction.
+     *
+     * When `orderId` is `undefined` (omitted or passed explicitly), the instruction is
+     * sent with a `null` order ID and the program cancels the most recently placed order
+     * on-chain via `get_last_order_id`. This is safe to use in a composed transaction
+     * where a place instruction runs first and the assigned order ID is not yet known.
+     *
+     * Note: when `orderId` is `undefined` and `overrides.withdrawIsolatedDepositAmount`
+     * is also provided, `getOrder` will return `undefined` (the ID is unknown client-side),
+     * causing the withdraw path to throw — supply an explicit `orderId` in that case.
+     *
+     * @see {@link getCancelOrderIx} to obtain the instruction without sending.
+     */
     cancelOrder(orderId?: number, txParams?: TxParams, subAccountId?: number, overrides?: {
         withdrawIsolatedDepositAmount?: BN;
     }): Promise<TransactionSignature>;
+    /**
+     * Build a `cancelOrder` instruction for the given order.
+     *
+     * When `orderId` is `undefined` (omitted or passed explicitly), the instruction is
+     * built with a `null` order ID (`orderId ?? null`). The program interprets a `null`
+     * ID as "cancel the user's most recently placed order" (via `get_last_order_id`
+     * on-chain). This is useful when composing a multi-instruction transaction where a
+     * place instruction precedes the cancel and the program-assigned order ID is not yet
+     * known at build time.
+     *
+     * When `orderId` is supplied, only that specific order is cancelled.
+     *
+     * @see {@link cancelOrder} to send the transaction directly.
+     * @see {@link getCancelOrderByUserIdIx} to cancel by the caller-supplied `userOrderId`.
+     */
     getCancelOrderIx(orderId?: number, subAccountId?: number): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number, subAccountId?: number): Promise<TransactionInstruction>;
@@ -546,7 +636,7 @@ export declare class VelocityClient {
         authority?: PublicKey;
     }): Promise<TransactionInstruction>;
     cancelOrders(marketType?: MarketType, marketIndex?: number, direction?: PositionDirection, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    getCancelOrdersIx(marketType: MarketType | null, marketIndex: number | null, direction: PositionDirection | null, subAccountId?: number): Promise<TransactionInstruction>;
+    getCancelOrdersIx(marketType: MarketType | null | undefined, marketIndex: number | null | undefined, direction: PositionDirection | null | undefined, subAccountId?: number): Promise<TransactionInstruction>;
     cancelAndPlaceOrders(cancelOrderParams: {
         marketType?: MarketType;
         marketIndex?: number;
@@ -572,18 +662,18 @@ export declare class VelocityClient {
         placeScaleOrdersTx: Transaction | VersionedTransaction;
     }>;
     getPlaceScaleOrdersIx(params: ScaleOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
-    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, fillerSubAccountId?: number, fillerAuthority?: PublicKey, hasBuilderFee?: boolean): Promise<TransactionSignature>;
-    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerSubAccountId?: number, isSignedMsg?: boolean, fillerAuthority?: PublicKey, hasBuilderFee?: boolean): Promise<TransactionInstruction>;
+    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, fillerSubAccountId?: number, fillerAuthority?: PublicKey, hasBuilderFee?: boolean, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionSignature>;
+    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], fillerSubAccountId?: number, isSignedMsg?: boolean, fillerAuthority?: PublicKey, hasBuilderFee?: boolean, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionInstruction>;
     getRevertFillIx(fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeSpotOrder(_orderParams: OptionalOrderParams, _txParams?: TxParams, _subAccountId?: number): Promise<TransactionSignature>;
     preparePlaceSpotOrderTx(_orderParams: OptionalOrderParams, _txParams?: TxParams, _subAccountId?: number): Promise<void>;
     getPlaceSpotOrderIx(_orderParams: OptionalOrderParams, _subAccountId?: number, _overrides?: {
         authority?: PublicKey;
     }): Promise<TransactionInstruction>;
-    fillSpotOrder(_userAccountPublicKey: PublicKey, _user: UserAccount, _order?: Pick<Order, 'marketIndex' | 'orderId'>, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo | MakerInfo[], _referrerInfo?: ReferrerInfo, _txParams?: TxParams): Promise<TransactionSignature>;
-    getFillSpotOrderIx(_userAccountPublicKey: PublicKey, _userAccount: UserAccount, _order?: Pick<Order, 'marketIndex' | 'orderId'>, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo | MakerInfo[], _referrerInfo?: ReferrerInfo, _fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    fillSpotOrder(_userAccountPublicKey: PublicKey, _user: UserAccount, _order?: Pick<Order, 'marketIndex' | 'orderId'>, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo | MakerInfo[], _txParams?: TxParams): Promise<TransactionSignature>;
+    getFillSpotOrderIx(_userAccountPublicKey: PublicKey, _userAccount: UserAccount, _order?: Pick<Order, 'marketIndex' | 'orderId'>, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo | MakerInfo[], _fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     /**
-     * Swap tokens in drift account using titan or jupiter
+     * Swap tokens in velocity account using titan or jupiter
      * @param swapClient swap client to find routes and instructions (Titan or Jupiter)
      * @param jupiterClient @deprecated Use swapClient instead. Legacy parameter for backward compatibility
      * @param outMarketIndex the market index of the token you're buying
@@ -594,7 +684,7 @@ export declare class VelocityClient {
      * @param slippageBps the max slippage passed to the swap provider api
      * @param swapMode swap provider swapMode (ExactIn or ExactOut), default is ExactIn
      * @param route the swap provider route to use for the swap
-     * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
+     * @param reduceOnly specify if In or Out token on the velocity account must reduceOnly, checked at end of swap
      * @param v6 pass in the quote response from swap provider quote's API (deprecated, use quote instead)
      * @param quote pass in the quote response from swap provider quote's API
      * @param txParams
@@ -652,7 +742,7 @@ export declare class VelocityClient {
         lookupTables: AddressLookupTableAccount[];
     }>;
     /**
-     * Get the drift begin_swap and end_swap instructions
+     * Get the velocity begin_swap and end_swap instructions
      *
      * @param outMarketIndex the market index of the token you're buying
      * @param inMarketIndex the market index of the token you're selling
@@ -715,27 +805,27 @@ export declare class VelocityClient {
     getUpdateUserStatsReferrerStatusIx(userAuthority: PublicKey): Promise<TransactionInstruction>;
     updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
     getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
-    placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean, auctionDurationPercentage?: number, optionalIxs?: TransactionInstruction[], isolatedPositionDepositAmount?: BN): Promise<{
-        placeAndTakeTx: Transaction | VersionedTransaction;
-        cancelExistingOrdersTx: Transaction | VersionedTransaction;
-        settlePnlTx: Transaction | VersionedTransaction;
-    }>;
-    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean): Promise<{
+    placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, txParams?: TxParams, subAccountId?: number, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionSignature>;
+    preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean, auctionDurationPercentage?: number, optionalIxs?: TransactionInstruction[], isolatedPositionDepositAmount?: BN): Promise<{
+        placeAndTakeTx: Transaction | VersionedTransaction | undefined;
+        cancelExistingOrdersTx: Transaction | VersionedTransaction | undefined;
+        settlePnlTx: Transaction | VersionedTransaction | undefined;
+    } | null>;
+    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean): Promise<{
         txSig: TransactionSignature;
         signedCancelExistingOrdersTx?: Transaction;
         signedSettlePnlTx?: Transaction;
-    }>;
-    getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, subAccountId?: number, overrides?: {
+    } | null>;
+    getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, subAccountId?: number, overrides?: {
         authority?: PublicKey;
-    }): Promise<TransactionInstruction>;
-    placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
+    }, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionInstruction>;
+    placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, txParams?: TxParams, subAccountId?: number, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionSignature>;
+    getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, subAccountId?: number, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionInstruction>;
     signSignedMsgOrderParamsMessage(orderParamsMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage, delegateSigner?: boolean): SignedMsgOrderParams;
     /**
      * Builds a deposit and place request for Swift service
      *
-     * @param depositTx - The signed tx containing a drift deposit (e.g. see `buildSwiftDepositTx`)
+     * @param depositTx - The signed tx containing a velocity deposit (e.g. see `buildSwiftDepositTx`)
      * @param orderParamsMessage - The order parameters message to sign
      * @param delegateSigner - Whether this is a delegate signer
      *
@@ -747,7 +837,7 @@ export declare class VelocityClient {
     };
     encodeSignedMsgOrderParamsMessage(orderParamsMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage, delegateSigner?: boolean): Buffer;
     decodeSignedMsgOrderParamsMessage(encodedMessage: Buffer, delegateSigner?: boolean): SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage;
-    signMessage(message: Uint8Array, keypair?: Keypair): Buffer;
+    signMessage(message: Uint8Array, keypair?: Keypair | undefined): Buffer;
     placeSignedMsgTakerOrder(signedSignedMsgOrderParams: SignedMsgOrderParams, marketIndex: number, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
@@ -765,18 +855,18 @@ export declare class VelocityClient {
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
         signingAuthority: PublicKey;
-    }, orderParams: OptionalOrderParams, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number, precedingIxs?: TransactionInstruction[], overrideCustomIxIndex?: number): Promise<TransactionSignature>;
+    }, orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number, precedingIxs?: TransactionInstruction[], overrideCustomIxIndex?: number, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionSignature>;
     getPlaceAndMakeSignedMsgPerpOrderIxs(signedSignedMsgOrderParams: SignedMsgOrderParams, signedMsgOrderUuid: Uint8Array, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
         signingAuthority: PublicKey;
-    }, orderParams: OptionalOrderParams, referrerInfo?: ReferrerInfo, subAccountId?: number, precedingIxs?: TransactionInstruction[], overrideCustomIxIndex?: number): Promise<TransactionInstruction[]>;
-    preparePlaceAndTakeSpotOrder(_orderParams: OptionalOrderParams, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo, _referrerInfo?: ReferrerInfo, _txParams?: TxParams, _subAccountId?: number): Promise<void>;
-    placeAndTakeSpotOrder(_orderParams: OptionalOrderParams, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo, _referrerInfo?: ReferrerInfo, _txParams?: TxParams, _subAccountId?: number): Promise<TransactionSignature>;
-    getPlaceAndTakeSpotOrderIx(_orderParams: OptionalOrderParams, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo, _referrerInfo?: ReferrerInfo, _subAccountId?: number): Promise<TransactionInstruction>;
-    placeAndMakeSpotOrder(_orderParams: OptionalOrderParams, _takerInfo: TakerInfo, _fulfillmentConfig?: unknown, _referrerInfo?: ReferrerInfo, _txParams?: TxParams, _subAccountId?: number): Promise<TransactionSignature>;
-    getPlaceAndMakeSpotOrderIx(_orderParams: OptionalOrderParams, _takerInfo: TakerInfo, _fulfillmentConfig?: unknown, _referrerInfo?: ReferrerInfo, _subAccountId?: number): Promise<TransactionInstruction>;
+    }, orderParams: OptionalOrderParams, subAccountId?: number, precedingIxs?: TransactionInstruction[], overrideCustomIxIndex?: number, takerEscrow?: RevenueShareEscrowAccount): Promise<TransactionInstruction[]>;
+    preparePlaceAndTakeSpotOrder(_orderParams: OptionalOrderParams, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo, _txParams?: TxParams, _subAccountId?: number): Promise<void>;
+    placeAndTakeSpotOrder(_orderParams: OptionalOrderParams, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo, _txParams?: TxParams, _subAccountId?: number): Promise<TransactionSignature>;
+    getPlaceAndTakeSpotOrderIx(_orderParams: OptionalOrderParams, _fulfillmentConfig?: unknown, _makerInfo?: MakerInfo, _subAccountId?: number): Promise<TransactionInstruction>;
+    placeAndMakeSpotOrder(_orderParams: OptionalOrderParams, _takerInfo: TakerInfo, _fulfillmentConfig?: unknown, _txParams?: TxParams, _subAccountId?: number): Promise<TransactionSignature>;
+    getPlaceAndMakeSpotOrderIx(_orderParams: OptionalOrderParams, _takerInfo: TakerInfo, _fulfillmentConfig?: unknown, _subAccountId?: number): Promise<TransactionInstruction>;
     /**
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
@@ -939,7 +1029,7 @@ export declare class VelocityClient {
     getLiquidatePerpWithFillIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, makerInfos: MakerInfo[], liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
     liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
     getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
-    getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, userStatsAccountPublicKey, liquidatorSubAccountId, maxAccounts, }: {
+    getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, liquidatorSubAccountId, maxAccounts, }: {
         jupiterClient: JupiterClient;
         liabilityMarketIndex: number;
         assetMarketIndex: number;
@@ -952,7 +1042,6 @@ export declare class VelocityClient {
         quote?: QuoteResponse;
         userAccount: UserAccount;
         userAccountPublicKey: PublicKey;
-        userStatsAccountPublicKey: PublicKey;
         liquidatorSubAccountId?: number;
         maxAccounts?: number;
     }): Promise<{
@@ -960,7 +1049,7 @@ export declare class VelocityClient {
         lookupTables: AddressLookupTableAccount[];
     }>;
     /**
-     * Get the drift liquidate_spot_with_swap instructions
+     * Get the velocity liquidate_spot_with_swap instructions
      *
      * @param liabilityMarketIndex the market index of the token you're buying
      * @param assetMarketIndex the market index of the token you're selling
@@ -969,9 +1058,8 @@ export declare class VelocityClient {
      * @param liabilityTokenAccount the token account to receive the tokens being bought
      * @param userAccount
      * @param userAccountPublicKey
-     * @param userStatsAccountPublicKey
      */
-    getLiquidateSpotWithSwapIx({ liabilityMarketIndex, assetMarketIndex, swapAmount: swapAmount, assetTokenAccount, liabilityTokenAccount, userAccount, userAccountPublicKey, userStatsAccountPublicKey, liquidatorSubAccountId, }: {
+    getLiquidateSpotWithSwapIx({ liabilityMarketIndex, assetMarketIndex, swapAmount: swapAmount, assetTokenAccount, liabilityTokenAccount, userAccount, userAccountPublicKey, liquidatorSubAccountId, }: {
         liabilityMarketIndex: number;
         assetMarketIndex: number;
         swapAmount: BN;
@@ -979,22 +1067,11 @@ export declare class VelocityClient {
         liabilityTokenAccount: PublicKey;
         userAccount: UserAccount;
         userAccountPublicKey: PublicKey;
-        userStatsAccountPublicKey: PublicKey;
         liquidatorSubAccountId?: number;
     }): Promise<{
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
     }>;
-    getInsuranceFundSwapIx({ inMarketIndex, outMarketIndex, amountIn, inTokenAccount, outTokenAccount, }: {
-        inMarketIndex: number;
-        outMarketIndex: number;
-        amountIn: BN;
-        inTokenAccount: PublicKey;
-        outTokenAccount: PublicKey;
-    }): Promise<{
-        beginSwapIx: TransactionInstruction;
-        endSwapIx: TransactionInstruction;
-    }>;
     liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
     getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
     liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
@@ -1068,15 +1145,15 @@ export declare class VelocityClient {
     removeInsuranceFundStake(marketIndex: number, collateralAccountPublicKey: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     updateUserQuoteAssetInsuranceStake(authority: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     getUpdateUserQuoteAssetInsuranceStakeIx(authority: PublicKey): Promise<TransactionInstruction>;
-    updateUserGovTokenInsuranceStake(authority: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
-    getUpdateUserGovTokenInsuranceStakeIx(authority: PublicKey): Promise<TransactionInstruction>;
     settleRevenueToInsuranceFund(spotMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getSettleRevenueToInsuranceFundIx(spotMarketIndex: number): Promise<TransactionInstruction>;
+    sweepPerpMarketFees(perpMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getSweepPerpMarketFeesIx(perpMarketIndex: number): Promise<TransactionInstruction>;
     resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
     getDepositIntoSpotMarketRevenuePoolIx(marketIndex: number, amount: BN, userTokenAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
     /**
-     * This ix will donate your funds to drift revenue pool. It does not deposit into your user account
+     * This ix will donate your funds to velocity revenue pool. It does not deposit into your user account
      * @param marketIndex
      * @param amount
      * @param userTokenAccountPublicKey
@@ -1212,7 +1289,7 @@ export declare class VelocityClient {
      */
     sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean, recentBlockhash?: BlockhashWithExpiryBlockHeight, optionalIxs?: TransactionInstruction[]): Promise<Transaction | VersionedTransaction>;
-    buildBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<(Transaction | VersionedTransaction)[]>;
+    buildBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<(Transaction | VersionedTransaction | undefined)[]>;
     buildTransactionsMap(instructionsMap: Record<string, TransactionInstruction | TransactionInstruction[]>, txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<MappedRecord<Record<string, TransactionInstruction | TransactionInstruction[]>, Transaction | VersionedTransaction>>;
     buildAndSignTransactionsMap(instructionsMap: Record<string, TransactionInstruction | TransactionInstruction[]>, txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<{
         signedTxMap: Record<string, Transaction>;
@@ -1221,10 +1298,6 @@ export declare class VelocityClient {
         signedTxMap: MappedRecord<Record<string, TransactionInstruction | TransactionInstruction[]>, Transaction | VersionedTransaction>;
         signedTxData: SignedTxData[];
     }>;
-    isOrderIncreasingPosition(orderParams: OptionalOrderParams, subAccountId: number): boolean;
+    isOrderIncreasingPosition(orderParams: OptionalOrderParams, subAccountId?: number): boolean;
 }
-/** @deprecated Use `VelocityClient` instead. `DriftClient` will be removed in a future major. */
-export declare const DriftClient: typeof VelocityClient;
-/** @deprecated Use `VelocityClient` instead. `DriftClient` will be removed in a future major. */
-export type DriftClient = VelocityClient;
 export {};