@raac/rpc 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/types/RPCLibrary.d.ts

@@ -47,6 +47,7 @@ import { findContract } from "./contracts/findContract";
 import { decodeCall } from "./contracts/decodeCall";
 import { resolveName, resolveNames } from "./contracts/resolveName";
 import { getTokenMetadata } from "./contracts/getTokenMetadata";
+import { resolveTokenInfo } from "./contracts/resolveTokenInfo";
 import getLatestPrice from "./contracts/housePrices/getLatestPrice";
 import setOracle from "./contracts/housePrices/setOracle";
 import tick from "./minter/tick";
@@ -139,7 +140,7 @@ import getRoles from "./contracts/getRoles";
 import getTreasuryState from "./contracts/treasury/getState";
 import getComplianceStatuses from "./contracts/complianceRegistry/getStatuses";
 import getStabilityPoolAdminState from "./pools/stabilityPool/getAdminState";
-import { readLiquidationContext, readLiquidationTarget, quoteLiquidation, suggestSplit, simulateWithSplit, minSharesOut } from "./pools/stabilityPool/liquidation";
+import { readLiquidationContext, readLiquidationTarget, planLiquidation, curveQuote, largestClearingFloor, toleranceNeeded, priceImpact, valueAtNav, sharesAtNav, minSharesOut, DEFAULT_PLAN_PARAMS } from "./pools/stabilityPool/liquidation";
 import { getEmissionSchedule, getSchedulePosition, getEmissionPerSecondForWeek, getMintingWeekForTimestamp } from "./minter/emissionSchedule";
 import getRWAVaultRegisteredAdapters from "./pools/rwaVault/getRegisteredAdapters";
 import getRWAVaultSeedStatus from "./pools/rwaVault/getSeedStatus";
@@ -441,6 +442,7 @@ declare class RPCLibrary {
         resolveName: typeof resolveName;
         resolveNames: typeof resolveNames;
         getTokenMetadata: typeof getTokenMetadata;
+        resolveTokenInfo: typeof resolveTokenInfo;
         feeCollector: {
             claimRewardFromPool: typeof claimRewardFromPool;
             getState: typeof getFeeCollectorState;
@@ -705,10 +707,15 @@ declare class RPCLibrary {
             liquidation: {
                 getContext: typeof readLiquidationContext;
                 getTarget: typeof readLiquidationTarget;
-                quote: typeof quoteLiquidation;
-                suggestSplit: typeof suggestSplit;
-                simulateWithSplit: typeof simulateWithSplit;
+                plan: typeof planLiquidation;
+                curveQuote: typeof curveQuote;
+                largestClearingFloor: typeof largestClearingFloor;
+                toleranceNeeded: typeof toleranceNeeded;
+                priceImpact: typeof priceImpact;
+                valueAtNav: typeof valueAtNav;
+                sharesAtNav: typeof sharesAtNav;
                 minSharesOut: typeof minSharesOut;
+                DEFAULT_PLAN_PARAMS: typeof DEFAULT_PLAN_PARAMS;
             };
         };
         lendingPool: {

package/dist/types/contracts/governance/gauge/getUserGaugeState.d.ts

@@ -3,12 +3,10 @@ import { ChainId } from "../../../configs/chains";
 import { TokenAmount } from "../../../utils/amount";
 export interface UserGaugeTokenState {
     address: string;
-    /** From the token registry; undefined when the registry does not list the token. */
+    /** From the token registry, or read from the token when the registry does not list it; undefined if it has none. */
     symbol?: string;
-    /** From the token registry; 18 when the registry does not list the token. */
+    /** From the token registry, or read from the token when the registry does not list it. */
     decimals: number;
-    /** Wallet balance, in this token's base units. */
-    balance: TokenAmount;
     /** Allowance to `spender`, in this token's base units. */
     allowance: TokenAmount;
     /** The contract that pulls the token: the gauge for the staking token, the wrapper for the underlying. */
@@ -23,13 +21,14 @@ export interface UserGaugeState {
     underlying: UserGaugeTokenState | null;
 }
 /**
- * What a wallet needs to stake in, wrap for, or unstake from a gauge: its stake, its balance of the staking token and its
- * allowance to the gauge, and for a wrapped gauge its balance of the underlying and allowance to the wrapper.
+ * What a wallet needs to stake in, wrap for, or unstake from a gauge: its stake, its allowance of the staking token to the
+ * gauge, and for a wrapped gauge its allowance of the underlying to the wrapper. Read the wallet's token balances with
+ * `wallet.assets.getBalance`.
  *
  * @param chainId - The chain/network to use.
  * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
  * @param user - The wallet.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The wallet's gauge state. Every amount carries its own token's registry decimals and symbol.
+ * @returns The wallet's gauge state. Every amount carries its own token's decimals and symbol.
  */
 export declare const getUserGaugeState: (chainId: ChainId, gaugeAddressOrId: string, user: string, provider?: Provider) => Promise<UserGaugeState>;

package/dist/types/contracts/psm/getVaultInfo.d.ts

@@ -1,10 +1,8 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains";
 import { TokenAmount, ScaledValue } from "../../utils/amount";
+/** A wallet's open redeem request and allowances to the vault. Token balances, shares included, come from `wallet.assets.getBalance`. */
 export interface PsmVaultUserInfo {
-    shareBalance: TokenAmount;
-    savingsTokenBalance: TokenAmount;
-    baseAssetBalance: TokenAmount;
     redeemRequest: {
         shares: TokenAmount;
         exitTime: number;

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

@@ -0,0 +1,18 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { TokenInfo } from "../utils/amount";
+/**
+ * A token's decimals and symbol for any address: the chain config registry first, then the token itself for an address
+ * the registry does not list. An on-chain read happens once per chain and token; a failed read is not remembered, so
+ * the next call tries again.
+ *
+ * Use this wherever a method takes a token address it cannot know in advance. Methods that take an asset key keep
+ * using `toTokenAmount`, which reads only the registry.
+ *
+ * @param chainId The chain id.
+ * @param idOrAddress An asset key from the registry, or a token contract address, any casing.
+ * @param provider Optional ethers.js Provider instance.
+ * @returns The token's decimals, and its symbol when it has one: a token without a readable `symbol()` gets none.
+ * @throws If an asset key is not in the registry, or an unlisted token has no readable `decimals()`.
+ */
+export declare const resolveTokenInfo: (chainId: ChainId, idOrAddress: string, provider?: Provider) => Promise<TokenInfo>;

package/dist/types/contracts/yearn/vault/getUserInfo.d.ts

@@ -6,8 +6,6 @@ export interface YearnVaultUserInfo {
     shares: TokenAmount;
     /** What `shares` redeem for now, in the vault asset. */
     assets: TokenAmount;
-    /** Wallet balance of the vault asset. */
-    assetBalance: TokenAmount;
     /** Vault asset allowance to the vault, which `deposit` and `mint` pull from. */
     assetAllowance: TokenAmount;
     /** Most the user can deposit now, in the vault asset. */
@@ -18,12 +16,13 @@ export interface YearnVaultUserInfo {
     maxRedeem: TokenAmount;
 }
 /**
- * Gets a user's position in a Yearn V3 vault, plus their vault asset balance and allowance.
+ * Gets a user's position in a Yearn V3 vault, plus their vault asset allowance. Read the wallet's asset balance with
+ * `wallet.assets.getBalance`.
  *
  * @param chainId - The chain/network to use.
  * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section (e.g. "spmusd"), or its address.
  * @param account - Address of the user.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The user's shares, their asset value, balances, allowance and limits, in base units.
+ * @returns The user's shares, their asset value, allowance and limits, in base units.
  */
 export declare function getUserInfo(chainId: ChainId, vaultAddressOrId: string, account: string, provider?: Provider): Promise<YearnVaultUserInfo>;

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

@@ -607,6 +607,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 +3166,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;

package/dist/types/wallet/assets/getBalance.d.ts

@@ -3,13 +3,14 @@ import { AssetType } from "../../utils/artifacts";
 import { ChainId } from "../../configs/chains/index";
 import { TokenAmount } from "../../utils/amount";
 /**
- * Reads a wallet's balance of a configured asset or native ETH.
+ * Reads a wallet's balance of a configured asset, any ERC20 by address, or native ETH.
  * @param chainId The chain id.
- * @param assetId The asset key in the chain config, or `"eth"` for native ETH.
+ * @param assetIdOrAddress The asset key in the chain config, an ERC20 contract address, or `"eth"` for native ETH.
  * @param address The wallet address.
  * @param provider The provider to read with.
  * @returns The balance in base units with decimals and symbol from the token registry (`"ETH"` and 18 for native ETH).
- * @throws If the asset is not deployed on the chain, or the read fails.
+ * A token address the registry does not list takes its decimals and symbol from the token, read once per chain.
+ * @throws If the asset key is not deployed on the chain, or the read fails.
  */
-declare function getBalance(chainId: ChainId, assetId: AssetType, address: string, provider: Provider): Promise<TokenAmount>;
+declare function getBalance(chainId: ChainId, assetIdOrAddress: AssetType, address: string, provider: Provider): Promise<TokenAmount>;
 export default getBalance;

package/dist/utils/artifacts.js

@@ -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" };
@@ -112,6 +113,7 @@ const ABIS = {
     // Pools
     lendingpool: RAACLENDINGPOOL_ABI,
     stabilitypool: RAACSTABILITYPOOL_ABI,
+    liquidationswap: LiquidationSwap_json_1.default.abi,
     // liquiditypool: LIQUIDITYPOOL_ABI,
     raacminter: RAACMINTER_ABI,
     // contracts

package/dist/wallet/assets/getBalance.js

@@ -3,30 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const amount_1 = require("../../utils/amount");
+const resolveTokenInfo_1 = require("../../contracts/resolveTokenInfo");
 const _helpers_1 = require("../../assets/_helpers");
 const rpcError_1 = require("../../utils/rpcError");
 /**
- * Reads a wallet's balance of a configured asset or native ETH.
+ * Reads a wallet's balance of a configured asset, any ERC20 by address, or native ETH.
  * @param chainId The chain id.
- * @param assetId The asset key in the chain config, or `"eth"` for native ETH.
+ * @param assetIdOrAddress The asset key in the chain config, an ERC20 contract address, or `"eth"` for native ETH.
  * @param address The wallet address.
  * @param provider The provider to read with.
  * @returns The balance in base units with decimals and symbol from the token registry (`"ETH"` and 18 for native ETH).
- * @throws If the asset is not deployed on the chain, or the read fails.
+ * A token address the registry does not list takes its decimals and symbol from the token, read once per chain.
+ * @throws If the asset key is not deployed on the chain, or the read fails.
  */
-async function getBalance(chainId, assetId, address, provider) {
+async function getBalance(chainId, assetIdOrAddress, address, provider) {
     const BALANCE_OF_ABI = ["function balanceOf(address) view returns (uint256)"];
     let contractAddress;
     try {
-        if (assetId === "eth") {
+        if (assetIdOrAddress === "eth") {
             const balance = await provider.getBalance(address);
             return (0, amount_1.toAmount)(balance, amount_1.WAD_DECIMALS, "ETH");
         }
-        (0, _helpers_1.assertAssetDeployed)(chainId, assetId);
-        contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
+        if (ethers_1.ethers.isAddress(assetIdOrAddress)) {
+            contractAddress = assetIdOrAddress;
+            const contract = new ethers_1.ethers.Contract(contractAddress, BALANCE_OF_ABI, provider);
+            const [balance, info] = await Promise.all([
+                contract.balanceOf(address),
+                (0, resolveTokenInfo_1.resolveTokenInfo)(chainId, contractAddress, provider),
+            ]);
+            return (0, amount_1.toAmount)(balance, info.decimals, info.symbol);
+        }
+        (0, _helpers_1.assertAssetDeployed)(chainId, assetIdOrAddress);
+        contractAddress = (0, contracts_1.getContractAddress)(chainId, assetIdOrAddress);
         const contract = new ethers_1.ethers.Contract(contractAddress, BALANCE_OF_ABI, provider);
         const balance = await contract.balanceOf(address);
-        return (0, amount_1.toTokenAmount)(chainId, assetId, balance);
+        return (0, amount_1.toTokenAmount)(chainId, assetIdOrAddress, balance);
     }
     catch (error) {
         throw (0, rpcError_1.toRpcError)("wallet.getBalance", error, { chainId, address: contractAddress });