@raac/rpc 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/types/pools/stabilityPool/liquidation.d.ts

@@ -1,13 +1,14 @@
 /**
- * Liquidation simulation for StabilityPool.liquidateBorrower, mirroring LiquidationStrategyProxy:
+ * Planning StabilityPool.liquidateBorrower, mirroring LiquidationStrategyProxy:
  *   1. the seized collateral is deposited into the RWAVault for vault-token shares, unless it already is the vault token;
  *   2. the stability pool's whole vault-token balance (the proxy runs under delegatecall) is split by BPS into
- *      mint (treasury fee), burn, swap and liquidity (fee collector);
- *   3. only the swap slice becomes crvUSD, through LiquidationSwap and its Curve pool;
- *   3b. LiquidationSwap reverts when slippage protection is on and get_dy falls below pricePerShare / oracle price
- *       less its tolerance, which is the case when Curve trades below the vault's value;
- *   4. the crvUSD must cover the position's debt; any shortfall is withdrawn from the LendingPool with the pool's
- *      rTokens, so stability pool depositors pay it, and the call reverts (InsufficientBalance) if they hold too few.
+ *      mint (treasury), burn, swap and liquidity (fee collector);
+ *   3. the swap slice is sold on Curve through LiquidationSwap, whose floor is the vault's NAV less a tolerance;
+ *   4. the reserve asset the pool then holds (swap proceeds plus whatever it held before) repays the debt; a shortfall
+ *      is drawn from the pool's rTokens through the LendingPool, and the call reverts (InsufficientBalance) if too few.
+ *
+ * The plan sizes the swap on Curve's get_dy and values every other leg at NAV. Any gap between the swap and the debt
+ * is reserve asset the Treasury sends to the pool beforehand, and the unsold vault tokens go to the Treasury for it.
  */
 import { type Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
@@ -21,29 +22,71 @@ export interface LiquidationSplit {
 export declare const SPLIT_KEYS: readonly ["mintBps", "burnBps", "swapBps", "liquidityBps"];
 export declare const splitTotal: (s: LiquidationSplit) => bigint;
 export declare const sameSplit: (a: LiquidationSplit, b: LiquidationSplit) => boolean;
-/** The stability pool's liquidation route, read once per review. */
+/** The stability pool's liquidation route and everything on chain that decides how a liquidation can go, at one block. */
 export interface LiquidationContext {
     stabilityPool: string;
+    lendingPool: string;
     liquidationSwap: string;
     liquidityPool: string;
     rwaVault: string;
+    treasury: string;
+    feeCollector: string;
     vaultToken: string;
     vaultSymbol: string;
+    /** The reserve asset the debt is in (crvUSD or pmUSD) and the pool's rToken for it. */
+    reserveAsset: string;
+    rToken: string;
     iIn: bigint;
     iOut: bigint;
     split: LiquidationSplit;
     /** Vault tokens already in the stability pool; the split divides these too. */
     poolVaultTokens: bigint;
-    /** rTokens the stability pool holds, which is the most a swap shortfall can draw from the LendingPool. */
+    /** Reserve asset the stability pool holds; the proxy counts it toward the debt before drawing on rTokens. */
+    poolReserve: bigint;
+    /** rTokens the stability pool holds, which is the most a shortfall can draw from the LendingPool. */
     rTokens: bigint;
-    /** LendingPool grace period, in seconds, before an insured position can be finalized. */
-    gracePeriod: number;
-    /** LiquidationSwap's own floor: null when protection is off, else pricePerShare / oracle price less its tolerance. */
-    slippage: {
-        bps: bigint;
+    /** What depositors are owed; above the rTokens held, the pool is under-backed by the difference. */
+    deTokenSupply: bigint;
+    /** Reserve asset the LendingPool can pay out now: the rToken contract's buffer plus what its yield vault lets it withdraw (null when that read is unavailable). */
+    idleCash: {
+        buffer: bigint;
+        vaultWithdrawable: bigint | null;
+    };
+    /** The LendingPool's accounting the buffer rebalance after repayment works from: total liquidity, the buffer ratio it keeps, and the smallest rebalance it bothers with. */
+    lendingPoolLiquidity: {
+        total: bigint;
+        bufferRatioBps: bigint;
+        minRebalance: bigint;
+    };
+    /** Curve: get_dy for one vault token, the reserve asset side's balance, and the pool's current fee in bps. */
+    curve: {
+        spot: bigint;
+        depth: bigint;
+        feeBps: bigint;
+    };
+    /** NAV: the vault's price per share in USD and the oracle's USD price of the reserve asset, both 1e18; `priceTimestamp` when the oracle reports one. */
+    nav: {
         pricePerShare: bigint;
         oraclePrice: bigint;
-    } | null;
+        priceTimestamp: number | null;
+    };
+    /** Vault tokens in existence: the burn leg runs before the swap and raises the price per share the floor is computed from. */
+    vaultTokenSupply: bigint;
+    /** LiquidationSwap's floor: when on, the swap must return at least NAV less `bps`. `owner` can change it. */
+    floor: {
+        enabled: boolean;
+        bps: bigint;
+        owner: string;
+    };
+    /** The liquidity leg reverts while the FeeCollector is paused or its fee type is not registered. */
+    feeCollectorState: {
+        paused: boolean;
+        liquidityFeeTypeRegistered: boolean;
+    };
+    /** The Treasury leg deposits vault tokens into the Treasury contract, which must list them. */
+    treasurySupportsVaultToken: boolean;
+    /** LendingPool grace period, in seconds, before an insured position can be finalized. */
+    gracePeriod: number;
 }
 /** Everything liquidateBorrower needs for one position, plus its state on chain. */
 export interface LiquidationTarget {
@@ -57,56 +100,127 @@ export interface LiquidationTarget {
     /** The collateral already is the vault token, so no RWAVault deposit happens. */
     isVaultToken: boolean;
     collateralValue: bigint;
+    /** Vault tokens this liquidation adds: shares minted for the collateral, or the collateral itself. */
+    sharesFromCollateral: bigint;
     /** getPositionScaledDebt: the debt with accrued interest, which is what the liquidation repays. */
     debt: bigint;
     isUnderLiquidation: boolean;
     isInsured: boolean;
     liquidationStartTime: number;
 }
-export interface LiquidationQuote {
-    split: LiquidationSplit;
-    /** Vault tokens this liquidation adds: shares minted for the collateral, or the collateral itself. */
-    sharesFromCollateral: bigint;
-    /** sharesFromCollateral plus the pool's existing balance: what the split divides. */
+/** The operator's policy, all in basis points. */
+export interface PlanParams {
+    /** Share burned. */
+    burnBps: bigint;
+    /** The Treasury's base fee, before any gap it funds. */
+    treasuryBps: bigint;
+    /** The most the liquidity leg gets once the Treasury funds a gap; without a gap it takes the whole remainder. */
+    liquidityCapBps: bigint;
+    /** The swap stops growing once its realised rate falls this far below Curve's spot rate. */
+    impactCapBps: bigint;
+    /** The highest floor tolerance the plan may propose setting on LiquidationSwap. */
+    toleranceCeilingBps: bigint;
+    /** Added to the tolerance the swap needs when one is proposed, against drift between the quote and execution; the swap is sized so that needed plus cushion stays under the ceiling. */
+    toleranceCushionBps: bigint;
+    /** Added to the debt, since it accrues until the transaction executes. */
+    marginBps: bigint;
+}
+export declare const DEFAULT_PLAN_PARAMS: PlanParams;
+/** DeFi sells on Curve as much as the debt needs; OTC sells nothing and the Treasury funds the whole debt. */
+export type PlanMode = "defi" | "otc";
+/** What stopped the swap growing: the debt is covered, the impact cap, the floor at the tolerance ceiling, the whole balance, or the mode. */
+export type SwapBound = "debt" | "impact" | "floor" | "balance" | "mode";
+export type PlanRoute = "covered" | "partial" | "otc";
+export interface LiquidationPlan {
+    mode: PlanMode;
+    params: PlanParams;
+    /** What the split divides: the shares for the collateral plus the pool's existing vault tokens. */
     totalVaultTokens: bigint;
+    /** The debt plus the margin. */
+    required: bigint;
+    /** `required` less the reserve asset the pool already holds: what the swap and the Treasury must bring. */
+    toCover: bigint;
     swapAmount: bigint;
-    /** get_dy from the deployed Curve pool; null when the quote reverted. */
-    swapOut: bigint | null;
-    /** LiquidationSwap's minimum output for swapAmount; null when its slippage protection is off. */
-    minSwapOut: bigint | null;
-    /** Debt the swap does not cover, drawn from depositors' rTokens; the whole debt when the quote reverted. */
-    shortfall: bigint;
-    coversDebt: boolean;
-    /** The collateral is worth less than the debt, so depositors lose whatever the split. */
-    badDebt: bigint;
-    /** get_dy for the whole balance: the most any split can recover. */
-    maxSwapOut: bigint | null;
-    /** How far the realised swap rate falls below the spot rate, in basis points. */
-    priceImpactBps: bigint | null;
-    /** The crvUSD side of the Curve pool; the swap can never return more. */
-    poolReserveOut: bigint | null;
-}
-export interface SuggestedSplit extends LiquidationSplit {
-    projectedOut: bigint;
-    /** No split covers the debt; this is the best effort (100% swap). */
-    bestEffort: boolean;
+    /** get_dy for `swapAmount`. */
+    swapOut: bigint;
+    /** How far the swap's realised rate falls below Curve's spot rate. */
+    priceImpactBps: bigint;
+    /** The floor tolerance this swap needs: get_dy against NAV as it stands after the burn leg. */
+    toleranceNeededBps: bigint;
+    /** The tolerance to set on LiquidationSwap before the swap, the need plus the cushion; null when the current one suffices or nothing is swapped. */
+    proposedToleranceBps: bigint | null;
+    bound: SwapBound;
+    /** The largest swap at the tolerance on chain, at the ceiling less the cushion, and under the impact cap. */
+    ceilings: {
+        atCurrent: bigint;
+        atCeiling: bigint;
+        underImpact: bigint;
+    };
+    split: LiquidationSplit;
+    /** Each leg in vault tokens, computed the way the proxy does. */
+    legs: {
+        swap: bigint;
+        burn: bigint;
+        treasury: bigint;
+        liquidity: bigint;
+    };
+    /** Reserve asset the Treasury must send to the stability pool before the liquidation. */
+    gap: bigint;
+    /** The Treasury's vault tokens at NAV, and that less the gap it funds: negative means a loss. */
+    treasuryValue: bigint;
+    treasuryNet: bigint;
+    /** The liquidity leg was held to the cap, or set to zero because the FeeCollector would revert. */
+    liquidityCapped: boolean;
+    liquidityDisabled: boolean;
+    route: PlanRoute;
+    /**
+     * The alternative for a gap: the pool's rTokens cover it through the LendingPool. Feasible when the pool holds
+     * enough rTokens and the LendingPool enough idle cash; null when the idle cash is unknown. `inject` is the reserve
+     * asset to send to the rToken contract so the withdrawal clears when the idle cash falls short.
+     */
+    absorb: {
+        feasible: boolean | null;
+        rTokensAfter: bigint;
+        inject: bigint;
+    };
+    /**
+     * The LendingPool rebalances its buffer when the debt is written off, before the repayment reaches it, so it wants
+     * `shortage` more in the buffer and takes it from the yield vault. A build that rebalances strictly (Sepolia)
+     * reverts when the vault cannot give that much; `inject` is the reserve asset to send to the rToken contract first:
+     * the whole shortage, since harvesting yield inside the rebalance lowers what the vault then allows.
+     */
+    rebalance: {
+        shortage: bigint;
+        feasible: boolean | null;
+        inject: bigint;
+    };
 }
-/** Reads the stability pool's liquidation route, split, balances and the LendingPool grace period. */
+/** get_dy for an amount of vault tokens; null when Curve reverts. */
+export type Quote = (amount: bigint) => Promise<bigint | null>;
+/** Reads the stability pool's liquidation route, balances, Curve, NAV, floor and leg prerequisites at one block. */
 export declare function readLiquidationContext(chainId: ChainId, provider: Provider): Promise<LiquidationContext>;
 /** Assembles liquidateBorrower's arguments and the position's state for one position id ("user:adapter:key"). */
 export declare function readLiquidationTarget(chainId: ChainId, provider: Provider, ctx: LiquidationContext, positionId: string): Promise<LiquidationTarget>;
-/** Prices the liquidation with `split`, using the deployed Curve pool's get_dy rather than the vault's oracle price. */
-export declare function quoteLiquidation(provider: Provider, ctx: LiquidationContext, target: LiquidationTarget, split: LiquidationSplit): Promise<LiquidationQuote>;
+/** get_dy on the context's Curve pool. */
+export declare const curveQuote: (provider: Provider, ctx: LiquidationContext) => Quote;
+/** Reserve asset that `shares` vault tokens are worth at NAV, as LiquidationSwap computes its expected output. */
+export declare const valueAtNav: (ctx: Pick<LiquidationContext, "nav">, shares: bigint) => bigint;
+/** Vault tokens worth `value` of reserve asset at NAV, rounded up. */
+export declare const sharesAtNav: (ctx: Pick<LiquidationContext, "nav">, value: bigint) => bigint;
 /**
- * The smallest swap share whose get_dy still covers the debt plus `bufferBps`, with the rest given back to mint,
- * burn and liquidity in their current proportion. get_dy grows with dx, so a binary search over BPS is sound.
+ * The floor tolerance a swap of `amount` returning `out` needs: how far `out` falls below NAV, in bps, rounded up.
+ * The proxy burns the burn leg before it swaps, which lifts the vault's price per share by the burned share of the
+ * supply, so the floor LiquidationSwap applies is computed on that higher NAV; `burned` accounts for it.
  */
-export declare function suggestSplit(provider: Provider, ctx: LiquidationContext, target: LiquidationTarget, quote: LiquidationQuote, bufferBps?: bigint): Promise<SuggestedSplit | null>;
-/** minSharesOut for the RWAVault deposit: previewDeposit less `slippageBps`. Zero when nothing is deposited. */
-export declare const minSharesOut: (target: LiquidationTarget, quote: LiquidationQuote, slippageBps: bigint) => bigint;
+export declare function toleranceNeeded(ctx: Pick<LiquidationContext, "nav" | "vaultTokenSupply">, amount: bigint, out: bigint, burned?: bigint): bigint;
+/** How far the realised rate of a swap falls below Curve's spot rate, in bps. */
+export declare function priceImpact(ctx: Pick<LiquidationContext, "curve">, amount: bigint, out: bigint): bigint;
+/** The largest swap share (bps) whose output clears the floor at `toleranceBps` once `burned` vault tokens are gone; the whole balance when the floor is off. */
+export declare function largestClearingFloor(ctx: Pick<LiquidationContext, "nav" | "floor" | "vaultTokenSupply">, quote: Quote, total: bigint, toleranceBps: bigint, burned?: bigint): Promise<bigint>;
 /**
- * Simulates liquidateBorrower from `sender` with the split overridden in storage (an eth_call state override), so a
- * split change in the same batch is simulated rather than only checked. Returns null when the RPC or the storage
- * layout cannot be used; otherwise the revert reason, or "" when it succeeds.
+ * Sizes the swap, derives the split and says what the Treasury must send. `quote` is Curve's get_dy, so a test can
+ * pass a synthetic curve. In "otc" mode nothing is swapped and the Treasury funds the whole uncovered debt.
  */
-export declare function simulateWithSplit(provider: Provider, ctx: LiquidationContext, sender: string, data: string, split: LiquidationSplit): Promise<string | null>;
+export declare function planLiquidation(ctx: LiquidationContext, target: LiquidationTarget, quote: Quote, params?: PlanParams, mode?: PlanMode): Promise<LiquidationPlan>;
+/** minSharesOut for the RWAVault deposit: previewDeposit less `slippageBps`. Zero when nothing is deposited. */
+export declare const minSharesOut: (target: LiquidationTarget, slippageBps: bigint) => bigint;

package/dist/types/utils/artifacts.d.ts

@@ -1,3 +1,6 @@
+import PSMVaultArtifact from "../artifacts/core/psm/PSMVault.sol/PSMVault.json";
+import PSMVaultV2Artifact from "../artifacts/core/psm/v2/PSMVaultV2.sol/PSMVaultV2.json";
+import PSMVaultV3Artifact from "../artifacts/core/psm/v3/PSMVaultV3.sol/PSMVaultV3.json";
 declare const ABIS: {
     crvusd: ({
         inputs: {
@@ -607,6 +610,63 @@ declare const ABIS: {
         type: string;
         anonymous?: undefined;
     })[];
+    liquidationswap: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: any[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: any[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
     raacminter: ({
         inputs: {
             internalType: string;
@@ -3109,6 +3169,62 @@ declare const getABI: (name: keyof typeof ABIS) => any[] | ({
     type: string;
     stateMutability?: undefined;
     outputs?: undefined;
+} | {
+    inputs: any[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: any[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[] | ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
 } | {
     inputs: {
         internalType: string;
@@ -5475,4 +5591,6 @@ declare const getABI: (name: keyof typeof ABIS) => any[] | ({
     type: string;
     anonymous?: undefined;
 })[];
-export { getABI, ABIS };
+/** PSMVault ABI per implementation major version, matched against the `version` of a chain config `psm` entry. */
+declare const PSM_VAULT_ABIS: Record<number, typeof PSMVaultArtifact.abi | typeof PSMVaultV2Artifact.abi | typeof PSMVaultV3Artifact.abi>;
+export { getABI, ABIS, PSM_VAULT_ABIS };

package/dist/types/utils/contracts.d.ts

@@ -133,6 +133,7 @@ export declare const getConfigs: () => {
         psm: {
             "rpsm-susds": {
                 id: string;
+                version: string;
                 name: string;
                 contract: string;
                 rateProvider: string;
@@ -408,6 +409,7 @@ declare const _default: {
             psm: {
                 "rpsm-susds": {
                     id: string;
+                    version: string;
                     name: string;
                     contract: string;
                     rateProvider: string;

package/dist/utils/artifacts.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ABIS = exports.getABI = void 0;
+exports.PSM_VAULT_ABIS = exports.ABIS = exports.getABI = void 0;
 const crvUSDToken_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/crvUSDToken.sol/crvUSDToken.json")); // assert { type: "json" };
 const pmUSD_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/pmUSD.sol/pmUSD.json")); // assert { type: "json" };
 const xPM_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/xPM.sol/xPM.json")); // assert { type: "json" };
@@ -11,6 +11,7 @@ const veRAACToken_json_1 = __importDefault(require("../artifacts/core/tokens/veR
 const RToken_json_1 = __importDefault(require("../artifacts/core/tokens/RToken.sol/RToken.json")); // assert { type: "json" };
 const LendingPool_json_1 = __importDefault(require("../artifacts/core/pools/LendingPool/LendingPool.sol/LendingPool.json")); // assert { type: "json" };
 const StabilityPool_json_1 = __importDefault(require("../artifacts/core/pools/StabilityPool/StabilityPool.sol/StabilityPool.json")); // assert { type: "json" };
+const LiquidationSwap_json_1 = __importDefault(require("../artifacts/core/pools/StabilityPool/LiquidationSwap.sol/LiquidationSwap.json")); // assert { type: "json" };
 // import LiquidityPoolArtifact from "../artifacts/LiquidityPool/LiquidityPool.sol/LiquidityPool.json"; // assert { type: "json" };
 const RAACNFT_json_1 = __importDefault(require("../artifacts/core/tokens/RAACNFT.sol/RAACNFT.json")); // assert { type: "json" };
 const DEToken_json_1 = __importDefault(require("../artifacts/core/tokens/DEToken.sol/DEToken.json")); // assert { type: "json" };
@@ -63,6 +64,8 @@ const AladdinZap_json_1 = __importDefault(require("../artifacts/zap/AladdinZap.s
 // Testnet faucet (hand-written ABI, Sepolia only)
 const Faucet_json_1 = __importDefault(require("../artifacts/faucet/Faucet.json"));
 const PSMVault_json_1 = __importDefault(require("../artifacts/core/psm/PSMVault.sol/PSMVault.json"));
+const PSMVaultV2_json_1 = __importDefault(require("../artifacts/core/psm/v2/PSMVaultV2.sol/PSMVaultV2.json"));
+const PSMVaultV3_json_1 = __importDefault(require("../artifacts/core/psm/v3/PSMVaultV3.sol/PSMVaultV3.json"));
 const RateProvider_json_1 = __importDefault(require("../artifacts/core/psm/RateProvider.sol/RateProvider.json"));
 const CRVUSD_ABI = crvUSDToken_json_1.default.abi;
 const PMUSD_ABI = pmUSD_json_1.default.abi;
@@ -112,6 +115,7 @@ const ABIS = {
     // Pools
     lendingpool: RAACLENDINGPOOL_ABI,
     stabilitypool: RAACSTABILITYPOOL_ABI,
+    liquidationswap: LiquidationSwap_json_1.default.abi,
     // liquiditypool: LIQUIDITYPOOL_ABI,
     raacminter: RAACMINTER_ABI,
     // contracts
@@ -172,3 +176,10 @@ const getABI = (name) => {
     return ABIS[name];
 };
 exports.getABI = getABI;
+/** PSMVault ABI per implementation major version, matched against the `version` of a chain config `psm` entry. */
+const PSM_VAULT_ABIS = {
+    1: PSMVault_json_1.default.abi,
+    2: PSMVaultV2_json_1.default.abi,
+    3: PSMVaultV3_json_1.default.abi,
+};
+exports.PSM_VAULT_ABIS = PSM_VAULT_ABIS;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "2.0.0-beta.21",
+	"version": "2.0.0-beta.23",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -16,6 +16,7 @@
 		"test:unit": "node -r ts-node/register -r tsconfig-paths/register --test tests/loader.unit.test.ts",
 		"test:integration": "node -r ts-node/register -r tsconfig-paths/register --test tests/loader.integration.test.ts",
 		"test:e2e": "npm run build && node -r ts-node/register -r tsconfig-paths/register --test tests/loader.e2e.test.ts",
+		"test:fork": "node --env-file-if-exists=.env -r ts-node/register/transpile-only tests/liquidationFork.test.ts",
 		"test:browser": "node tests/browser/server.js --local",
 		"test:browser:published": "open tests/browser/index.html",
 		"sync": "bash setup.sh",