@velocity-exchange/sdk 0.4.0 → 0.6.0

package/lib/browser/pyth/pythLazerSubscriber.js

@@ -127,6 +127,36 @@ class PythLazerSubscriber {
         });
         // Reset allSubscribedIds to rebuild with only stable feeds
         this.allSubscribedIds = [];
+        // addMessageListener is global to the client (fires for every message,
+        // not scoped to a subscription), and each message carries its own
+        // subscriptionId — so one listener serves all subscriptions. Registering
+        // it per chunk would run every message once per chunk.
+        this.pythLazerClient.addMessageListener((message) => {
+            var _a, _b;
+            this.receivingData = true;
+            clearTimeout(this.timeoutId);
+            switch (message.type) {
+                case 'json': {
+                    if (message.value.type == 'streamUpdated') {
+                        if ((_a = message.value.solana) === null || _a === void 0 ? void 0 : _a.data) {
+                            this.feedIdChunkToPriceMessage.set(this.subscriptionIdsToFeedIdsHash.get(message.value.subscriptionId), message.value.solana.data);
+                        }
+                        if ((_b = message.value.parsed) === null || _b === void 0 ? void 0 : _b.priceFeeds) {
+                            for (const priceFeed of message.value.parsed.priceFeeds) {
+                                const price = Number(priceFeed.price) *
+                                    Math.pow(10, Number(priceFeed.exponent));
+                                this.feedIdToPrice.set(priceFeed.priceFeedId, price);
+                            }
+                        }
+                    }
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+            this.setTimeout();
+        });
         let subscriptionId = 1;
         for (const priceFeedArray of this.priceFeedArrays) {
             const filteredFeedIds = this.filterStableFeeds(priceFeedArray.priceFeedIds);
@@ -153,33 +183,13 @@ class PythLazerSubscriber {
                     this.marketIndextoPriceFeedIdChunk.delete(marketIndex);
                 }
             }
-            this.pythLazerClient.addMessageListener((message) => {
-                var _a, _b;
-                this.receivingData = true;
-                clearTimeout(this.timeoutId);
-                switch (message.type) {
-                    case 'json': {
-                        if (message.value.type == 'streamUpdated') {
-                            if ((_a = message.value.solana) === null || _a === void 0 ? void 0 : _a.data) {
-                                this.feedIdChunkToPriceMessage.set(this.subscriptionIdsToFeedIdsHash.get(message.value.subscriptionId), message.value.solana.data);
-                            }
-                            if ((_b = message.value.parsed) === null || _b === void 0 ? void 0 : _b.priceFeeds) {
-                                for (const priceFeed of message.value.parsed.priceFeeds) {
-                                    const price = Number(priceFeed.price) *
-                                        Math.pow(10, Number(priceFeed.exponent));
-                                    this.feedIdToPrice.set(priceFeed.priceFeedId, price);
-                                }
-                            }
-                        }
-                        break;
-                    }
-                    default: {
-                        break;
-                    }
-                }
-                this.setTimeout();
-            });
-            this.pythLazerClient.send({
+            // Use subscribe() (not send()): subscribe() registers the request in
+            // the pool's subscriptions map so ResilientWebSocket replays it on
+            // every socket reconnect. send() fires once and is never replayed, so
+            // after the first heartbeat-timeout reconnect the socket streams
+            // nothing — forcing the watchdog to tear down the whole client and
+            // reopen numConnections fresh sockets. subscribe() recovers in place.
+            this.pythLazerClient.subscribe({
                 type: 'subscribe',
                 subscriptionId,
                 priceFeedIds: filteredFeedIds,

package/lib/browser/types.d.ts

@@ -1642,6 +1642,8 @@ export type UserStatsAccount = {
     authority: PublicKey;
     ifStakedQuoteAssetAmount: BN;
     delegatePermissions: number;
+    /** non-zero when the permissionless `tripEquityFloorBreaker` fired: every subaccount of the authority rejects risk-increasing fills, withdrawals and transfers out until the warm admin resets */
+    equityBreakerTripped: number;
 };
 /** Decoded mirror of the on-chain `User` (sub-account) zero-copy account. */
 export type UserAccount = {
@@ -1684,6 +1686,8 @@ export type UserAccount = {
     poolId: number;
     /** bitmask, see `SpecialUserStatus` */
     specialUserStatus: number;
+    /** QUOTE_PRECISION (1e6); admin-set minimum cross-margin total collateral for risk-increasing orders, fills, withdrawals and transfers; 0 = disabled */
+    equityFloor: BN;
 };
 /** A user's balance in one spot market. Decoded mirror of the on-chain `SpotPosition`. */
 export type SpotPosition = {

package/lib/browser/user.d.ts

@@ -410,6 +410,21 @@ export declare class User {
      * @returns Precision QUOTE_PRECISION (1e6).
      */
     getTotalCollateral(marginCategory?: MarginCategory, strict?: boolean, includeOpenOrders?: boolean, liquidationBuffer?: BN, perpMarketIndex?: number): BN;
+    /**
+     * True when the account has an admin-set `equityFloor` and its cross-margin
+     * total collateral is below it. While below the floor, the program rejects
+     * risk-increasing order placement and fills, withdrawals, and transfers out
+     * of the account (`EquityBelowFloor`); reduce-only activity stays allowed.
+     * Mirrors `User::is_below_equity_floor` on-chain.
+     * @param strict Use TWAP-bounded oracle pricing, matching the withdraw path. Defaults to false.
+     */
+    isBelowEquityFloor(strict?: boolean): boolean;
+    /**
+     * Cross-margin total collateral in excess of the admin-set `equityFloor`,
+     * floored at zero (QUOTE_PRECISION). Unbounded (`null`) when no floor is set.
+     * @param strict Use TWAP-bounded oracle pricing. Defaults to false.
+     */
+    getEquityAboveFloor(strict?: boolean): BN | null;
     /**
      * Builds the liquidation-buffer map to pass into margin calculations while
      * a liquidation is in progress: `'cross'` is set to the state account's

package/lib/browser/user.js

@@ -898,6 +898,33 @@ class User {
         }
         return marginCalc.totalCollateral;
     }
+    /**
+     * True when the account has an admin-set `equityFloor` and its cross-margin
+     * total collateral is below it. While below the floor, the program rejects
+     * risk-increasing order placement and fills, withdrawals, and transfers out
+     * of the account (`EquityBelowFloor`); reduce-only activity stays allowed.
+     * Mirrors `User::is_below_equity_floor` on-chain.
+     * @param strict Use TWAP-bounded oracle pricing, matching the withdraw path. Defaults to false.
+     */
+    isBelowEquityFloor(strict = false) {
+        const equityFloor = this.getUserAccountOrThrow().equityFloor;
+        if (equityFloor.lte(numericConstants_1.ZERO)) {
+            return false;
+        }
+        return this.getTotalCollateral('Initial', strict).lt(equityFloor);
+    }
+    /**
+     * Cross-margin total collateral in excess of the admin-set `equityFloor`,
+     * floored at zero (QUOTE_PRECISION). Unbounded (`null`) when no floor is set.
+     * @param strict Use TWAP-bounded oracle pricing. Defaults to false.
+     */
+    getEquityAboveFloor(strict = false) {
+        const equityFloor = this.getUserAccountOrThrow().equityFloor;
+        if (equityFloor.lte(numericConstants_1.ZERO)) {
+            return null;
+        }
+        return anchor_1.BN.max(this.getTotalCollateral('Initial', strict).sub(equityFloor), numericConstants_1.ZERO);
+    }
     /**
      * Builds the liquidation-buffer map to pass into margin calculations while
      * a liquidation is in progress: `'cross'` is set to the state account's
@@ -2353,7 +2380,16 @@ class User {
         const spotMarket = this.velocityClient.getSpotMarketAccountOrThrow(marketIndex);
         // eslint-disable-next-line prefer-const
         let { borrowLimit, withdrawLimit } = (0, spotBalance_2.calculateWithdrawLimit)(spotMarket, nowTs);
-        const freeCollateral = this.getFreeCollateral();
+        // the withdraw path enforces the equity floor on post-withdraw total
+        // collateral, so equity above the floor caps free collateral here
+        const equityAboveFloor = this.getEquityAboveFloor(true);
+        if (equityAboveFloor !== null && equityAboveFloor.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        let freeCollateral = this.getFreeCollateral();
+        if (equityAboveFloor !== null) {
+            freeCollateral = anchor_1.BN.min(freeCollateral, equityAboveFloor);
+        }
         const initialMarginRequirement = this.getInitialMarginRequirement();
         const oracleData = this.getOracleDataForSpotMarket(marketIndex);
         const { numeratorScale, denominatorScale } = spotMarket.decimals > 6

package/lib/browser/velocityClient.d.ts

@@ -1529,7 +1529,9 @@ export declare class VelocityClient {
      * @param subAccountId - Sub-account id to withdraw from; defaults to `this.activeSubAccountId`.
      * @returns The `withdraw` instruction.
      */
-    getWithdrawIx(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean, subAccountId?: number): Promise<TransactionInstruction>;
+    getWithdrawIx(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean, subAccountId?: number, overrides?: {
+        authority?: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Transfers a spot balance directly between two sub-accounts owned by `this.wallet.publicKey`
      * (withdraws from `fromSubAccountId`, deposits into `toSubAccountId`) without leaving the program —
@@ -1571,13 +1573,22 @@ export declare class VelocityClient {
      * @param marketIndex - Spot market index of the balance to transfer.
      * @param fromSubAccountId - Sub-account id to debit.
      * @param toSubAccountId - Sub-account id to credit.
+     * @param equityFloorDelta - Equity floor (QUOTE_PRECISION) to move from the debited to the credited
+     * sub-account along with the funds, keeping the sum of floors constant. The debited side must stay
+     * at/above its reduced floor and the credited side's collateral (after the transfer lands) must back
+     * its increased floor, else the transfer reverts with `InvalidEquityFloorTransfer`. Pass `'auto'`
+     * (quote market only) to move the minimal floor needed for the debited side to stay at/above its
+     * floor: `max(0, amount - (collateral - floor))`, capped at the debited side's floor. The auto delta
+     * never exceeds `amount`, so the credited side stays backed whenever it was before. Client-side
+     * pricing can differ slightly from the on-chain strict check at the exact boundary; retry with an
+     * explicit padded delta if an `'auto'` transfer reverts. Defaults to zero.
      * @param txParams - Optional compute-unit/priority-fee overrides for the transaction.
      * @returns The transaction signature.
      * @throws (on-chain) if `allowDelegateTransfer` is not enabled, if the signer is not the delegate on
      * both sub-accounts, if the sub-accounts have different owners, if either is bankrupt, or if
      * `fromSubAccountId === toSubAccountId`.
      */
-    transferDepositByDelegate(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number, txParams?: TxParams): Promise<TransactionSignature>;
+    transferDepositByDelegate(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number, equityFloorDelta?: BN | 'auto', txParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Builds the `transferDepositByDelegate` instruction. See `transferDepositByDelegate` for the full
      * set of on-chain preconditions. Uses an already-loaded `from` sub-account's cached data if
@@ -1589,7 +1600,7 @@ export declare class VelocityClient {
      * @param toSubAccountId - Sub-account id to credit.
      * @returns The instruction.
      */
-    getTransferDepositByDelegateIx(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number): Promise<TransactionInstruction>;
+    getTransferDepositByDelegateIx(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number, equityFloorDelta?: BN | 'auto'): Promise<TransactionInstruction>;
     /**
      * Moves a deposit balance and/or a borrow balance for the same underlying mint between two
      * sub-accounts owned by `this.wallet.publicKey` that sit in *different* isolated pools, in one
@@ -2519,6 +2530,26 @@ export declare class VelocityClient {
      * @returns The instruction.
      */
     getForceCancelOrdersIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    /**
+     * Keeper instruction: trips the authority-wide equity floor breaker. Proves on-chain that the
+     * given subaccount's cross-margin total collateral is below its `equityFloor` (reverts with
+     * `SufficientCollateral` otherwise, or if no floor is set) and sets `equityBreakerTripped` on the
+     * authority's `UserStats` — every subaccount of the authority then rejects risk-increasing fills,
+     * withdrawals and transfers out until the warm admin calls `resetEquityFloorBreaker`.
+     * Permissionless — any signer may trip it; the margin calculation is the proof.
+     * @param userAccountPublicKey - Public key of the breached subaccount's user account.
+     * @param user - Decoded user account of the breached subaccount.
+     * @param txParams - Optional compute-unit/priority-fee overrides.
+     * @returns The transaction signature.
+     */
+    tripEquityFloorBreaker(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
+    /**
+     * Builds the `tripEquityFloorBreaker` instruction. See `tripEquityFloorBreaker` for semantics.
+     * @param userAccountPublicKey - Public key of the breached subaccount's user account.
+     * @param userAccount - Decoded user account of the breached subaccount.
+     * @returns The instruction.
+     */
+    getTripEquityFloorBreakerIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
     /**
      * Keeper instruction: marks a user account idle after confirming (via `validate_user_is_idle`)
      * it has been inactive long enough — the inactivity window is shorter (accelerated) when the
@@ -3495,11 +3526,12 @@ export declare class VelocityClient {
     getUpdatePrelaunchOracleIx(perpMarketIndex: number): Promise<TransactionInstruction>;
     /**
      * Keeper instruction: estimates the market's bid/ask price from the given makers' resting DLOB
-     * orders (filtered to those within `BID_ASK_TWAP_MAX_ORACLE_DIVERGENCE_PERCENT` of the oracle
-     * price) and folds the estimate into `lastBidPriceTwap`/`lastAskPriceTwap`. Restricted: the
-     * calling wallet's `UserStats` must have `canUpdateBidAskTwap` set and at least 1000 USDC
-     * (`QUOTE_PRECISION`, 1e6) staked in the insurance fund (`ifStakedQuoteAssetAmount`), or the
-     * instruction reverts.
+     * orders (kept only within `±BID_ASK_TWAP_MAX_ORACLE_DIVERGENCE_PERCENT` of the oracle price on
+     * both sides) and folds the estimate into `lastBidPriceTwap`/`lastAskPriceTwap`. This does NOT
+     * update the funding rate, crank funding separately via `getUpdateFundingRateIx`. Restricted:
+     * the calling wallet's `UserStats` (which must be the signer's own) must have
+     * `canUpdateBidAskTwap` set and at least 1000 USDC (`QUOTE_PRECISION`, 1e6) staked in the
+     * insurance fund (`ifStakedQuoteAssetAmount`), or the instruction reverts.
      * @param perpMarketIndex - Perp market index to update.
      * @param makers - `(maker, makerStats)` pairs whose resting orders are sampled for the estimate.
      * @param txParams - Optional compute-unit/priority-fee overrides.
@@ -3596,7 +3628,9 @@ export declare class VelocityClient {
      * @param marketIndex - Spot market index whose insurance fund to stake into.
      * @returns The instruction.
      */
-    getInitializeInsuranceFundStakeIx(marketIndex: number): Promise<TransactionInstruction>;
+    getInitializeInsuranceFundStakeIx(marketIndex: number, overrides?: {
+        authority?: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Builds the `addInsuranceFundStake` instruction, transferring `amount` of the market's token
      * from `collateralAccountPublicKey` into its insurance fund vault and minting the caller's
@@ -3609,7 +3643,9 @@ export declare class VelocityClient {
      * @param collateralAccountPublicKey - Token account to debit for the stake.
      * @returns The instruction.
      */
-    getAddInsuranceFundStakeIx(marketIndex: number, amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    getAddInsuranceFundStakeIx(marketIndex: number, amount: BN, collateralAccountPublicKey: PublicKey, overrides?: {
+        authority?: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Add to an insurance fund stake and optionally initialize the account
      */

package/lib/browser/velocityClient.js

@@ -3042,7 +3042,8 @@ class VelocityClient {
      * @param subAccountId - Sub-account id to withdraw from; defaults to `this.activeSubAccountId`.
      * @returns The `withdraw` instruction.
      */
-    async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false, subAccountId) {
+    async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false, subAccountId, overrides) {
+        var _a;
         const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [this.getUserAccountOrThrow(subAccountId)],
@@ -3068,7 +3069,7 @@ class VelocityClient {
             user,
             userStats: this.getUserStatsAccountPublicKey(),
             userTokenAccount,
-            authority: this.wallet.publicKey,
+            authority: (_a = overrides === null || overrides === void 0 ? void 0 : overrides.authority) !== null && _a !== void 0 ? _a : this.wallet.publicKey,
             tokenProgram,
             remainingAccounts,
         });
@@ -3154,14 +3155,23 @@ class VelocityClient {
      * @param marketIndex - Spot market index of the balance to transfer.
      * @param fromSubAccountId - Sub-account id to debit.
      * @param toSubAccountId - Sub-account id to credit.
+     * @param equityFloorDelta - Equity floor (QUOTE_PRECISION) to move from the debited to the credited
+     * sub-account along with the funds, keeping the sum of floors constant. The debited side must stay
+     * at/above its reduced floor and the credited side's collateral (after the transfer lands) must back
+     * its increased floor, else the transfer reverts with `InvalidEquityFloorTransfer`. Pass `'auto'`
+     * (quote market only) to move the minimal floor needed for the debited side to stay at/above its
+     * floor: `max(0, amount - (collateral - floor))`, capped at the debited side's floor. The auto delta
+     * never exceeds `amount`, so the credited side stays backed whenever it was before. Client-side
+     * pricing can differ slightly from the on-chain strict check at the exact boundary; retry with an
+     * explicit padded delta if an `'auto'` transfer reverts. Defaults to zero.
      * @param txParams - Optional compute-unit/priority-fee overrides for the transaction.
      * @returns The transaction signature.
      * @throws (on-chain) if `allowDelegateTransfer` is not enabled, if the signer is not the delegate on
      * both sub-accounts, if the sub-accounts have different owners, if either is bankrupt, or if
      * `fromSubAccountId === toSubAccountId`.
      */
-    async transferDepositByDelegate(amount, marketIndex, fromSubAccountId, toSubAccountId, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getTransferDepositByDelegateIx(amount, marketIndex, fromSubAccountId, toSubAccountId), txParams), [], this.opts);
+    async transferDepositByDelegate(amount, marketIndex, fromSubAccountId, toSubAccountId, equityFloorDelta = numericConstants_1.ZERO, txParams) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getTransferDepositByDelegateIx(amount, marketIndex, fromSubAccountId, toSubAccountId, equityFloorDelta), txParams), [], this.opts);
         if (fromSubAccountId === this.activeSubAccountId ||
             toSubAccountId === this.activeSubAccountId) {
             this.cacheSpotMarketSlot(slot, marketIndex);
@@ -3179,28 +3189,49 @@ class VelocityClient {
      * @param toSubAccountId - Sub-account id to credit.
      * @returns The instruction.
      */
-    async getTransferDepositByDelegateIx(amount, marketIndex, fromSubAccountId, toSubAccountId) {
+    async getTransferDepositByDelegateIx(amount, marketIndex, fromSubAccountId, toSubAccountId, equityFloorDelta = numericConstants_1.ZERO) {
         const fromUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, fromSubAccountId);
         const toUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, toSubAccountId);
-        let remainingAccounts;
-        const userMapKey = this.getUserMapKey(fromSubAccountId, this.authority);
-        const mapUser = this.users.get(userMapKey);
-        if (mapUser) {
-            remainingAccounts = this.getRemainingAccounts({
-                userAccounts: [mapUser.getUserAccountOrThrow()],
-                useMarketLastSlotCache: true,
-                writableSpotMarketIndexes: [marketIndex],
-            });
+        let resolvedFloorDelta;
+        if (equityFloorDelta === 'auto') {
+            // auto assumes amount and equity share QUOTE_PRECISION; for
+            // non-quote markets the caller must value the tokens themselves
+            if (marketIndex !== numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                throw new Error("equityFloorDelta 'auto' is only supported for the quote spot market; pass an explicit delta");
+            }
+            const fromUserClass = this.getUser(fromSubAccountId, this.authority);
+            const floor = fromUserClass.getUserAccountOrThrow().equityFloor;
+            if (floor.lte(numericConstants_1.ZERO)) {
+                resolvedFloorDelta = numericConstants_1.ZERO;
+            }
+            else {
+                const excess = anchor_1.BN.max(fromUserClass.getTotalCollateral('Initial', true).sub(floor), numericConstants_1.ZERO);
+                resolvedFloorDelta = anchor_1.BN.min(anchor_1.BN.max(amount.sub(excess), numericConstants_1.ZERO), floor);
+            }
         }
         else {
-            const fromUserAccount = (await this.program.account.user.fetch(fromUser));
-            remainingAccounts = this.getRemainingAccounts({
-                userAccounts: [fromUserAccount],
-                useMarketLastSlotCache: true,
-                writableSpotMarketIndexes: [marketIndex],
-            });
+            resolvedFloorDelta = equityFloorDelta;
         }
-        return await this.program.instruction.transferDepositByDelegate(marketIndex, amount, {
+        const loadUserAccount = async (subAccountId, userPublicKey) => {
+            const userMapKey = this.getUserMapKey(subAccountId, this.authority);
+            const mapUser = this.users.get(userMapKey);
+            if (mapUser) {
+                return mapUser.getUserAccountOrThrow();
+            }
+            return (await this.program.account.user.fetch(userPublicKey));
+        };
+        // moving equity floor triggers an on-chain margin check of the credited
+        // side, so its markets/oracles must be in the remaining accounts too
+        const userAccounts = [await loadUserAccount(fromSubAccountId, fromUser)];
+        if (resolvedFloorDelta.gt(numericConstants_1.ZERO)) {
+            userAccounts.push(await loadUserAccount(toSubAccountId, toUser));
+        }
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts,
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        return await this.program.instruction.transferDepositByDelegate(marketIndex, amount, resolvedFloorDelta, {
             accounts: {
                 delegate: this.wallet.publicKey,
                 fromUser,
@@ -5241,6 +5272,42 @@ class VelocityClient {
             remainingAccounts,
         });
     }
+    /**
+     * Keeper instruction: trips the authority-wide equity floor breaker. Proves on-chain that the
+     * given subaccount's cross-margin total collateral is below its `equityFloor` (reverts with
+     * `SufficientCollateral` otherwise, or if no floor is set) and sets `equityBreakerTripped` on the
+     * authority's `UserStats` — every subaccount of the authority then rejects risk-increasing fills,
+     * withdrawals and transfers out until the warm admin calls `resetEquityFloorBreaker`.
+     * Permissionless — any signer may trip it; the margin calculation is the proof.
+     * @param userAccountPublicKey - Public key of the breached subaccount's user account.
+     * @param user - Decoded user account of the breached subaccount.
+     * @param txParams - Optional compute-unit/priority-fee overrides.
+     * @returns The transaction signature.
+     */
+    async tripEquityFloorBreaker(userAccountPublicKey, user, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getTripEquityFloorBreakerIx(userAccountPublicKey, user), txParams), [], this.opts);
+        return txSig;
+    }
+    /**
+     * Builds the `tripEquityFloorBreaker` instruction. See `tripEquityFloorBreaker` for semantics.
+     * @param userAccountPublicKey - Public key of the breached subaccount's user account.
+     * @param userAccount - Decoded user account of the breached subaccount.
+     * @returns The instruction.
+     */
+    async getTripEquityFloorBreakerIx(userAccountPublicKey, userAccount) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [userAccount],
+        });
+        return await this.program.instruction.tripEquityFloorBreaker({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                keeper: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority),
+            },
+            remainingAccounts,
+        });
+    }
     /**
      * Keeper instruction: marks a user account idle after confirming (via `validate_user_is_idle`)
      * it has been inactive long enough — the inactivity window is shorter (accelerated) when the
@@ -7183,11 +7250,12 @@ class VelocityClient {
     }
     /**
      * Keeper instruction: estimates the market's bid/ask price from the given makers' resting DLOB
-     * orders (filtered to those within `BID_ASK_TWAP_MAX_ORACLE_DIVERGENCE_PERCENT` of the oracle
-     * price) and folds the estimate into `lastBidPriceTwap`/`lastAskPriceTwap`. Restricted: the
-     * calling wallet's `UserStats` must have `canUpdateBidAskTwap` set and at least 1000 USDC
-     * (`QUOTE_PRECISION`, 1e6) staked in the insurance fund (`ifStakedQuoteAssetAmount`), or the
-     * instruction reverts.
+     * orders (kept only within `±BID_ASK_TWAP_MAX_ORACLE_DIVERGENCE_PERCENT` of the oracle price on
+     * both sides) and folds the estimate into `lastBidPriceTwap`/`lastAskPriceTwap`. This does NOT
+     * update the funding rate, crank funding separately via `getUpdateFundingRateIx`. Restricted:
+     * the calling wallet's `UserStats` (which must be the signer's own) must have
+     * `canUpdateBidAskTwap` set and at least 1000 USDC (`QUOTE_PRECISION`, 1e6) staked in the
+     * insurance fund (`ifStakedQuoteAssetAmount`), or the instruction reverts.
      * @param perpMarketIndex - Perp market index to update.
      * @param makers - `(maker, makerStats)` pairs whose resting orders are sampled for the estimate.
      * @param txParams - Optional compute-unit/priority-fee overrides.
@@ -7433,15 +7501,17 @@ class VelocityClient {
      * @param marketIndex - Spot market index whose insurance fund to stake into.
      * @returns The instruction.
      */
-    async getInitializeInsuranceFundStakeIx(marketIndex) {
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+    async getInitializeInsuranceFundStakeIx(marketIndex, overrides) {
+        var _a;
+        const authority = (_a = overrides === null || overrides === void 0 ? void 0 : overrides.authority) !== null && _a !== void 0 ? _a : this.wallet.publicKey;
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, authority, marketIndex);
         const accounts = {
             insuranceFundStake: ifStakeAccountPublicKey,
             spotMarket: this.getSpotMarketAccountOrThrow(marketIndex).pubkey,
-            userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey // only allow payer to initialize own insurance fund stake account
+            userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, authority // only allow payer to initialize own insurance fund stake account
             ),
-            authority: this.wallet.publicKey,
-            payer: this.wallet.publicKey,
+            authority,
+            payer: authority,
             rent: web3_js_1.SYSVAR_RENT_PUBKEY,
             systemProgram: web3_js_1.SystemProgram.programId,
             state: await this.getStatePublicKey(),
@@ -7462,9 +7532,11 @@ class VelocityClient {
      * @param collateralAccountPublicKey - Token account to debit for the stake.
      * @returns The instruction.
      */
-    async getAddInsuranceFundStakeIx(marketIndex, amount, collateralAccountPublicKey) {
+    async getAddInsuranceFundStakeIx(marketIndex, amount, collateralAccountPublicKey, overrides) {
+        var _a;
+        const authority = (_a = overrides === null || overrides === void 0 ? void 0 : overrides.authority) !== null && _a !== void 0 ? _a : this.wallet.publicKey;
         const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, authority, marketIndex);
         const remainingAccounts = [];
         this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
         if (this.isTransferHook(spotMarket)) {
@@ -7476,9 +7548,9 @@ class VelocityClient {
                 state: await this.getStatePublicKey(),
                 spotMarket: spotMarket.pubkey,
                 insuranceFundStake: ifStakeAccountPublicKey,
-                userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey // only allow payer to add to own insurance fund stake account
+                userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, authority // only allow payer to add to own insurance fund stake account
                 ),
-                authority: this.wallet.publicKey,
+                authority,
                 spotMarketVault: spotMarket.vault,
                 insuranceFundVault: spotMarket.insuranceFund.vault,
                 velocitySigner: this.getSignerPublicKey(),

package/lib/node/adminClient.d.ts

@@ -2462,6 +2462,41 @@ export declare class AdminClient extends VelocityClient {
      * @returns The unsigned `updateSpecialUserStatus` instruction.
      */
     getUpdateSpecialUserStatusIx(userAccountPublicKey: PublicKey, status: number): Promise<TransactionInstruction>;
+    /**
+     * Sets a `User` account's `equityFloor`: the minimum cross-margin total
+     * collateral (QUOTE_PRECISION) the account must keep. Below the floor the
+     * program rejects risk-increasing order placement and fills, withdrawals,
+     * and deposit/position transfers out of the account; reduce-only activity
+     * stays allowed. Requires warm admin (`check_warm`); the account's
+     * authority and delegate cannot change it. Pass `0` to disable.
+     * @param userAccountPublicKey - `User` PDA to update.
+     * @param equityFloor - New floor, QUOTE_PRECISION; `0` disables.
+     * @param txParams - Optional transaction-building overrides.
+     * @returns Transaction signature.
+     */
+    updateUserEquityFloor(userAccountPublicKey: PublicKey, equityFloor: BN, txParams?: TxParams): Promise<TransactionSignature>;
+    /**
+     * Builds the `updateUserEquityFloor` instruction without sending it. See
+     * `updateUserEquityFloor`.
+     * @returns The unsigned `updateUserEquityFloor` instruction.
+     */
+    getUpdateUserEquityFloorIx(userAccountPublicKey: PublicKey, equityFloor: BN): Promise<TransactionInstruction>;
+    /**
+     * Clears the authority-wide equity floor breaker set by the permissionless
+     * `tripEquityFloorBreaker` keeper instruction, unfreezing all of the
+     * authority's subaccounts. Requires warm admin (`check_warm`); intended to
+     * be called after a human has reviewed why the breaker fired.
+     * @param userStatsPublicKey - `UserStats` PDA of the authority to unfreeze.
+     * @param txParams - Optional transaction-building overrides.
+     * @returns Transaction signature.
+     */
+    resetEquityFloorBreaker(userStatsPublicKey: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    /**
+     * Builds the `resetEquityFloorBreaker` instruction without sending it. See
+     * `resetEquityFloorBreaker`.
+     * @returns The unsigned `resetEquityFloorBreaker` instruction.
+     */
+    getResetEquityFloorBreakerIx(userStatsPublicKey: PublicKey): Promise<TransactionInstruction>;
     /**
      * Rotates `state.warmAdmin`, the operational (multisig+timelock) tier that can
      * rotate every hot-role key (`updateHotAdmin`). Cold-only: the `UpdateWarmAdmin`