120 lines
5.4 KiB
TypeScript
120 lines
5.4 KiB
TypeScript
/**
|
|
* Floor price helpers for the red-team agent feedback loop.
|
|
*
|
|
* ethPerToken is not a contract view function — it is computed off-chain as
|
|
* lmTotalEth / adjustedOutstandingSupply, where:
|
|
* - lmTotalEth = native ETH + WETH held by LiquidityManager
|
|
* (mirrors ThreePositionStrategy._getEthBalance())
|
|
* - adjustedSupply = kraiken.outstandingSupply() minus KRK at
|
|
* feeDestination and stakingPool
|
|
* (mirrors LiquidityManager._getOutstandingSupply())
|
|
*/
|
|
import { Interface } from 'ethers';
|
|
import { rpcCall } from './rpc.js';
|
|
|
|
// Base WETH address — stable across Anvil forks of Base Sepolia.
|
|
const WETH = '0x4200000000000000000000000000000000000006';
|
|
|
|
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
|
|
|
|
const KRK_ABI = [
|
|
'function outstandingSupply() external view returns (uint256)',
|
|
'function peripheryContracts() external view returns (address, address)',
|
|
'function balanceOf(address account) external view returns (uint256)',
|
|
];
|
|
|
|
/** feeDestination() is the auto-generated getter for the public storage var on LiquidityManager. */
|
|
const LM_ABI = ['function feeDestination() external view returns (address)'];
|
|
|
|
const ERC20_ABI = ['function balanceOf(address account) external view returns (uint256)'];
|
|
|
|
const krkIface = new Interface(KRK_ABI);
|
|
const lmIface = new Interface(LM_ABI);
|
|
const erc20Iface = new Interface(ERC20_ABI);
|
|
|
|
/**
|
|
* Read full floor diagnostics for the LiquidityManager / Kraiken pair.
|
|
*
|
|
* All reads are issued in at most two parallel rounds to minimise latency:
|
|
* Round 1: ETH/WETH balances, raw outstanding supply, feeDestination, peripheryContracts
|
|
* Round 2 (conditional): balanceOf(feeDestination) and/or balanceOf(stakingPool) when non-zero
|
|
*
|
|
* outstandingSupply in the return value mirrors LiquidityManager._getOutstandingSupply():
|
|
* it starts from kraiken.outstandingSupply() then subtracts KRK held at feeDestination
|
|
* and stakingPool, since neither can be sold into the floor.
|
|
*
|
|
* ethPerToken = (lmNativeEth + lmWeth) / adjustedOutstandingSupply.
|
|
* Returns ethPerToken = 0n when outstandingSupply is zero (uninitialized pool).
|
|
*
|
|
* @param lmAddress - LiquidityManager contract address.
|
|
* @param krkAddress - Kraiken contract address.
|
|
*/
|
|
export async function getFloorState(
|
|
rpcUrl: string,
|
|
lmAddress: string,
|
|
krkAddress: string,
|
|
): Promise<{
|
|
ethPerToken: bigint;
|
|
lmEthBalance: bigint;
|
|
lmWethBalance: bigint;
|
|
outstandingSupply: bigint;
|
|
}> {
|
|
// Round 1: five reads in parallel.
|
|
const [lmEthHex, lmWethHex, rawSupplyHex, feeDestHex, peripheryHex] = (await Promise.all([
|
|
rpcCall(rpcUrl, 'eth_getBalance', [lmAddress, 'latest']),
|
|
rpcCall(rpcUrl, 'eth_call', [{ to: WETH, data: erc20Iface.encodeFunctionData('balanceOf', [lmAddress]) }, 'latest']),
|
|
rpcCall(rpcUrl, 'eth_call', [{ to: krkAddress, data: krkIface.encodeFunctionData('outstandingSupply', []) }, 'latest']),
|
|
rpcCall(rpcUrl, 'eth_call', [{ to: lmAddress, data: lmIface.encodeFunctionData('feeDestination', []) }, 'latest']),
|
|
rpcCall(rpcUrl, 'eth_call', [{ to: krkAddress, data: krkIface.encodeFunctionData('peripheryContracts', []) }, 'latest']),
|
|
])) as [string, string, string, string, string];
|
|
|
|
const [lmWethRaw] = erc20Iface.decodeFunctionResult('balanceOf', lmWethHex);
|
|
const [rawSupply] = krkIface.decodeFunctionResult('outstandingSupply', rawSupplyHex);
|
|
const [feeDestination] = lmIface.decodeFunctionResult('feeDestination', feeDestHex);
|
|
// peripheryContracts() returns (liquidityManager, stakingPool) — we only need the second.
|
|
const [, stakingPool] = krkIface.decodeFunctionResult('peripheryContracts', peripheryHex);
|
|
|
|
const lmEthBalance = BigInt(lmEthHex);
|
|
const lmWethBalance = BigInt(lmWethRaw);
|
|
|
|
// Round 2: subtract excluded KRK balances (matches _getOutstandingSupply logic).
|
|
const isZero = (addr: string) => addr.toLowerCase() === ZERO_ADDRESS;
|
|
const excluded: string[] = [];
|
|
if (!isZero(feeDestination as string)) excluded.push(feeDestination as string);
|
|
if (!isZero(stakingPool as string)) excluded.push(stakingPool as string);
|
|
|
|
let supply = BigInt(rawSupply);
|
|
if (excluded.length > 0) {
|
|
const balHexes = (await Promise.all(
|
|
excluded.map(addr =>
|
|
rpcCall(rpcUrl, 'eth_call', [{ to: krkAddress, data: krkIface.encodeFunctionData('balanceOf', [addr]) }, 'latest']),
|
|
),
|
|
)) as string[];
|
|
for (const hex of balHexes) {
|
|
const [bal] = krkIface.decodeFunctionResult('balanceOf', hex);
|
|
supply -= BigInt(bal);
|
|
}
|
|
}
|
|
|
|
const lmTotalEth = lmEthBalance + lmWethBalance;
|
|
// Scale by 1e18 (WAD) before dividing so the result is in wei-per-token
|
|
// rather than always 0n. Example: 100 ETH / 1M KRK = 1e20 * 1e18 / 1e24 = 1e14 wei/token.
|
|
const ethPerToken = supply === 0n ? 0n : (lmTotalEth * 10n ** 18n) / supply;
|
|
|
|
return { ethPerToken, lmEthBalance, lmWethBalance, outstandingSupply: supply };
|
|
}
|
|
|
|
/**
|
|
* Compute the current floor price (ethPerToken) from LM state.
|
|
*
|
|
* Delegates to getFloorState(); callers that need multiple fields should call
|
|
* getFloorState() directly to avoid redundant RPC calls.
|
|
*
|
|
* @param krkAddress - Kraiken contract address.
|
|
* @param lmAddress - LiquidityManager contract address.
|
|
* @returns ethPerToken in wei, 0n when outstanding supply is zero.
|
|
*/
|
|
export async function getEthPerToken(rpcUrl: string, krkAddress: string, lmAddress: string): Promise<bigint> {
|
|
const { ethPerToken } = await getFloorState(rpcUrl, lmAddress, krkAddress);
|
|
return ethPerToken;
|
|
}
|