@velocity-exchange/sdk 0.7.0 → 0.8.0

package/lib/node/idl/velocity.json

@@ -2,7 +2,7 @@
     "address": "vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P",
     "metadata": {
         "name": "velocity",
-        "version": "2.163.1",
+        "version": "2.164.0",
         "spec": "0.1.0",
         "description": "Created with Anchor"
     },
@@ -4420,6 +4420,9 @@
                     "name": "liquidator",
                     "writable": true
                 },
+                {
+                    "name": "liquidator_stats"
+                },
                 {
                     "name": "user",
                     "writable": true
@@ -6283,6 +6286,9 @@
                 52
             ],
             "accounts": [
+                {
+                    "name": "state"
+                },
                 {
                     "name": "spot_market",
                     "writable": true,
@@ -6327,6 +6333,40 @@
                         "user_stats"
                     ]
                 },
+                {
+                    "name": "spot_market_vault",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    115,
+                                    112,
+                                    111,
+                                    116,
+                                    95,
+                                    109,
+                                    97,
+                                    114,
+                                    107,
+                                    101,
+                                    116,
+                                    95,
+                                    118,
+                                    97,
+                                    117,
+                                    108,
+                                    116
+                                ]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "market_index"
+                            }
+                        ]
+                    }
+                },
                 {
                     "name": "insurance_fund_vault",
                     "writable": true,
@@ -6363,6 +6403,12 @@
                             }
                         ]
                     }
+                },
+                {
+                    "name": "velocity_signer"
+                },
+                {
+                    "name": "token_program"
                 }
             ],
             "args": [
@@ -6537,13 +6583,7 @@
                     }
                 },
                 {
-                    "name": "authority",
-                    "relations": [
-                        "user"
-                    ]
-                },
-                {
-                    "name": "user"
+                    "name": "authority"
                 },
                 {
                     "name": "payer",
@@ -8238,6 +8278,9 @@
                 {
                     "name": "user",
                     "writable": true
+                },
+                {
+                    "name": "user_stats"
                 }
             ],
             "args": [
@@ -11431,6 +11474,42 @@
             ],
             "args": []
         },
+        {
+            "name": "update_spot_market_deposit_cap",
+            "discriminator": [
+                76,
+                21,
+                179,
+                154,
+                28,
+                161,
+                174,
+                107
+            ],
+            "accounts": [
+                {
+                    "name": "admin",
+                    "signer": true
+                },
+                {
+                    "name": "state"
+                },
+                {
+                    "name": "spot_market",
+                    "writable": true
+                }
+            ],
+            "args": [
+                {
+                    "name": "deposit_guard_threshold",
+                    "type": "u64"
+                },
+                {
+                    "name": "max_deposit_bps_per_day",
+                    "type": "u16"
+                }
+            ]
+        },
         {
             "name": "update_spot_market_expiry",
             "discriminator": [
@@ -12070,6 +12149,38 @@
                 }
             ]
         },
+        {
+            "name": "update_spot_market_withdraw_circuit_breaker",
+            "discriminator": [
+                2,
+                97,
+                135,
+                97,
+                117,
+                169,
+                65,
+                223
+            ],
+            "accounts": [
+                {
+                    "name": "admin",
+                    "signer": true
+                },
+                {
+                    "name": "state"
+                },
+                {
+                    "name": "spot_market",
+                    "writable": true
+                }
+            ],
+            "args": [
+                {
+                    "name": "withdraw_circuit_breaker_bps",
+                    "type": "u16"
+                }
+            ]
+        },
         {
             "name": "update_state_max_initialize_user_fee",
             "discriminator": [
@@ -16157,6 +16268,31 @@
             "code": 6359,
             "name": "InvalidEquityFloorTransfer",
             "msg": "Invalid equity floor transfer between subaccounts"
+        },
+        {
+            "code": 6360,
+            "name": "IFDepositMintsZeroShares",
+            "msg": "Insurance fund deposit would mint zero shares"
+        },
+        {
+            "code": 6361,
+            "name": "LiquidationWorsensAccountHealth",
+            "msg": "Liquidation would worsen the account's margin shortage"
+        },
+        {
+            "code": 6362,
+            "name": "PerpBankruptcyMustPrecedeSpot",
+            "msg": "Perp bankruptcies must be resolved before spot bankruptcies"
+        },
+        {
+            "code": 6363,
+            "name": "InvalidRevenueShareRecipient",
+            "msg": "Revenue share recipient user must be sub_account_id 0"
+        },
+        {
+            "code": 6364,
+            "name": "DailyDepositLimit",
+            "msg": "Spot market daily deposit limit hit"
         }
     ],
     "types": [
@@ -21204,19 +21340,24 @@
                         }
                     },
                     {
-                        "name": "_padding_align_amm",
+                        "name": "pending_revenue_share",
                         "docs": [
-                            "8 bytes of explicit padding so MarketStats (216 bytes) plus this",
-                            "padding equals 224 bytes — the offset Rust naturally inserts to",
-                            "16-align AMM's leading u128. Making it explicit keeps the IDL byte",
-                            "layout aligned with `repr(C)`."
+                            "Aggregate accrued builder/referrer revenue-share owed out of this",
+                            "market's `pnl_pool` but not yet paid: incremented as builder and",
+                            "referrer fees accrue on fills (mirrors the per-order",
+                            "`RevenueShareOrder.fees_accrued` writes) and decremented as",
+                            "`sweep_completed_revenue_share_for_market` pays them. The",
+                            "permissionless fee sweep reserves it (like `max(net_user_pnl, 0)` and",
+                            "the floored IF tranche) so a protocol-fee drain can't move the tokens",
+                            "backing already-owed revenue share out of the pnl pool and leave those",
+                            "claims temporarily unpayable. precision: QUOTE_PRECISION.",
+                            "",
+                            "Occupies the 8 bytes Rust naturally inserts to 16-align AMM's leading",
+                            "u128 (formerly explicit `_padding_align_amm`): a u64 at the same",
+                            "8-aligned offset keeps every downstream byte offset and the total size",
+                            "unchanged, so legacy accounts read 0 (nothing owed) until fees accrue."
                         ],
-                        "type": {
-                            "array": [
-                                "u8",
-                                8
-                            ]
-                        }
+                        "type": "u64"
                     },
                     {
                         "name": "amm",
@@ -22998,15 +23139,44 @@
                     {
                         "name": "_padding_align_pfp",
                         "docs": [
-                            "Aligns `protocol_fee_pool`'s leading u128 to a 16-byte struct offset so",
-                            "host (x86_64, align 16) and SBF (align 8) layouts agree. Do not reorder."
+                            "Explicit filler carved from the alignment gap before `protocol_fee_pool`",
+                            "(which must stay at struct offset 752 so host/SBF layouts agree and the",
+                            "borsh/IDL packed offset matches). The gap is 13 bytes; the three",
+                            "configurable-limit fields below plus this 1-byte filler fill it exactly,",
+                            "so `protocol_fee_pool` and every field after it keep their offsets and the",
+                            "account size is unchanged. Reads 0 on markets created before these fields",
+                            "existed. Every byte is explicit so no implicit `#[repr(C)]` pad desyncs",
+                            "off-chain borsh decoders. Do not reorder or resize."
                         ],
-                        "type": {
-                            "array": [
-                                "u8",
-                                8
-                            ]
-                        }
+                        "type": "u8"
+                    },
+                    {
+                        "name": "withdraw_circuit_breaker_bps",
+                        "docs": [
+                            "Daily withdraw circuit-breaker size: the max fraction of the 24h deposit",
+                            "TWAP that may be withdrawn per 24h window. `0` is treated as the default",
+                            "(2500 bps = 25%) so markets created before this field existed keep prior",
+                            "behavior. precision: basis points (10_000 = 100%)"
+                        ],
+                        "type": "u16"
+                    },
+                    {
+                        "name": "max_deposit_bps_per_day",
+                        "docs": [
+                            "Daily deposit rate limit: the max fraction above the 24h deposit TWAP that",
+                            "resulting deposits may reach per 24h window. Disabled when `0`.",
+                            "precision: basis points (10_000 = 100%)"
+                        ],
+                        "type": "u16"
+                    },
+                    {
+                        "name": "deposit_guard_threshold",
+                        "docs": [
+                            "No deposit rate limit when resulting deposits are below this threshold.",
+                            "Mirrors `withdraw_guard_threshold` on the deposit side.",
+                            "precision: token mint precision"
+                        ],
+                        "type": "u64"
                     },
                     {
                         "name": "protocol_fee_pool",
@@ -23042,13 +23212,33 @@
                         "type": "u32"
                     },
                     {
-                        "name": "padding",
-                        "type": {
-                            "array": [
-                                "u8",
-                                8
-                            ]
-                        }
+                        "name": "if_last_settle_vault_amount",
+                        "docs": [
+                            "Donation-proof accounted balance of the insurance-fund vault. It is moved",
+                            "by the same signed delta as the real SPL vault on *every* instruction that",
+                            "moves the vault, so it stays a faithful shadow of the vault minus raw",
+                            "donations. Inflows grow it: staker deposits (`add_insurance_fund_stake`)",
+                            "and settled revenue (`settle_revenue_to_insurance_fund`). Outflows/draws",
+                            "shrink it (saturating at 0): staker withdrawals",
+                            "(`remove_insurance_fund_stake`) and every IF draw that covers a loss —",
+                            "`resolve_perp_pnl_deficit`, `resolve_perp_bankruptcy`,",
+                            "`resolve_spot_bankruptcy`. The one movement deliberately *excluded* is a",
+                            "raw SPL transfer straight into the vault: it runs no instruction, so it",
+                            "never enters this balance — that is exactly the donation the shadow must",
+                            "not see. Consumed by the per-period revenue-settle APR cap in",
+                            "`settle_revenue_to_insurance_fund`, sized off `min(live_if_vault, this)`,",
+                            "so a donation spiked into the live vault right before a settle cannot",
+                            "inflate the cap while legitimate stakes and real settled revenue (which",
+                            "this balance tracks) still do. (The unstake-cancel share forfeiture is",
+                            "donation-proofed differently — by withdraw-and-restake at the active share",
+                            "price — and does *not* read this field.) Repurposed from trailing padding —",
+                            "layout/size unchanged; `0` means \"uninitialized\" (existing account",
+                            "pre-upgrade, or an accounted balance legitimately drained to empty — an",
+                            "empty IF vault has no user shares, so this is safe), and is seeded from the",
+                            "live balance on the next add/settle and treated as \"fall back to live\" by",
+                            "the consumers."
+                        ],
+                        "type": "u64"
                     }
                 ]
             }

package/lib/node/math/liquidation.d.ts

@@ -85,6 +85,37 @@ export declare function calculatePerpIfFee(marginShortage: BN, userBaseAssetAmou
  *   `liabilityLiquidationMultiplier` is zero.
  */
 export declare function calculateSpotIfFee(marginShortage: BN, tokenAmount: BN, assetWeight: number, assetLiquidationMultiplier: number, liabilityWeight: number, liabilityLiquidationMultiplier: number, liabilityDecimals: number, liabilityPrice: BN, maxIfFee: number): number;
+/**
+ * User-protective price at which a collateral (deposit) asset is seized when its oracle is
+ * margin-invalid (`StaleForMargin`/`TooUncertain`) but still acceptable for
+ * `VelocityAction::Liquidate`, mirroring `calculate_user_protective_asset_price` in
+ * `programs/velocity/src/math/liquidation.rs`. The program sizes the asset-conversion leg
+ * of spot and pnl-vs-spot liquidations (and the swap-liquidation worst-case price) with this
+ * instead of the raw oracle price whenever the deposit oracle fails the margin-calc validity
+ * gate — a stale or uncertain oracle can make an account liquidatable but cannot cheapen its
+ * collateral. Pass the result as `assetPrice` to `calculateAssetTransferForLiabilityTransfer`
+ * to predict on-chain transfer amounts in that case.
+ * @param oraclePrice Raw oracle price of the asset, PRICE_PRECISION (1e6).
+ * @param oracleConfidence Oracle confidence interval, PRICE_PRECISION (1e6).
+ * @param lastOraclePriceTwap5Min The asset spot market's `historicalOracleData.lastOraclePriceTwap5Min`, PRICE_PRECISION (1e6).
+ * @returns `max(oraclePrice, lastOraclePriceTwap5Min, oraclePrice + oracleConfidence)`, PRICE_PRECISION (1e6).
+ */
+export declare function calculateUserProtectiveAssetPrice(oraclePrice: BN, oracleConfidence: BN, lastOraclePriceTwap5Min: BN): BN;
+/**
+ * Liability-side counterpart of `calculateUserProtectiveAssetPrice`, mirroring
+ * `calculate_user_protective_liability_price` in
+ * `programs/velocity/src/math/liquidation.rs`. When the borrow (liability) oracle is
+ * margin-invalid, the program prices the repayment leg of spot and pnl-vs-spot liquidations
+ * (and the swap-liquidation worst-case price) at this instead of the raw oracle price, so an
+ * inflated stale/uncertain debt price cannot cheapen the collateral (or pnl) exchanged for
+ * it. Pass the result as `liabilityPrice` to `calculateAssetTransferForLiabilityTransfer` to
+ * predict on-chain transfer amounts in that case.
+ * @param oraclePrice Raw oracle price of the liability, PRICE_PRECISION (1e6).
+ * @param oracleConfidence Oracle confidence interval, PRICE_PRECISION (1e6).
+ * @param lastOraclePriceTwap5Min The liability spot market's `historicalOracleData.lastOraclePriceTwap5Min`, PRICE_PRECISION (1e6).
+ * @returns `min(oraclePrice, lastOraclePriceTwap5Min, oraclePrice - oracleConfidence)`, floored at 1, PRICE_PRECISION (1e6).
+ */
+export declare function calculateUserProtectiveLiabilityPrice(oraclePrice: BN, oracleConfidence: BN, lastOraclePriceTwap5Min: BN): BN;
 /**
  * Calculates how much of a liquidated user's collateral asset a liquidator receives in
  * exchange for repaying `liabilityAmount` of a liability, mirroring
@@ -97,11 +128,15 @@ export declare function calculateSpotIfFee(marginShortage: BN, tokenAmount: BN,
  * @param assetAmount User's available balance of the asset being transferred, asset spot market's own token precision.
  * @param assetLiquidationMultiplier Liquidation-time discount multiplier on the asset side, LIQUIDATION_FEE_PRECISION (1e6).
  * @param assetDecimals Asset spot market's token decimals.
- * @param assetPrice Oracle price of the asset, PRICE_PRECISION (1e6).
+ * @param assetPrice Oracle price of the asset, PRICE_PRECISION (1e6). When the asset oracle
+ *   is margin-invalid, the program prices the seizure protectively — pass
+ *   `calculateUserProtectiveAssetPrice(...)` instead of the raw oracle price to match.
  * @param liabilityAmount Liability amount being repaid, liability spot market's own token precision.
  * @param liabilityLiquidationMultiplier Liquidation-time premium multiplier on the liability side, LIQUIDATION_FEE_PRECISION (1e6).
  * @param liabilityDecimals Liability spot market's token decimals.
- * @param liabilityPrice Oracle price of the liability asset, PRICE_PRECISION (1e6).
+ * @param liabilityPrice Oracle price of the liability asset, PRICE_PRECISION (1e6). When the
+ *   liability oracle is margin-invalid, the program prices the repayment protectively — pass
+ *   `calculateUserProtectiveLiabilityPrice(...)` instead of the raw oracle price to match.
  * @returns Asset amount to transfer to the liquidator, asset spot market's own token precision (floored at 1).
  */
 export declare function calculateAssetTransferForLiabilityTransfer(assetAmount: BN, assetLiquidationMultiplier: number, assetDecimals: number, assetPrice: BN, liabilityAmount: BN, liabilityLiquidationMultiplier: number, liabilityDecimals: number, liabilityPrice: BN): BN | undefined;

package/lib/node/math/liquidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"liquidation.d.ts","sourceRoot":"","sources":["../../../src/math/liquidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAe1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6CAA6C,CAC5D,cAAc,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,EAAE,EACf,gBAAgB,EAAE,EAAE,GAClB,EAAE,GAAG,SAAS,CAqBhB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,+CAA+C,CAC9D,cAAc,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,0BAA0B,EAAE,MAAM,EAClC,eAAe,EAAE,MAAM,EACvB,8BAA8B,EAAE,MAAM,EACtC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,EAAE,EAClB,gBAAgB,EAAE,MAAM,GACtB,EAAE,GAAG,SAAS,CA8ChB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CACjC,cAAc,EAAE,EAAE,EAClB,mBAAmB,EAAE,EAAE,EACvB,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,EAAE,EACf,gBAAgB,EAAE,EAAE,EACpB,mBAAmB,EAAE,MAAM,GACzB,MAAM,CAgCR;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CACjC,cAAc,EAAE,EAAE,EAClB,WAAW,EAAE,EAAE,EACf,WAAW,EAAE,MAAM,EACnB,0BAA0B,EAAE,MAAM,EAClC,eAAe,EAAE,MAAM,EACvB,8BAA8B,EAAE,MAAM,EACtC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,EAAE,EAClB,QAAQ,EAAE,MAAM,GACd,MAAM,CAuCR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0CAA0C,CACzD,WAAW,EAAE,EAAE,EACf,0BAA0B,EAAE,MAAM,EAClC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,EAAE,EACd,eAAe,EAAE,EAAE,EACnB,8BAA8B,EAAE,MAAM,EACtC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,EAAE,GAChB,EAAE,GAAG,SAAS,CAkDhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACzC,kBAAkB,EAAE,EAAE,EACtB,0BAA0B,EAAE,EAAE,EAC9B,cAAc,EAAE,EAAE,EAClB,IAAI,EAAE,EAAE,EACR,qBAAqB,EAAE,EAAE,EACzB,mBAAmB,EAAE,EAAE,EACvB,kBAAkB,UAAQ,GACxB,EAAE,CA+BJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,sCAAsC,EAAE,EAAE,EAC1C,0BAA0B,EAAE,EAAE,GAC5B,EAAE,CAIJ"}
+{"version":3,"file":"liquidation.d.ts","sourceRoot":"","sources":["../../../src/math/liquidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAe1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6CAA6C,CAC5D,cAAc,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,EAAE,EACf,gBAAgB,EAAE,EAAE,GAClB,EAAE,GAAG,SAAS,CAqBhB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,+CAA+C,CAC9D,cAAc,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,0BAA0B,EAAE,MAAM,EAClC,eAAe,EAAE,MAAM,EACvB,8BAA8B,EAAE,MAAM,EACtC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,EAAE,EAClB,gBAAgB,EAAE,MAAM,GACtB,EAAE,GAAG,SAAS,CA8ChB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CACjC,cAAc,EAAE,EAAE,EAClB,mBAAmB,EAAE,EAAE,EACvB,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,EAAE,EACf,gBAAgB,EAAE,EAAE,EACpB,mBAAmB,EAAE,MAAM,GACzB,MAAM,CAgCR;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CACjC,cAAc,EAAE,EAAE,EAClB,WAAW,EAAE,EAAE,EACf,WAAW,EAAE,MAAM,EACnB,0BAA0B,EAAE,MAAM,EAClC,eAAe,EAAE,MAAM,EACvB,8BAA8B,EAAE,MAAM,EACtC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,EAAE,EAClB,QAAQ,EAAE,MAAM,GACd,MAAM,CAuCR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iCAAiC,CAChD,WAAW,EAAE,EAAE,EACf,gBAAgB,EAAE,EAAE,EACpB,uBAAuB,EAAE,EAAE,GACzB,EAAE,CAKJ;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qCAAqC,CACpD,WAAW,EAAE,EAAE,EACf,gBAAgB,EAAE,EAAE,EACpB,uBAAuB,EAAE,EAAE,GACzB,EAAE,CAQJ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0CAA0C,CACzD,WAAW,EAAE,EAAE,EACf,0BAA0B,EAAE,MAAM,EAClC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,EAAE,EACd,eAAe,EAAE,EAAE,EACnB,8BAA8B,EAAE,MAAM,EACtC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,EAAE,GAChB,EAAE,GAAG,SAAS,CAkDhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACzC,kBAAkB,EAAE,EAAE,EACtB,0BAA0B,EAAE,EAAE,EAC9B,cAAc,EAAE,EAAE,EAClB,IAAI,EAAE,EAAE,EACR,qBAAqB,EAAE,EAAE,EACzB,mBAAmB,EAAE,EAAE,EACvB,kBAAkB,UAAQ,GACxB,EAAE,CA+BJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,sCAAsC,EAAE,EAAE,EAC1C,0BAA0B,EAAE,EAAE,GAC5B,EAAE,CAIJ"}

package/lib/node/math/liquidation.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMarginShortage = exports.calculateMaxPctToLiquidate = exports.calculateAssetTransferForLiabilityTransfer = exports.calculateSpotIfFee = exports.calculatePerpIfFee = exports.calculateLiabilityTransferToCoverMarginShortage = exports.calculateBaseAssetAmountToCoverMarginShortage = void 0;
+exports.getMarginShortage = exports.calculateMaxPctToLiquidate = exports.calculateAssetTransferForLiabilityTransfer = exports.calculateUserProtectiveLiabilityPrice = exports.calculateUserProtectiveAssetPrice = exports.calculateSpotIfFee = exports.calculatePerpIfFee = exports.calculateLiabilityTransferToCoverMarginShortage = exports.calculateBaseAssetAmountToCoverMarginShortage = void 0;
 const anchor_1 = require("../isomorphic/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 /**
@@ -188,6 +188,43 @@ function calculateSpotIfFee(marginShortage, tokenAmount, assetWeight, assetLiqui
     return anchor_1.BN.min(new anchor_1.BN(maxIfFee), impliedIfFee).toNumber();
 }
 exports.calculateSpotIfFee = calculateSpotIfFee;
+/**
+ * User-protective price at which a collateral (deposit) asset is seized when its oracle is
+ * margin-invalid (`StaleForMargin`/`TooUncertain`) but still acceptable for
+ * `VelocityAction::Liquidate`, mirroring `calculate_user_protective_asset_price` in
+ * `programs/velocity/src/math/liquidation.rs`. The program sizes the asset-conversion leg
+ * of spot and pnl-vs-spot liquidations (and the swap-liquidation worst-case price) with this
+ * instead of the raw oracle price whenever the deposit oracle fails the margin-calc validity
+ * gate — a stale or uncertain oracle can make an account liquidatable but cannot cheapen its
+ * collateral. Pass the result as `assetPrice` to `calculateAssetTransferForLiabilityTransfer`
+ * to predict on-chain transfer amounts in that case.
+ * @param oraclePrice Raw oracle price of the asset, PRICE_PRECISION (1e6).
+ * @param oracleConfidence Oracle confidence interval, PRICE_PRECISION (1e6).
+ * @param lastOraclePriceTwap5Min The asset spot market's `historicalOracleData.lastOraclePriceTwap5Min`, PRICE_PRECISION (1e6).
+ * @returns `max(oraclePrice, lastOraclePriceTwap5Min, oraclePrice + oracleConfidence)`, PRICE_PRECISION (1e6).
+ */
+function calculateUserProtectiveAssetPrice(oraclePrice, oracleConfidence, lastOraclePriceTwap5Min) {
+    return anchor_1.BN.max(anchor_1.BN.max(oraclePrice, lastOraclePriceTwap5Min), oraclePrice.add(oracleConfidence));
+}
+exports.calculateUserProtectiveAssetPrice = calculateUserProtectiveAssetPrice;
+/**
+ * Liability-side counterpart of `calculateUserProtectiveAssetPrice`, mirroring
+ * `calculate_user_protective_liability_price` in
+ * `programs/velocity/src/math/liquidation.rs`. When the borrow (liability) oracle is
+ * margin-invalid, the program prices the repayment leg of spot and pnl-vs-spot liquidations
+ * (and the swap-liquidation worst-case price) at this instead of the raw oracle price, so an
+ * inflated stale/uncertain debt price cannot cheapen the collateral (or pnl) exchanged for
+ * it. Pass the result as `liabilityPrice` to `calculateAssetTransferForLiabilityTransfer` to
+ * predict on-chain transfer amounts in that case.
+ * @param oraclePrice Raw oracle price of the liability, PRICE_PRECISION (1e6).
+ * @param oracleConfidence Oracle confidence interval, PRICE_PRECISION (1e6).
+ * @param lastOraclePriceTwap5Min The liability spot market's `historicalOracleData.lastOraclePriceTwap5Min`, PRICE_PRECISION (1e6).
+ * @returns `min(oraclePrice, lastOraclePriceTwap5Min, oraclePrice - oracleConfidence)`, floored at 1, PRICE_PRECISION (1e6).
+ */
+function calculateUserProtectiveLiabilityPrice(oraclePrice, oracleConfidence, lastOraclePriceTwap5Min) {
+    return anchor_1.BN.max(anchor_1.BN.min(anchor_1.BN.min(oraclePrice, lastOraclePriceTwap5Min), oraclePrice.sub(oracleConfidence)), numericConstants_1.ONE);
+}
+exports.calculateUserProtectiveLiabilityPrice = calculateUserProtectiveLiabilityPrice;
 /**
  * Calculates how much of a liquidated user's collateral asset a liquidator receives in
  * exchange for repaying `liabilityAmount` of a liability, mirroring
@@ -200,11 +237,15 @@ exports.calculateSpotIfFee = calculateSpotIfFee;
  * @param assetAmount User's available balance of the asset being transferred, asset spot market's own token precision.
  * @param assetLiquidationMultiplier Liquidation-time discount multiplier on the asset side, LIQUIDATION_FEE_PRECISION (1e6).
  * @param assetDecimals Asset spot market's token decimals.
- * @param assetPrice Oracle price of the asset, PRICE_PRECISION (1e6).
+ * @param assetPrice Oracle price of the asset, PRICE_PRECISION (1e6). When the asset oracle
+ *   is margin-invalid, the program prices the seizure protectively — pass
+ *   `calculateUserProtectiveAssetPrice(...)` instead of the raw oracle price to match.
  * @param liabilityAmount Liability amount being repaid, liability spot market's own token precision.
  * @param liabilityLiquidationMultiplier Liquidation-time premium multiplier on the liability side, LIQUIDATION_FEE_PRECISION (1e6).
  * @param liabilityDecimals Liability spot market's token decimals.
- * @param liabilityPrice Oracle price of the liability asset, PRICE_PRECISION (1e6).
+ * @param liabilityPrice Oracle price of the liability asset, PRICE_PRECISION (1e6). When the
+ *   liability oracle is margin-invalid, the program prices the repayment protectively — pass
+ *   `calculateUserProtectiveLiabilityPrice(...)` instead of the raw oracle price to match.
  * @returns Asset amount to transfer to the liquidator, asset spot market's own token precision (floored at 1).
  */
 function calculateAssetTransferForLiabilityTransfer(assetAmount, assetLiquidationMultiplier, assetDecimals, assetPrice, liabilityAmount, liabilityLiquidationMultiplier, liabilityDecimals, liabilityPrice) {

package/lib/node/math/spotBalance.d.ts

@@ -241,6 +241,19 @@ export declare function calculateWithdrawLimit(spotMarket: SpotMarketAccount, no
     currentDepositAmount: BN;
     currentBorrowAmount: BN;
 };
+/**
+ * Mirror of the program's `calculate_max_deposit_token_amount`. Returns the max
+ * resulting deposit token amount permitted by the daily deposit cap: growth up
+ * to `maxDepositBpsPerDay` above the 24h deposit TWAP, but never below the
+ * deposit guard threshold. Returns null when the cap is disabled (pct == 0).
+ */
+export declare function calculateMaxDepositTokenAmount(depositTokenTwap: BN, depositGuardThreshold: BN, maxDepositBpsPerDay: number): BN | null;
+/**
+ * Mirror of the program's `check_deposit_limits`. Returns true if the market's
+ * current deposit level is within the daily deposit cap (always true when the
+ * cap is disabled).
+ */
+export declare function checkDepositLimits(spotMarket: SpotMarketAccount): boolean;
 /**
  * Calculates the margin-weighted value of a spot deposit, mirroring the asset-side of the
  * program's collateral valuation (`get_strict_token_value` + `get_asset_weight`). Uses the

package/lib/node/math/spotBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spotBalance.d.ts","sourceRoot":"","sources":["../../../src/math/spotBalance.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"spotBalance.d.ts","sourceRoot":"","sources":["../../../src/math/spotBalance.ts"],"names":[],"mappings":"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"}

package/lib/node/math/spotBalance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSpotLiabilityValue = exports.getSpotAssetValue = exports.calculateWithdrawLimit = exports.calculateTokenUtilizationLimits = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateScaledInitialAssetWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+exports.getSpotLiabilityValue = exports.getSpotAssetValue = exports.checkDepositLimits = exports.calculateMaxDepositTokenAmount = exports.calculateWithdrawLimit = exports.calculateTokenUtilizationLimits = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateScaledInitialAssetWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("../isomorphic/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
@@ -571,7 +571,14 @@ function calculateWithdrawLimit(spotMarket, now) {
     else {
         maxBorrowTokensTwap = anchor_1.BN.max(spotMarket.withdrawGuardThreshold, anchor_1.BN.min(anchor_1.BN.max(lesserDepositAmount.div(new anchor_1.BN(2)), borrowTokenTwapLive.add(lesserDepositAmount.div(new anchor_1.BN(3)))), lesserDepositAmount.sub(lesserDepositAmount.div(new anchor_1.BN(20))))); // isolated pools between 50-95% utilization with friction on twap in 33% increments
     }
-    const minDepositTokensTwap = depositTokenTwapLive.sub(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(4)), anchor_1.BN.min(spotMarket.withdrawGuardThreshold, depositTokenTwapLive)));
+    // 0 is treated as the default 25% (2500 bps) so markets created before the
+    // field existed keep prior behavior (mirrors calculate_min_deposit_token_amount).
+    // withdrawCircuitBreakerBps is in basis points (BPS_PRECISION = 10_000 = 100%).
+    const breakerPct = spotMarket.withdrawCircuitBreakerBps === 0
+        ? numericConstants_2.BPS_PRECISION.divn(4)
+        : new anchor_1.BN(spotMarket.withdrawCircuitBreakerBps);
+    const maxDrop = depositTokenTwapLive.mul(breakerPct).div(numericConstants_2.BPS_PRECISION);
+    const minDepositTokensTwap = depositTokenTwapLive.sub(anchor_1.BN.max(maxDrop, anchor_1.BN.min(spotMarket.withdrawGuardThreshold, depositTokenTwapLive)));
     const { minDepositTokensForUtilization, maxBorrowTokensForUtilization } = calculateTokenUtilizationLimits(marketDepositTokenAmount, marketBorrowTokenAmount, spotMarket);
     const minDepositTokens = anchor_1.BN.max(minDepositTokensForUtilization, minDepositTokensTwap);
     let maxBorrowTokens = anchor_1.BN.min(maxBorrowTokensForUtilization, maxBorrowTokensTwap);
@@ -599,6 +606,40 @@ function calculateWithdrawLimit(spotMarket, now) {
     };
 }
 exports.calculateWithdrawLimit = calculateWithdrawLimit;
+/**
+ * Mirror of the program's `calculate_max_deposit_token_amount`. Returns the max
+ * resulting deposit token amount permitted by the daily deposit cap: growth up
+ * to `maxDepositBpsPerDay` above the 24h deposit TWAP, but never below the
+ * deposit guard threshold. Returns null when the cap is disabled (pct == 0).
+ */
+function calculateMaxDepositTokenAmount(depositTokenTwap, depositGuardThreshold, maxDepositBpsPerDay) {
+    if (maxDepositBpsPerDay === 0) {
+        return null; // disabled
+    }
+    // maxDepositBpsPerDay is in basis points (BPS_PRECISION = 10_000 = 100%).
+    const maxIncrease = depositTokenTwap
+        .mul(new anchor_1.BN(maxDepositBpsPerDay))
+        .div(numericConstants_2.BPS_PRECISION);
+    return anchor_1.BN.max(depositTokenTwap.add(maxIncrease), depositGuardThreshold);
+}
+exports.calculateMaxDepositTokenAmount = calculateMaxDepositTokenAmount;
+/**
+ * Mirror of the program's `check_deposit_limits`. Returns true if the market's
+ * current deposit level is within the daily deposit cap (always true when the
+ * cap is disabled).
+ */
+function checkDepositLimits(spotMarket) {
+    if (spotMarket.maxDepositBpsPerDay === 0) {
+        return true;
+    }
+    const depositTokenAmount = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const maxDepositToken = calculateMaxDepositTokenAmount(spotMarket.depositTokenTwap, spotMarket.depositGuardThreshold, spotMarket.maxDepositBpsPerDay);
+    if (maxDepositToken === null) {
+        return true;
+    }
+    return depositTokenAmount.lte(maxDepositToken);
+}
+exports.checkDepositLimits = checkDepositLimits;
 /**
  * Calculates the margin-weighted value of a spot deposit, mirroring the asset-side of the
  * program's collateral valuation (`get_strict_token_value` + `get_asset_weight`). Uses the

package/lib/node/types.d.ts

@@ -1207,6 +1207,8 @@ export type PerpMarketAccount = {
     feePoolBufferTarget: BN;
     /** PERCENTAGE_PRECISION (1e6 = 100%); fraction of OI notional (at the oracle TWAP) the sweep leaves behind in `feeLedger.pendingIfFee` as a standing bankruptcy first-loss tranche; 0 disables */
     bankruptcyIfFloorPct: number;
+    /** QUOTE_PRECISION (1e6); aggregate builder/referrer revenue share accrued but not yet paid out of this market's pnl pool. The fee sweep reserves it (like `max(net_user_pnl, 0)` and the floored IF tranche) so a protocol-fee drain can't leave accrued revenue-share claims temporarily unpayable */
+    pendingRevenueShare: BN;
     /** MARGIN_PRECISION (1e4); scales margin ratio up for large positions */
     imfFactor: number;
     /** MARGIN_PRECISION (1e4); discounts positive-unrealized-pnl asset weight for large positions */
@@ -1357,6 +1359,10 @@ export type SpotMarketAccount = {
     protocolLiquidationFee: number;
     /** IF_FACTOR_PRECISION (1e6); protocol's carveout of lending deposit-interest gains */
     protocolFeeFactor: number;
+    /** token mint precision; IF vault balance recorded at the last revenue settle, used as a
+     * donation-proof base for the per-period revenue-settle APR cap (see `settle_revenue_to_insurance_fund`);
+     * `0` = uninitialized (pre-upgrade accounts, seeded on first settle) */
+    ifLastSettleVaultAmount: BN;
     /** token mint decimals; token-mint precision throughout this account is 10^decimals */
     decimals: number;
     /** SPOT_UTILIZATION_PRECISION (1e6) */
@@ -1439,6 +1445,9 @@ export type SpotMarketAccount = {
     poolId: number;
     /** -100 to 100; percentage adjustment applied to the base fee rate */
     feeAdjustment: number;
+    depositGuardThreshold: BN;
+    withdrawCircuitBreakerBps: number;
+    maxDepositBpsPerDay: number;
 };
 /** A scaled token balance inside a market's internal pools (pnl pool, protocol fee pool, revenue pool, spot fee pool, AMM fee pool). Multiply `scaledBalance` (SPOT_BALANCE_PRECISION, 1e9) by the referenced spot market's `cumulativeDepositInterest`/`cumulativeBorrowInterest` to get the token amount. */
 export type PoolBalance = {