@velocity-exchange/sdk 0.7.0 → 0.9.0

package/lib/browser/adminClient.d.ts

@@ -894,9 +894,13 @@ export declare class AdminClient extends VelocityClient {
      * `updateWithdrawGuardThreshold` — in particular, the `oracle` param must equal
      * `spotMarket.oracle` (enforced by the `has_one` constraint) and is auto-resolved when
      * omitted. Throws if the spot market account can't be found when not subscribed.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateWithdrawGuardThreshold` instruction.
      */
-    getUpdateWithdrawGuardThresholdIx(spotMarketIndex: number, withdrawGuardThreshold: BN, oracle?: PublicKey): Promise<TransactionInstruction>;
+    getUpdateWithdrawGuardThresholdIx(spotMarketIndex: number, withdrawGuardThreshold: BN, oracle?: PublicKey, admin?: PublicKey): Promise<TransactionInstruction>;
     /**
      * Sets a spot market's lending-gain carveouts: the share of deposit interest routed to the
      * insurance fund (`ifFeeFactor`) and to the withdrawable protocol fee pool
@@ -913,9 +917,13 @@ export declare class AdminClient extends VelocityClient {
     /**
      * Builds the `updateSpotMarketIfFactor` instruction without sending it. See
      * `updateSpotMarketIfFactor` for units and validation.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateSpotMarketIfFactor` instruction.
      */
-    getUpdateSpotMarketIfFactorIx(spotMarketIndex: number, ifFeeFactor: number, protocolFeeFactor: number): Promise<TransactionInstruction>;
+    getUpdateSpotMarketIfFactorIx(spotMarketIndex: number, ifFeeFactor: number, protocolFeeFactor: number, admin?: PublicKey): Promise<TransactionInstruction>;
     /**
      * Sets how often a spot market's revenue pool may be settled to the insurance fund.
      * Requires warm admin (`check_warm`).
@@ -943,6 +951,10 @@ export declare class AdminClient extends VelocityClient {
      * @returns The unsigned `updateSpotMarketMaxTokenDeposits` instruction.
      */
     getUpdateSpotMarketMaxTokenDepositsIx(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionInstruction>;
+    updateSpotMarketWithdrawCircuitBreaker(spotMarketIndex: number, withdrawCircuitBreakerBps: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketWithdrawCircuitBreakerIx(spotMarketIndex: number, withdrawCircuitBreakerBps: number): Promise<TransactionInstruction>;
+    updateSpotMarketDepositCap(spotMarketIndex: number, depositGuardThreshold: BN, maxDepositBpsPerDay: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketDepositCapIx(spotMarketIndex: number, depositGuardThreshold: BN, maxDepositBpsPerDay: number): Promise<TransactionInstruction>;
     /**
      * Caps a spot market's total borrows as a fraction of its `maxTokenDeposits`, rather than
      * an absolute token amount. Requires warm admin (`check_warm`). On-chain, the effective cap
@@ -971,9 +983,13 @@ export declare class AdminClient extends VelocityClient {
     /**
      * Builds the `updateSpotMarketScaleInitialAssetWeightStart` instruction without sending it.
      * See `updateSpotMarketScaleInitialAssetWeightStart`.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateSpotMarketScaleInitialAssetWeightStart` instruction.
      */
-    getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionInstruction>;
+    getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex: number, scaleInitialAssetWeightStart: BN, admin?: PublicKey): Promise<TransactionInstruction>;
     /**
      * Sets how long an insurance-fund staker's unstake request must sit in escrow before it can
      * be completed for a given spot market. Requires warm admin (`check_warm`).
@@ -1258,9 +1274,13 @@ export declare class AdminClient extends VelocityClient {
     /**
      * Builds the `updateSpotMarketStatus` instruction without sending it. See
      * `updateSpotMarketStatus`.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateSpotMarketStatus` instruction.
      */
-    getUpdateSpotMarketStatusIx(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionInstruction>;
+    getUpdateSpotMarketStatusIx(spotMarketIndex: number, marketStatus: MarketStatus, admin?: PublicKey): Promise<TransactionInstruction>;
     /**
      * Sets a spot market's operation pause bitmask (`SpotOperation`: `UpdateCumulativeInterest`
      * 0b00001, `Fill` 0b00010, `Deposit` 0b00100, `Withdraw` 0b01000, `Liquidation` 0b10000).
@@ -2480,24 +2500,27 @@ export declare class AdminClient extends VelocityClient {
      */
     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.
+     * Sets a `User` account's `equityFloor` and `equityFloorBuffer`. The floor
+     * is the minimum cross-margin total collateral (QUOTE_PRECISION) below
+     * which the permissionless breaker can trip; risk-increasing order
+     * placement and fills, withdrawals, and deposit/position transfers out of
+     * the account must clear `floor + buffer` (`EquityBelowFloor` otherwise);
+     * reduce-only activity stays allowed. Requires warm admin (`check_warm`);
+     * the account's authority and delegate cannot change either value. Pass
+     * `0` as the floor to disable both checks.
      * @param userAccountPublicKey - `User` PDA to update.
      * @param equityFloor - New floor, QUOTE_PRECISION; `0` disables.
+     * @param equityFloorBuffer - New buffer, QUOTE_PRECISION; no effect while the floor is 0.
      * @param txParams - Optional transaction-building overrides.
      * @returns Transaction signature.
      */
-    updateUserEquityFloor(userAccountPublicKey: PublicKey, equityFloor: BN, txParams?: TxParams): Promise<TransactionSignature>;
+    updateUserEquityFloor(userAccountPublicKey: PublicKey, equityFloor: BN, equityFloorBuffer: 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>;
+    getUpdateUserEquityFloorIx(userAccountPublicKey: PublicKey, equityFloor: BN, equityFloorBuffer: BN): Promise<TransactionInstruction>;
     /**
      * Clears the authority-wide equity floor breaker set by the permissionless
      * `tripEquityFloorBreaker` keeper instruction, unfreezing all of the

package/lib/browser/adminClient.js

@@ -1767,9 +1767,13 @@ class AdminClient extends velocityClient_1.VelocityClient {
      * `updateWithdrawGuardThreshold` — in particular, the `oracle` param must equal
      * `spotMarket.oracle` (enforced by the `has_one` constraint) and is auto-resolved when
      * omitted. Throws if the spot market account can't be found when not subscribed.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateWithdrawGuardThreshold` instruction.
      */
-    async getUpdateWithdrawGuardThresholdIx(spotMarketIndex, withdrawGuardThreshold, oracle) {
+    async getUpdateWithdrawGuardThresholdIx(spotMarketIndex, withdrawGuardThreshold, oracle, admin) {
         const spotMarketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
         if (!oracle) {
             const cachedSpotMarket = this.isSubscribed
@@ -1789,9 +1793,9 @@ class AdminClient extends velocityClient_1.VelocityClient {
         }
         return await this.program.instruction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
             accounts: {
-                admin: this.isSubscribed
+                admin: admin !== null && admin !== void 0 ? admin : (this.isSubscribed
                     ? this.getStateAccount().coldAdmin
-                    : this.wallet.publicKey,
+                    : this.wallet.publicKey),
                 state: await this.getStatePublicKey(),
                 spotMarket: spotMarketPublicKey,
                 oracle,
@@ -1819,14 +1823,18 @@ class AdminClient extends velocityClient_1.VelocityClient {
     /**
      * Builds the `updateSpotMarketIfFactor` instruction without sending it. See
      * `updateSpotMarketIfFactor` for units and validation.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateSpotMarketIfFactor` instruction.
      */
-    async getUpdateSpotMarketIfFactorIx(spotMarketIndex, ifFeeFactor, protocolFeeFactor) {
+    async getUpdateSpotMarketIfFactorIx(spotMarketIndex, ifFeeFactor, protocolFeeFactor, admin) {
         return await this.program.instruction.updateSpotMarketIfFactor(spotMarketIndex, ifFeeFactor, protocolFeeFactor, {
             accounts: {
-                admin: this.isSubscribed
+                admin: admin !== null && admin !== void 0 ? admin : (this.isSubscribed
                     ? this.getStateAccount().coldAdmin
-                    : this.wallet.publicKey,
+                    : this.wallet.publicKey),
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
@@ -1889,6 +1897,40 @@ class AdminClient extends velocityClient_1.VelocityClient {
             },
         });
     }
+    async updateSpotMarketWithdrawCircuitBreaker(spotMarketIndex, withdrawCircuitBreakerBps) {
+        const ix = await this.getUpdateSpotMarketWithdrawCircuitBreakerIx(spotMarketIndex, withdrawCircuitBreakerBps);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketWithdrawCircuitBreakerIx(spotMarketIndex, withdrawCircuitBreakerBps) {
+        return this.program.instruction.updateSpotMarketWithdrawCircuitBreaker(withdrawCircuitBreakerBps, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketDepositCap(spotMarketIndex, depositGuardThreshold, maxDepositBpsPerDay) {
+        const ix = await this.getUpdateSpotMarketDepositCapIx(spotMarketIndex, depositGuardThreshold, maxDepositBpsPerDay);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketDepositCapIx(spotMarketIndex, depositGuardThreshold, maxDepositBpsPerDay) {
+        return this.program.instruction.updateSpotMarketDepositCap(depositGuardThreshold, maxDepositBpsPerDay, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
     /**
      * Caps a spot market's total borrows as a fraction of its `maxTokenDeposits`, rather than
      * an absolute token amount. Requires warm admin (`check_warm`). On-chain, the effective cap
@@ -1937,14 +1979,18 @@ class AdminClient extends velocityClient_1.VelocityClient {
     /**
      * Builds the `updateSpotMarketScaleInitialAssetWeightStart` instruction without sending it.
      * See `updateSpotMarketScaleInitialAssetWeightStart`.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateSpotMarketScaleInitialAssetWeightStart` instruction.
      */
-    async getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex, scaleInitialAssetWeightStart) {
+    async getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex, scaleInitialAssetWeightStart, admin) {
         return this.program.instruction.updateSpotMarketScaleInitialAssetWeightStart(scaleInitialAssetWeightStart, {
             accounts: {
-                admin: this.isSubscribed
+                admin: admin !== null && admin !== void 0 ? admin : (this.isSubscribed
                     ? this.getStateAccount().coldAdmin
-                    : this.wallet.publicKey,
+                    : this.wallet.publicKey),
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
@@ -2492,14 +2538,18 @@ class AdminClient extends velocityClient_1.VelocityClient {
     /**
      * Builds the `updateSpotMarketStatus` instruction without sending it. See
      * `updateSpotMarketStatus`.
+     * @param admin - Overrides the `admin` signer account. The instruction is warm-gated
+     *   on-chain, so pass the key that will actually sign at execution — e.g. a Squads warm-admin
+     *   vault PDA when the ix is wrapped in a multisig proposal. Defaults to `state.coldAdmin`
+     *   (or the wallet if not subscribed).
      * @returns The unsigned `updateSpotMarketStatus` instruction.
      */
-    async getUpdateSpotMarketStatusIx(spotMarketIndex, marketStatus) {
+    async getUpdateSpotMarketStatusIx(spotMarketIndex, marketStatus, admin) {
         return await this.program.instruction.updateSpotMarketStatus(marketStatus, {
             accounts: {
-                admin: this.isSubscribed
+                admin: admin !== null && admin !== void 0 ? admin : (this.isSubscribed
                     ? this.getStateAccount().coldAdmin
-                    : this.wallet.publicKey,
+                    : this.wallet.publicKey),
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
@@ -4886,19 +4936,22 @@ class AdminClient extends velocityClient_1.VelocityClient {
         });
     }
     /**
-     * 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.
+     * Sets a `User` account's `equityFloor` and `equityFloorBuffer`. The floor
+     * is the minimum cross-margin total collateral (QUOTE_PRECISION) below
+     * which the permissionless breaker can trip; risk-increasing order
+     * placement and fills, withdrawals, and deposit/position transfers out of
+     * the account must clear `floor + buffer` (`EquityBelowFloor` otherwise);
+     * reduce-only activity stays allowed. Requires warm admin (`check_warm`);
+     * the account's authority and delegate cannot change either value. Pass
+     * `0` as the floor to disable both checks.
      * @param userAccountPublicKey - `User` PDA to update.
      * @param equityFloor - New floor, QUOTE_PRECISION; `0` disables.
+     * @param equityFloorBuffer - New buffer, QUOTE_PRECISION; no effect while the floor is 0.
      * @param txParams - Optional transaction-building overrides.
      * @returns Transaction signature.
      */
-    async updateUserEquityFloor(userAccountPublicKey, equityFloor, txParams) {
-        const ix = await this.getUpdateUserEquityFloorIx(userAccountPublicKey, equityFloor);
+    async updateUserEquityFloor(userAccountPublicKey, equityFloor, equityFloorBuffer, txParams) {
+        const ix = await this.getUpdateUserEquityFloorIx(userAccountPublicKey, equityFloor, equityFloorBuffer);
         const tx = await this.buildTransaction(ix, txParams);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
@@ -4908,8 +4961,8 @@ class AdminClient extends velocityClient_1.VelocityClient {
      * `updateUserEquityFloor`.
      * @returns The unsigned `updateUserEquityFloor` instruction.
      */
-    async getUpdateUserEquityFloorIx(userAccountPublicKey, equityFloor) {
-        return this.program.instruction.updateUserEquityFloor(equityFloor, {
+    async getUpdateUserEquityFloorIx(userAccountPublicKey, equityFloor, equityFloorBuffer) {
+        return this.program.instruction.updateUserEquityFloor(equityFloor, equityFloorBuffer, {
             accounts: {
                 admin: this.useHotWalletAdmin
                     ? this.wallet.publicKey

package/lib/browser/core/VelocityCore.d.ts

@@ -224,6 +224,7 @@ export declare class VelocityCore {
      * @param args.state - the global `State` PDA.
      * @param args.filler - the keeper's `User` account submitting the trigger.
      * @param args.user - the order owner's `User` account.
+     * @param args.userStats - the order owner's `UserStats` account (authority-wide equity breaker).
      * @param args.authority - signer that must own or be a registered delegate of `filler`.
      * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
      * @returns the unsigned `triggerOrder` `TransactionInstruction`.
@@ -234,6 +235,7 @@ export declare class VelocityCore {
         state: PublicKey;
         filler: PublicKey;
         user: PublicKey;
+        userStats: PublicKey;
         authority: PublicKey;
         remainingAccounts: AccountMeta[];
     }): Promise<TransactionInstruction>;

package/lib/browser/core/VelocityCore.js

@@ -202,6 +202,7 @@ class VelocityCore {
      * @param args.state - the global `State` PDA.
      * @param args.filler - the keeper's `User` account submitting the trigger.
      * @param args.user - the order owner's `User` account.
+     * @param args.userStats - the order owner's `UserStats` account (authority-wide equity breaker).
      * @param args.authority - signer that must own or be a registered delegate of `filler`.
      * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
      * @returns the unsigned `triggerOrder` `TransactionInstruction`.

package/lib/browser/core/instructions/trigger.d.ts

@@ -11,6 +11,9 @@ import type { VelocityProgram } from '../../config';
  * @param args.state - the global `State` PDA.
  * @param args.filler - the keeper's `User` account submitting the trigger.
  * @param args.user - the order owner's `User` account.
+ * @param args.userStats - the order owner's `UserStats` account (checked for the
+ *   authority-wide equity breaker; a risk-increasing trigger order is cancelled
+ *   rather than activated while the breaker is tripped).
  * @param args.authority - signer that must own or be a registered delegate of `filler`.
  * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
  * @returns the unsigned `triggerOrder` `TransactionInstruction`.
@@ -21,6 +24,7 @@ export declare function buildTriggerOrderInstruction(args: {
     state: PublicKey;
     filler: PublicKey;
     user: PublicKey;
+    userStats: PublicKey;
     authority: PublicKey;
     remainingAccounts: AccountMeta[];
 }): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/trigger.js

@@ -12,6 +12,9 @@ exports.buildTriggerOrderInstruction = void 0;
  * @param args.state - the global `State` PDA.
  * @param args.filler - the keeper's `User` account submitting the trigger.
  * @param args.user - the order owner's `User` account.
+ * @param args.userStats - the order owner's `UserStats` account (checked for the
+ *   authority-wide equity breaker; a risk-increasing trigger order is cancelled
+ *   rather than activated while the breaker is tripped).
  * @param args.authority - signer that must own or be a registered delegate of `filler`.
  * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
  * @returns the unsigned `triggerOrder` `TransactionInstruction`.
@@ -22,6 +25,7 @@ async function buildTriggerOrderInstruction(args) {
             state: args.state,
             filler: args.filler,
             user: args.user,
+            userStats: args.userStats,
             authority: args.authority,
         },
         remainingAccounts: args.remainingAccounts,

package/lib/browser/decode/user.js

@@ -336,7 +336,8 @@ function decodeUser(buffer) {
     offset += 3; // padding
     const equityFloor = readUnsignedBigInt64LE(buffer, offset);
     offset += 8;
-    offset += 8; // padding2
+    const equityFloorBuffer = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
     return {
         authority,
         delegate,
@@ -366,6 +367,7 @@ function decodeUser(buffer) {
         poolId,
         specialUserStatus,
         equityFloor,
+        equityFloorBuffer,
     };
 }
 exports.decodeUser = decodeUser;

package/lib/browser/equityFloorManager.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Maker-facing abstraction over the per-subaccount equity floor. The on-chain
+ * checks are deliberately per-subaccount (each check reads only the one User
+ * account already loaded in the hot path), which leaves the burden of placing
+ * floor where the equity is on the delegate. This module removes that burden:
+ * it treats an authority's subaccounts as one pool, plans quote transfers with
+ * the exact floor delta they must carry, computes how much can leave a
+ * subaccount, and rebalances the floor split to match where the equity
+ * actually sits — so a delegate never has to reason about floor placement to
+ * stay clear of the breaker.
+ */
+import { PublicKey } from '@solana/web3.js';
+import { TransactionSignature } from '@solana/web3.js';
+import { BN } from './isomorphic/anchor';
+import { EquityFloorLevel } from './math/margin';
+import { VelocityClient } from './velocityClient';
+import { TxParams } from './types';
+/** One subaccount's standing relative to its floor. All BN values QUOTE_PRECISION. */
+export type SubaccountFloorStatus = {
+    subAccountId: number;
+    /** Cross-margin total collateral, strict (TWAP-bounded) pricing — what the on-chain checks see. */
+    equity: BN;
+    equityFloor: BN;
+    equityFloorBuffer: BN;
+    /** `equityFloor + equityFloorBuffer`: what risk-increasing actions must clear. */
+    bufferedFloor: BN;
+    /** `equity - equityFloor`; negative means the breaker can trip on this subaccount. */
+    headroom: BN;
+    /** `equity - bufferedFloor`; negative means risk-increasing actions are rejecting. */
+    bufferedHeadroom: BN;
+    level: EquityFloorLevel;
+};
+/** Authority-wide standing: aggregates plus the per-subaccount breakdown. */
+export type EquityFloorStatus = {
+    authority: PublicKey;
+    breakerTripped: boolean;
+    totalEquity: BN;
+    totalFloor: BN;
+    totalBuffer: BN;
+    /** `totalEquity - (totalFloor + totalBuffer)`: the slack the whole pool has to allocate. */
+    totalBufferedHeadroom: BN;
+    /** Worst level across subaccounts with a floor set. */
+    level: EquityFloorLevel;
+    subaccounts: SubaccountFloorStatus[];
+};
+/** A floor-only rebalance step: zero-amount `transferDepositByDelegate` carrying `equityFloorDelta`. */
+export type FloorMove = {
+    fromSubAccountId: number;
+    toSubAccountId: number;
+    equityFloorDelta: BN;
+};
+/** A fully resolved quote transfer ready to submit. */
+export type QuoteTransferPlan = {
+    amount: BN;
+    marketIndex: number;
+    fromSubAccountId: number;
+    toSubAccountId: number;
+    equityFloorDelta: BN;
+};
+/**
+ * Splits `totalFloor` across subaccounts proportionally to their equity,
+ * clamped so every allocation is backed (`floor_i <= max(0, equity_i -
+ * buffer_i)`), with the clamped remainder water-filled into subaccounts that
+ * still have capacity. Entries in `pinned` keep their current floor and
+ * receive none of the remainder (used for breached subaccounts, which cannot
+ * shed floor on-chain). Returns `null` when no backed allocation exists, i.e.
+ * the pool's equity cannot cover `totalFloor` plus buffers.
+ */
+export declare function allocateEquityFloors(totalFloor: BN, subaccounts: {
+    equity: BN;
+    buffer: BN;
+    currentFloor: BN;
+}[], pinned?: boolean[]): BN[] | null;
+/**
+ * Turns a current → target floor split into concrete moves, greedily matching
+ * surpluses against deficits. The moves conserve the floor sum by
+ * construction and each one only ever sheds floor from a subaccount whose
+ * floor is above its target.
+ */
+export declare function planFloorMoves(subAccountIds: number[], current: BN[], target: BN[]): FloorMove[];
+export type EquityFloorManagerConfig = {
+    /**
+     * Subaccount ids to manage. Defaults to every subaccount of the client's
+     * authority currently subscribed on the `VelocityClient`.
+     */
+    subAccountIds?: number[];
+    /**
+     * Client-side equity haircut (QUOTE_PRECISION) applied when sizing floor
+     * deltas, absorbing the dust by which strict on-chain pricing can differ
+     * from the client's. Defaults to 1 quote unit ($1).
+     */
+    collateralHaircut?: BN;
+};
+/**
+ * See the module doc. All reads use the subaccounts already subscribed on the
+ * wrapped `VelocityClient` (the delegate's client, whose `authority` is the
+ * subaccounts' owner); all writes go through `transferDepositByDelegate`.
+ */
+export declare class EquityFloorManager {
+    private velocityClient;
+    private collateralHaircut;
+    private subAccountIds?;
+    constructor(velocityClient: VelocityClient, config?: EquityFloorManagerConfig);
+    private getManagedUsers;
+    private getSubaccountStatus;
+    /** Full authority-wide standing: aggregates, worst level, per-subaccount detail. */
+    getStatus(): EquityFloorStatus;
+    /**
+     * The most quote that can leave `subAccountId` to the outside (a
+     * withdrawal, which cannot move floor): equity above the buffered floor,
+     * less the haircut. Floor constraint only — the withdrawal itself is still
+     * subject to margin and borrow limits.
+     */
+    getMaxWithdrawable(subAccountId: number): BN;
+    /**
+     * The most quote that can move from one subaccount to another when the
+     * transfer carries floor with it. Because floor travels with the funds
+     * (capped at the floor the debited side holds, after which its check
+     * disables entirely), this is normally the debited side's whole equity —
+     * bounded by what the credited side's equity can back. Floor constraint
+     * only; margin and borrow limits still apply on top.
+     */
+    getMaxQuoteTransferable(fromSubAccountId: number, toSubAccountId: number): BN;
+    /**
+     * Resolves a quote transfer into the exact instruction parameters,
+     * padding the auto floor delta by the haircut so on-chain strict pricing
+     * dust cannot fail it. The padded delta never exceeds the amount or the
+     * debited side's floor, so the credited side stays backed whenever it was
+     * before.
+     */
+    planQuoteTransfer(amount: BN, fromSubAccountId: number, toSubAccountId: number): QuoteTransferPlan;
+    /** Plans and submits a quote transfer between two subaccounts in one call. */
+    transferQuote(amount: BN, fromSubAccountId: number, toSubAccountId: number, txParams?: TxParams): Promise<TransactionSignature>;
+    /**
+     * Plans the floor-only moves (zero-amount transfers) that re-split the
+     * total floor proportionally to where the equity currently sits, so every
+     * subaccount ends with the same relative headroom. Breached subaccounts
+     * (below their raw floor) cannot shed floor on-chain, so their floor is
+     * pinned in place and the rest is allocated around them. Throws when the
+     * pool's equity cannot back the total floor plus buffers — at that point
+     * no split works and equity must be deposited (or the admin must lower
+     * the floor).
+     */
+    planFloorRebalance(): FloorMove[];
+    /**
+     * Executes `planFloorRebalance` serially. Safe to run at any time; a
+     * no-op when the split already matches the equity distribution.
+     */
+    rebalanceFloors(txParams?: TxParams): Promise<TransactionSignature[]>;
+}