+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 | 1x + + +1x +17x +17x +17x + + +1x +7x +7x +7x + + +1x +5x +5x +5x +5x +5x + + +1x +5x +5x + | import { formatUnits } from 'viem';
+
+/** Convert wei (bigint or string) to a JS number. Core primitive. */
+export function weiToNumber(value: bigint | string, decimals = 18): number {
+ const bi = typeof value === 'string' ? BigInt(value || '0') : (value ?? 0n);
+ return Number(formatUnits(bi, decimals));
+}
+
+/** Format wei to fixed decimal string (e.g. "0.00123") */
+export function formatWei(value: bigint | string, decimals = 18, digits = 5): string {
+ const num = weiToNumber(value, decimals);
+ return num === 0 ? '0' : num.toFixed(digits);
+}
+
+/** Format number to compact display (e.g. "1.23K", "4.56M") */
+export function compactNumber(value: number): string {
+ return Intl.NumberFormat('en-US', {
+ notation: 'compact',
+ maximumFractionDigits: 2,
+ }).format(value);
+}
+
+/** Format number with commas (e.g. "1,234,567") */
+export function commaNumber(value: number): string {
+ return value ? value.toLocaleString('en-US') : '0';
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 | 1x + +1x +20x +20x +20x +7x +7x +7x +20x +6x +6x +1x +1x + +1x +3x +3x + | import { bytesToUint256LittleEndian } from './subgraph.js';
+
+export function toBigIntId(id: string | Uint8Array | number | bigint): bigint {
+ if (typeof id === 'bigint') return id;
+ if (typeof id === 'number') return BigInt(id);
+ if (typeof id === 'string') {
+ const trimmed = id.startsWith('0x') ? id : `0x${id}`;
+ return BigInt(trimmed);
+ }
+ if (id instanceof Uint8Array) {
+ return bytesToUint256LittleEndian(id);
+ }
+ throw new Error('Unsupported position id type');
+}
+
+export function decodePositionId(id: string | Uint8Array | number | bigint): bigint {
+ return toBigIntId(id);
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| format.ts | +
+
+ |
+ 100% | +18/18 | +100% | +12/12 | +100% | +4/4 | +100% | +18/18 | +
| ids.ts | +
+
+ |
+ 100% | +16/16 | +100% | +11/11 | +100% | +2/2 | +100% | +16/16 | +
| position.ts | +
+
+ |
+ 100% | +31/31 | +100% | +18/18 | +100% | +2/2 | +100% | +31/31 | +
| snatch.ts | +
+
+ |
+ 100% | +100/100 | +100% | +41/41 | +100% | +4/4 | +100% | +100/100 | +
| staking.ts | +
+
+ |
+ 100% | +27/27 | +100% | +8/8 | +100% | +2/2 | +100% | +27/27 | +
| subgraph.ts | +
+
+ |
+ 100% | +14/14 | +100% | +4/4 | +100% | +2/2 | +100% | +14/14 | +
| taxRates.ts | +
+
+ |
+ 100% | +34/34 | +100% | +0/0 | +100% | +0/0 | +100% | +34/34 | +
| version.ts | +
+
+ |
+ 100% | +36/36 | +100% | +5/5 | +100% | +2/2 | +100% | +36/36 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 | + + + + + + +1x + + + + + + + + + + + + +1x +16x +2x +2x + +16x +2x +2x + +16x + +1x +1x + + +11x +11x + + +11x + + +11x +11x + + + + + + + + + + + + +1x +10x +2x +2x + +10x +2x +2x + +10x + +1x +1x + + +5x +5x + + +5x + + +5x +5x + | /**
+ * Position profit calculations for Harberger staking.
+ *
+ * Positions earn profit through their proportional share of new token issuance.
+ * This aligns with the Harberger tax economic model where stakers earn from protocol growth.
+ */
+
+import { formatUnits } from 'viem';
+
+/**
+ * Calculate profit for an active position.
+ *
+ * Active positions earn their proportional share of all new tokens minted
+ * since the position was created.
+ *
+ * @param totalSupplyInit - Total token supply when position was created
+ * @param currentTotalSupply - Current total token supply
+ * @param positionShare - Position's proportional share (0-1)
+ * @returns Profit in token units (not wei)
+ */
+export function calculateActivePositionProfit(totalSupplyInit: bigint, currentTotalSupply: bigint, positionShare: number): number {
+ if (totalSupplyInit < 0n || currentTotalSupply < 0n) {
+ throw new Error('Supply values must be non-negative');
+ }
+
+ if (positionShare < 0 || positionShare > 1) {
+ throw new Error('Position share must be between 0 and 1');
+ }
+
+ if (currentTotalSupply < totalSupplyInit) {
+ // If supply decreased (shouldn't happen in normal operation), return 0
+ return 0;
+ }
+
+ // Convert to token units (assuming 18 decimals)
+ const initSupply = Number(formatUnits(totalSupplyInit, 18));
+ const currentSupply = Number(formatUnits(currentTotalSupply, 18));
+
+ // Calculate new issuance since position creation
+ const newIssuance = currentSupply - initSupply;
+
+ // Position earns its share of new issuance
+ return newIssuance * positionShare;
+}
+
+/**
+ * Calculate profit for a closed position.
+ *
+ * Closed positions earned their proportional share of all new tokens minted
+ * during the position's lifetime (from creation to closure).
+ *
+ * @param totalSupplyInit - Total token supply when position was created
+ * @param totalSupplyEnd - Total token supply when position was closed
+ * @param positionShare - Position's proportional share (0-1)
+ * @returns Profit in token units (not wei)
+ */
+export function calculateClosedPositionProfit(totalSupplyInit: bigint, totalSupplyEnd: bigint, positionShare: number): number {
+ if (totalSupplyInit < 0n || totalSupplyEnd < 0n) {
+ throw new Error('Supply values must be non-negative');
+ }
+
+ if (positionShare < 0 || positionShare > 1) {
+ throw new Error('Position share must be between 0 and 1');
+ }
+
+ if (totalSupplyEnd < totalSupplyInit) {
+ // If supply decreased during position lifetime, return 0
+ return 0;
+ }
+
+ // Convert to token units (assuming 18 decimals)
+ const initSupply = Number(formatUnits(totalSupplyInit, 18));
+ const endSupply = Number(formatUnits(totalSupplyEnd, 18));
+
+ // Calculate new issuance during position lifetime
+ const newIssuance = endSupply - initSupply;
+
+ // Position earned its share of new issuance
+ return newIssuance * positionShare;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 | +1x + + + + + + + + + + + + + + + + + + + + + + + + +1x + +12x +12x +12x + +1x +4x +2x +2x + +1x +11x + +11x +1x +1x +1x +1x +1x +1x + +10x + +10x +21x +2x +2x + +21x +2x +2x + +17x +10x + +10x +9x +2x +2x +7x +10x + +10x +10x +10x +10x +10x + +11x +18x +16x + +14x +14x +18x +3x +3x +18x +11x +11x + +18x +12x +12x +3x +3x +12x +2x +2x +2x +2x +2x +2x +18x + +10x +10x +10x +11x +11x +11x +11x +11x + +1x +3x +3x +3x +3x +3x +3x +1x +1x + +2x +3x +3x + +3x +3x +3x +3x +3x +3x +2x + +2x +2x +2x +2x +2x + +3x +1x +1x + +1x +1x + | import type { Positions as Position } from './__generated__/graphql.js';
+import { toBigIntId } from './ids.js';
+
+export interface SnatchablePosition {
+ id: bigint;
+ stakeShares: bigint;
+ taxRate: number;
+ taxRateIndex?: number;
+ owner?: string | null;
+}
+
+export interface SnatchSelectionOptions {
+ shortfallShares: bigint;
+ maxTaxRate: number;
+ includeOwned?: boolean;
+ recipientAddress?: string | null;
+}
+
+export interface SnatchSelectionResult {
+ selected: SnatchablePosition[];
+ coveredShares: bigint;
+ remainingShortfall: bigint;
+ maxSelectedTaxRate?: number;
+ maxSelectedTaxRateIndex?: number;
+}
+
+const SHARE_SCALE = 1_000_000n;
+
+function normaliseAddress(value?: string | null): string {
+ return (value ?? '').toLowerCase();
+}
+
+export function minimumTaxRate<T extends { taxRate: number }>(positions: T[], fallback: number = 0): number {
+ if (!positions.length) return fallback;
+ return positions.reduce((min, position) => (position.taxRate < min ? position.taxRate : min), Number.POSITIVE_INFINITY);
+}
+
+export function selectSnatchPositions(candidates: SnatchablePosition[], options: SnatchSelectionOptions): SnatchSelectionResult {
+ const { shortfallShares, maxTaxRate, includeOwned = false, recipientAddress = null } = options;
+
+ if (shortfallShares <= 0n) {
+ return {
+ selected: [],
+ coveredShares: 0n,
+ remainingShortfall: 0n,
+ };
+ }
+
+ const recipientNormalised = normaliseAddress(recipientAddress);
+
+ const filtered = candidates.filter(candidate => {
+ if (candidate.taxRate >= maxTaxRate) {
+ return false;
+ }
+
+ if (!includeOwned && candidate.owner) {
+ return normaliseAddress(candidate.owner) !== recipientNormalised;
+ }
+
+ return true;
+ });
+
+ const sorted = filtered.slice().sort((a, b) => {
+ if (a.taxRate === b.taxRate) {
+ return Number(a.stakeShares - b.stakeShares);
+ }
+ return a.taxRate - b.taxRate;
+ });
+
+ const selection: SnatchablePosition[] = [];
+ let remaining = shortfallShares;
+ let covered = 0n;
+ let maxSelectedTaxRate: number | undefined;
+ let maxSelectedTaxRateIndex: number | undefined;
+
+ for (const candidate of sorted) {
+ if (remaining <= 0n) break;
+ if (candidate.stakeShares <= 0n) continue;
+
+ selection.push(candidate);
+ remaining -= candidate.stakeShares;
+ if (remaining < 0n) {
+ covered = shortfallShares;
+ remaining = 0n;
+ } else {
+ covered = shortfallShares - remaining;
+ }
+
+ if (maxSelectedTaxRate === undefined || candidate.taxRate > maxSelectedTaxRate) {
+ maxSelectedTaxRate = candidate.taxRate;
+ if (typeof candidate.taxRateIndex === 'number') {
+ maxSelectedTaxRateIndex = candidate.taxRateIndex;
+ }
+ } else if (
+ candidate.taxRate === maxSelectedTaxRate &&
+ typeof candidate.taxRateIndex === 'number' &&
+ candidate.taxRateIndex > (maxSelectedTaxRateIndex ?? -1)
+ ) {
+ maxSelectedTaxRateIndex = candidate.taxRateIndex;
+ }
+ }
+
+ return {
+ selected: selection,
+ coveredShares: covered,
+ remainingShortfall: remaining > 0n ? remaining : 0n,
+ maxSelectedTaxRate,
+ maxSelectedTaxRateIndex,
+ };
+}
+
+export function getSnatchList(
+ positions: Position[],
+ needed: bigint,
+ taxRate: number,
+ stakeTotalSupply: bigint
+): bigint[] {
+ if (stakeTotalSupply <= 0n) {
+ throw new Error('stakeTotalSupply must be greater than zero');
+ }
+
+ const candidates: SnatchablePosition[] = positions.map(position => {
+ const shareRatio = Number(position.share);
+ const scaledShares = BigInt(Math.round(shareRatio * Number(SHARE_SCALE)));
+
+ return {
+ id: toBigIntId(position.id),
+ owner: position.owner,
+ stakeShares: (stakeTotalSupply * scaledShares) / SHARE_SCALE,
+ taxRate: Number(position.taxRate),
+ };
+ });
+
+ const result = selectSnatchPositions(candidates, {
+ shortfallShares: needed,
+ maxTaxRate: taxRate,
+ includeOwned: true,
+ });
+
+ if (result.remainingShortfall > 0n) {
+ throw new Error('Not enough capacity');
+ }
+
+ return result.selected.map(candidate => candidate.id);
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 | 1x + +1x +6x +6x +6x +6x +6x +6x +6x +1x +1x + +5x +5x +5x +6x +6x + +1x +7x +7x +7x +7x +7x +7x +7x + +4x +4x +4x + | const SECONDS_IN_YEAR = 365 * 24 * 60 * 60;
+
+export function calculateSnatchShortfall(
+ outstandingStake: bigint,
+ desiredStakeShares: bigint,
+ stakeTotalSupply: bigint,
+ capNumerator: bigint = 2n,
+ capDenominator: bigint = 10n
+): bigint {
+ if (capDenominator === 0n) {
+ throw new Error('capDenominator must be greater than zero');
+ }
+
+ const cap = (stakeTotalSupply * capNumerator) / capDenominator;
+ const required = outstandingStake + desiredStakeShares;
+ const delta = required - cap;
+ return delta > 0n ? delta : 0n;
+}
+
+export function isPositionDelinquent(
+ lastTaxTimestamp: number,
+ taxRate: number,
+ referenceTimestamp: number = Math.floor(Date.now() / 1000),
+ secondsInYear: number = SECONDS_IN_YEAR
+): boolean {
+ const rate = Number(taxRate);
+ if (rate <= 0) return false;
+
+ const allowance = secondsInYear / rate;
+ return referenceTimestamp - lastTaxTimestamp > allowance;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 | 1x + + + + + + +22x + +22x +88x +88x + +22x +22x + +1x +25x +25x +100x +100x +25x + + + + + + + + +25x + | export function bytesToUint256LittleEndian(bytes: Uint8Array): bigint {
+ // console.log(hexString);
+ // const cleanHexString = hexString.startsWith('0x') ? hexString.substring(2) : hexString;
+ // const bytes = new Uint8Array(Math.ceil(cleanHexString.length / 2));
+ // for (let i = 0, j = 0; i < cleanHexString.length; i += 2, j++) {
+ // bytes[j] = parseInt(cleanHexString.slice(i, i + 2), 16);
+ // }
+ let value: bigint = 0n;
+
+ for (let i = bytes.length - 1; i >= 0; i--) {
+ value = (value << 8n) | BigInt(bytes[i]);
+ }
+
+ return value;
+}
+
+export function uint256ToBytesLittleEndian(value: bigint): Uint8Array {
+ const bytes = new Uint8Array(4);
+ for (let i = 0; i < 4; i++) {
+ bytes[i] = Number((value >> (8n * BigInt(i))) & 0xffn);
+ }
+ return bytes;
+ // let hexString = '0x';
+
+ // for (let i = 0; i < bytes.length; i++) {
+ // // Convert each byte to a hexadecimal string and pad with zero if needed
+ // hexString += bytes[i].toString(16).padStart(2, '0');
+ // }
+
+ // return hexString;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | + + + + + + + + + + + + + +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x +1x + + + + + + + + + + + + +1x + + + + + +1x + + | /**
+ * AUTO-GENERATED FILE — DO NOT EDIT
+ *
+ * Generated by scripts/sync-tax-rates.mjs from onchain/src/Stake.sol.
+ * Run `node scripts/sync-tax-rates.mjs` after modifying the contract TAX_RATES array.
+ */
+
+export interface TaxRateOption {
+ index: number;
+ year: number;
+ daily: number;
+ decimal: number;
+}
+
+export const TAX_RATE_OPTIONS: TaxRateOption[] = [
+ { index: 0, year: 1, daily: 0.00274, decimal: 0.01 },
+ { index: 1, year: 3, daily: 0.00822, decimal: 0.03 },
+ { index: 2, year: 5, daily: 0.0137, decimal: 0.05 },
+ { index: 3, year: 8, daily: 0.02192, decimal: 0.08 },
+ { index: 4, year: 12, daily: 0.03288, decimal: 0.12 },
+ { index: 5, year: 18, daily: 0.04932, decimal: 0.18 },
+ { index: 6, year: 24, daily: 0.06575, decimal: 0.24 },
+ { index: 7, year: 30, daily: 0.08219, decimal: 0.3 },
+ { index: 8, year: 40, daily: 0.10959, decimal: 0.4 },
+ { index: 9, year: 50, daily: 0.13699, decimal: 0.5 },
+ { index: 10, year: 60, daily: 0.16438, decimal: 0.6 },
+ { index: 11, year: 80, daily: 0.21918, decimal: 0.8 },
+ { index: 12, year: 100, daily: 0.27397, decimal: 1 },
+ { index: 13, year: 130, daily: 0.35616, decimal: 1.3 },
+ { index: 14, year: 180, daily: 0.49315, decimal: 1.8 },
+ { index: 15, year: 250, daily: 0.68493, decimal: 2.5 },
+ { index: 16, year: 320, daily: 0.87671, decimal: 3.2 },
+ { index: 17, year: 420, daily: 1.15068, decimal: 4.2 },
+ { index: 18, year: 540, daily: 1.47945, decimal: 5.4 },
+ { index: 19, year: 700, daily: 1.91781, decimal: 7 },
+ { index: 20, year: 920, daily: 2.52055, decimal: 9.2 },
+ { index: 21, year: 1200, daily: 3.28767, decimal: 12 },
+ { index: 22, year: 1600, daily: 4.38356, decimal: 16 },
+ { index: 23, year: 2000, daily: 5.47945, decimal: 20 },
+ { index: 24, year: 2600, daily: 7.12329, decimal: 26 },
+ { index: 25, year: 3400, daily: 9.31507, decimal: 34 },
+ { index: 26, year: 4400, daily: 12.05479, decimal: 44 },
+ { index: 27, year: 5700, daily: 15.61644, decimal: 57 },
+ { index: 28, year: 7500, daily: 20.54795, decimal: 75 },
+ { index: 29, year: 9700, daily: 26.57534, decimal: 97 }
+];
+
+/**
+ * Checksum of the contract TAX_RATES array (first 16 chars of SHA-256).
+ * Used for runtime validation to ensure kraiken-lib is in sync with deployed contracts.
+ *
+ * To validate at runtime:
+ * 1. Read TAX_RATES array from the Stake contract
+ * 2. Compute checksum: sha256(values.join(',')).slice(0, 16)
+ * 3. Compare with TAX_RATES_CHECKSUM
+ *
+ * If mismatch: Run `node scripts/sync-tax-rates.mjs` and rebuild kraiken-lib.
+ */
+export const TAX_RATES_CHECKSUM = '1e37f2312ef082e9';
+
+/**
+ * Array of raw year values (matches contract uint256[] TAX_RATES exactly).
+ * Used for runtime validation without needing to parse options.
+ */
+export const TAX_RATES_RAW = [1, 3, 5, 8, 12, 18, 24, 30, 40, 50, 60, 80, 100, 130, 180, 250, 320, 420, 540, 700, 920, 1200, 1600, 2000, 2600, 3400, 4400, 5700, 7500, 9700];
+
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 | + + + + + + + + + + +1x + + + + +1x + + + + + + + + + + + +1x + + + + +1x +5x +5x + + + + +1x +10x +10x +10x +7x +7x +7x +7x +7x +7x +7x +3x +3x +3x +3x +3x + +10x +10x +10x +10x +10x +10x +10x +10x +10x +10x +10x +10x + +10x +10x + | /**
+ * Protocol version compatibility tracking.
+ *
+ * The Kraiken contract exposes a VERSION constant that must be checked
+ * at runtime by indexers and frontends to ensure data compatibility.
+ */
+
+/**
+ * Current version this library is built for.
+ * Should match the deployed Kraiken contract VERSION.
+ */
+export const KRAIKEN_LIB_VERSION = 2;
+
+/**
+ * Singleton ID used for stack metadata rows across services.
+ */
+export const STACK_META_ID = 'stack-meta';
+
+/**
+ * List of Kraiken contract versions this library is compatible with.
+ *
+ * - Indexers MUST validate contract.VERSION is in this list at startup
+ * - Frontends SHOULD validate indexer version matches KRAIKEN_LIB_VERSION
+ *
+ * Version History:
+ * - v1: Initial deployment (30-tier TAX_RATES, index-based staking)
+ * - v2: OptimizerV3, VWAP mirror floor, directional VWAP recording
+ */
+export const COMPATIBLE_CONTRACT_VERSIONS = [1, 2];
+
+/**
+ * Validates if a contract version is compatible with this library.
+ */
+export function isCompatibleVersion(contractVersion: number): boolean {
+ return COMPATIBLE_CONTRACT_VERSIONS.includes(contractVersion);
+}
+
+/**
+ * Error message generator for version mismatches.
+ */
+export function getVersionMismatchError(contractVersion: number, context: 'ponder' | 'frontend'): string {
+ const compatibleVersions = COMPATIBLE_CONTRACT_VERSIONS.join(', ');
+ const instructions =
+ context === 'ponder'
+ ? [
+ '1. Check if contract was upgraded',
+ '2. Update COMPATIBLE_CONTRACT_VERSIONS in kraiken-lib/src/version.ts',
+ '3. Run: ./scripts/build-kraiken-lib.sh',
+ '4. Run: rm -rf services/ponder/.ponder/',
+ '5. Restart Ponder for full re-index',
+ ]
+ : [
+ '1. Contact administrator - indexer may need updating',
+ '2. Try refreshing the page',
+ '3. Check if contract was recently upgraded',
+ ];
+
+ const lines = [
+ '╔════════════════════════════════════════════════════════════╗',
+ `║ ❌ CRITICAL: VERSION MISMATCH (${context})`.padEnd(61) + '║',
+ '╠════════════════════════════════════════════════════════════╣',
+ `║ Contract VERSION: ${contractVersion}`.padEnd(61) + '║',
+ `║ Library VERSION: ${KRAIKEN_LIB_VERSION}`.padEnd(61) + '║',
+ `║ Compatible versions: ${compatibleVersions}`.padEnd(61) + '║',
+ '║'.padEnd(61) + '║',
+ '║ 📋 Required Actions:'.padEnd(61) + '║',
+ ...instructions.map(line => `║ ${line}`.padEnd(61) + '║'),
+ '╚════════════════════════════════════════════════════════════╝',
+ ];
+
+ return lines.join('\n');
+}
+ |