@hypurrquant/defi-core 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,709 @@
+import { Address, Hex, PublicClient } from 'viem';
+
+/** A built DeFi transaction ready for simulation or broadcast */
+interface DeFiTx {
+    description: string;
+    to: Address;
+    data: Hex;
+    value: bigint;
+    gas_estimate?: number;
+    /** ERC20 approvals to check and send before broadcasting this tx */
+    approvals?: Array<{
+        token: Address;
+        spender: Address;
+        amount: bigint;
+    }>;
+    /** Pre-transactions to execute before the main tx (e.g. farming approval) */
+    pre_txs?: DeFiTx[];
+}
+/** Result of executing or simulating a transaction */
+interface ActionResult {
+    tx_hash?: string;
+    status: TxStatus;
+    gas_used?: number;
+    description: string;
+    details: Record<string, unknown>;
+}
+/** Transaction status (serde: snake_case) */
+declare enum TxStatus {
+    DryRun = "dry_run",
+    Simulated = "simulated",
+    SimulationFailed = "simulation_failed",
+    NeedsApproval = "needs_approval",
+    Pending = "pending",
+    Confirmed = "confirmed",
+    Failed = "failed"
+}
+/** Token amount with decimals-aware formatting */
+interface TokenAmount {
+    token: Address;
+    symbol: string;
+    amount: bigint;
+    decimals: number;
+}
+declare function formatHuman(t: TokenAmount): string;
+/** Slippage tolerance in basis points */
+interface Slippage {
+    bps: number;
+}
+declare function newSlippage(bps: number): Slippage;
+declare function defaultSwapSlippage(): Slippage;
+declare function applyMinSlippage(slippage: Slippage, amount: bigint): bigint;
+interface PriceData {
+    source: string;
+    source_type: string;
+    asset: Address;
+    price_usd: bigint;
+    price_f64: number;
+    block_number?: number;
+    timestamp?: number;
+}
+interface SwapParams {
+    protocol: string;
+    token_in: Address;
+    token_out: Address;
+    amount_in: bigint;
+    slippage: Slippage;
+    recipient: Address;
+    deadline?: number;
+}
+interface QuoteParams {
+    protocol: string;
+    token_in: Address;
+    token_out: Address;
+    amount_in: bigint;
+}
+interface QuoteResult {
+    protocol: string;
+    amount_out: bigint;
+    price_impact_bps?: number;
+    fee_bps?: number;
+    route: string[];
+}
+interface AddLiquidityParams {
+    protocol: string;
+    token_a: Address;
+    token_b: Address;
+    amount_a: bigint;
+    amount_b: bigint;
+    recipient: Address;
+    /** Optional lower tick for concentrated LP (defaults to full range) */
+    tick_lower?: number;
+    /** Optional upper tick for concentrated LP (defaults to full range) */
+    tick_upper?: number;
+    /** ±N% concentrated range around current price (e.g. 2 for ±2%) */
+    range_pct?: number;
+    /** Optional pool address for tick detection / single-side LP */
+    pool?: Address;
+}
+interface RemoveLiquidityParams {
+    protocol: string;
+    token_a: Address;
+    token_b: Address;
+    liquidity: bigint;
+    recipient: Address;
+}
+interface SupplyParams {
+    protocol: string;
+    asset: Address;
+    amount: bigint;
+    on_behalf_of: Address;
+}
+interface BorrowParams {
+    protocol: string;
+    asset: Address;
+    amount: bigint;
+    interest_rate_mode: InterestRateMode;
+    on_behalf_of: Address;
+}
+/** Interest rate mode (serde: snake_case) */
+declare enum InterestRateMode {
+    Variable = "variable",
+    Stable = "stable"
+}
+interface RepayParams {
+    protocol: string;
+    asset: Address;
+    amount: bigint;
+    interest_rate_mode: InterestRateMode;
+    on_behalf_of: Address;
+}
+interface WithdrawParams {
+    protocol: string;
+    asset: Address;
+    amount: bigint;
+    to: Address;
+}
+interface LendingRates {
+    protocol: string;
+    asset: Address;
+    supply_apy: number;
+    borrow_variable_apy: number;
+    borrow_stable_apy?: number;
+    utilization: number;
+    total_supply: bigint;
+    total_borrow: bigint;
+    /** Reward token addresses for supply-side incentives */
+    supply_reward_tokens?: string[];
+    /** Reward token addresses for borrow-side incentives */
+    borrow_reward_tokens?: string[];
+    /** Emissions per second per supply reward token (raw uint256 as string) */
+    supply_emissions_per_second?: string[];
+    /** Emissions per second per borrow reward token (raw uint256 as string) */
+    borrow_emissions_per_second?: string[];
+    /** Supply-side incentive APY (%) from reward token emissions */
+    supply_incentive_apy?: number;
+    /** Borrow-side incentive APY (%) from reward token emissions (negative = subsidized) */
+    borrow_incentive_apy?: number;
+}
+interface UserPosition {
+    protocol: string;
+    user: Address;
+    supplies: PositionAsset[];
+    borrows: PositionAsset[];
+    health_factor?: number;
+    net_apy?: number;
+}
+interface PositionAsset {
+    asset: Address;
+    symbol: string;
+    amount: bigint;
+    value_usd?: number;
+}
+interface OpenCdpParams {
+    protocol: string;
+    collateral: Address;
+    collateral_amount: bigint;
+    debt_amount: bigint;
+    recipient: Address;
+}
+interface AdjustCdpParams {
+    protocol: string;
+    cdp_id: bigint;
+    collateral_delta?: bigint;
+    debt_delta?: bigint;
+    add_collateral: boolean;
+    add_debt: boolean;
+}
+interface CloseCdpParams {
+    protocol: string;
+    cdp_id: bigint;
+}
+interface CdpInfo {
+    protocol: string;
+    cdp_id: bigint;
+    collateral: TokenAmount;
+    debt: TokenAmount;
+    collateral_ratio: number;
+    liquidation_price?: number;
+}
+interface StakeParams {
+    protocol: string;
+    amount: bigint;
+    recipient: Address;
+}
+interface UnstakeParams {
+    protocol: string;
+    amount: bigint;
+    recipient: Address;
+}
+interface StakingInfo {
+    protocol: string;
+    staked_token: Address;
+    liquid_token: Address;
+    exchange_rate: number;
+    apy?: number;
+    total_staked: bigint;
+}
+interface VaultInfo {
+    protocol: string;
+    vault_address: Address;
+    asset: Address;
+    total_assets: bigint;
+    total_supply: bigint;
+    apy?: number;
+}
+interface DerivativesPositionParams {
+    protocol: string;
+    market: string;
+    size: bigint;
+    collateral: bigint;
+    is_long: boolean;
+}
+interface OptionParams {
+    protocol: string;
+    underlying: Address;
+    strike_price: bigint;
+    expiry: number;
+    is_call: boolean;
+    amount: bigint;
+}
+/** A pool that has an active emission gauge */
+interface GaugedPool {
+    pool: Address;
+    gauge: Address;
+    token0: string;
+    token1: string;
+    token0Addr?: Address;
+    token1Addr?: Address;
+    type: "V2" | "CL";
+    tickSpacing?: number;
+    stable?: boolean;
+    /** Reward rate in wei per second (from gauge.rewardRate or rewardData) */
+    rewardRate?: bigint;
+    /** Total LP staked in gauge (wei) */
+    totalStaked?: bigint;
+    /** Reward token address */
+    rewardToken?: Address;
+    /** Calculated emission APR (%) — set by caller if prices available */
+    aprPercent?: number;
+    /** Pool TVL in USD — set by caller if prices available */
+    poolTvlUsd?: number;
+}
+interface RewardInfo {
+    token: Address;
+    symbol: string;
+    amount: bigint;
+    value_usd?: number;
+}
+interface GaugeInfo {
+    gauge: Address;
+    pool: Address;
+    total_staked: bigint;
+    reward_rate: bigint;
+    rewards: RewardInfo[];
+}
+interface VeNftInfo {
+    token_id: bigint;
+    amount: bigint;
+    unlock_time: number;
+    voting_power: bigint;
+}
+interface YieldInfo {
+    protocol: string;
+    pool: string;
+    apy: number;
+    tvl: bigint;
+    tokens: Address[];
+}
+interface PortfolioSnapshot {
+    timestamp: number;
+    chain: string;
+    wallet: string;
+    tokens: TokenBalance[];
+    defi_positions: DefiPosition[];
+    total_value_usd: number;
+}
+interface TokenBalance {
+    token: string;
+    symbol: string;
+    balance: bigint;
+    value_usd: number;
+    price_usd: number;
+}
+interface DefiPosition {
+    protocol: string;
+    type: "lending_supply" | "lending_borrow" | "lp" | "staking" | "vault";
+    asset: string;
+    amount: bigint;
+    value_usd: number;
+}
+interface PortfolioPnL {
+    period: string;
+    start_value_usd: number;
+    end_value_usd: number;
+    pnl_usd: number;
+    pnl_pct: number;
+    token_changes: TokenChange[];
+}
+interface TokenChange {
+    symbol: string;
+    balance_change: bigint;
+    value_change_usd: number;
+}
+
+type DefiErrorCode = "PROTOCOL_NOT_FOUND" | "TOKEN_NOT_FOUND" | "CHAIN_NOT_FOUND" | "INSUFFICIENT_BALANCE" | "INSUFFICIENT_ALLOWANCE" | "SLIPPAGE_EXCEEDED" | "SIMULATION_FAILED" | "ABI_ERROR" | "REGISTRY_ERROR" | "RPC_ERROR" | "PROVIDER_ERROR" | "CONTRACT_ERROR" | "INVALID_PARAM" | "UNSUPPORTED" | "TX_FAILED" | "INTERNAL";
+declare class DefiError extends Error {
+    readonly code: DefiErrorCode;
+    constructor(code: DefiErrorCode, message: string);
+    static protocolNotFound(name: string): DefiError;
+    static tokenNotFound(name: string): DefiError;
+    static chainNotFound(name: string): DefiError;
+    static insufficientBalance(needed: string, available: string): DefiError;
+    static insufficientAllowance(spender: Address): DefiError;
+    static slippageExceeded(expected: string, actual: string): DefiError;
+    static simulationFailed(reason: string): DefiError;
+    static abiError(reason: string): DefiError;
+    static registryError(reason: string): DefiError;
+    static rpcError(reason: string): DefiError;
+    static providerError(reason: string): DefiError;
+    static contractError(reason: string): DefiError;
+    static invalidParam(reason: string): DefiError;
+    static unsupported(operation: string): DefiError;
+    static internal(reason: string): DefiError;
+    toJSON(): {
+        error: string;
+    };
+}
+type Result<T> = T;
+
+/**
+ * BigInt JSON serialization utilities.
+ *
+ * Rust's alloy U256 (backed by ruint) serializes to JSON as 0x-prefixed
+ * lowercase hex strings (e.g., "0x75bcd15"). We must match this exactly
+ * for behavioral parity.
+ */
+/** JSON replacer for Rust parity — bigint becomes 0x-hex string */
+declare function jsonReplacer(_key: string, value: unknown): unknown;
+/** JSON replacer for SDK consumers — bigint becomes decimal string */
+declare function jsonReplacerDecimal(_key: string, value: unknown): unknown;
+/** Stringify with decimal bigint handling */
+declare function jsonStringify(data: unknown, pretty?: boolean): string;
+/** Parse a 0x-hex or decimal string to bigint */
+declare function parseBigInt(value: string): bigint;
+
+declare const erc20Abi: readonly [{
+    readonly name: "name";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "symbol";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "decimals";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly name: "totalSupply";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "transfer";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "transferFrom";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+
+declare function buildApprove(token: Address, spender: Address, amount: bigint): DeFiTx;
+declare function buildTransfer(token: Address, to: Address, amount: bigint): DeFiTx;
+
+declare function getProvider(rpcUrl: string): PublicClient;
+declare function clearProviderCache(): void;
+
+declare const MULTICALL3_ADDRESS: Address;
+declare function buildMulticall(calls: Array<[Address, Hex]>): DeFiTx;
+declare function multicallRead(rpcUrl: string, calls: Array<[Address, Hex]>): Promise<(Hex | null)[]>;
+declare function decodeU256(data: Hex | null): bigint;
+declare function decodeU128(data: Hex | null): bigint;
+
+interface IDex {
+    name(): string;
+    buildSwap(params: SwapParams): Promise<DeFiTx>;
+    quote(params: QuoteParams): Promise<QuoteResult>;
+    buildAddLiquidity(params: AddLiquidityParams): Promise<DeFiTx>;
+    buildRemoveLiquidity(params: RemoveLiquidityParams): Promise<DeFiTx>;
+}
+
+interface ILending {
+    name(): string;
+    buildSupply(params: SupplyParams): Promise<DeFiTx>;
+    buildBorrow(params: BorrowParams): Promise<DeFiTx>;
+    buildRepay(params: RepayParams): Promise<DeFiTx>;
+    buildWithdraw(params: WithdrawParams): Promise<DeFiTx>;
+    getRates(asset: Address): Promise<LendingRates>;
+    getUserPosition(user: Address): Promise<UserPosition>;
+}
+
+/** ve(3,3) Gauge operations — stake LP tokens to earn emissions */
+interface IGauge {
+    name(): string;
+    /** Resolve gauge address from pool address via voter */
+    resolveGauge?(pool: Address): Promise<Address>;
+    /** Deposit LP tokens into gauge */
+    buildDeposit(gauge: Address, amount: bigint, tokenId?: bigint, lpToken?: Address): Promise<DeFiTx>;
+    /** Withdraw LP tokens or NFT from gauge */
+    buildWithdraw(gauge: Address, amount: bigint, tokenId?: bigint): Promise<DeFiTx>;
+    /** Claim earned rewards from gauge */
+    buildClaimRewards(gauge: Address, account?: Address): Promise<DeFiTx>;
+    /** Claim rewards for a CL gauge NFT position (Hybra V4 style) */
+    buildClaimRewardsByTokenId?(gauge: Address, tokenId: bigint): Promise<DeFiTx>;
+    /** Get pending rewards for a user */
+    getPendingRewards(gauge: Address, user: Address): Promise<RewardInfo[]>;
+    /** Get pending rewards for a CL gauge NFT position */
+    getPendingRewardsByTokenId?(gauge: Address, tokenId: bigint): Promise<bigint>;
+    /** Get pending rewards for an Aerodrome Slipstream CL gauge using earned(address, uint256) */
+    getPendingRewardsByCLTokenId?(gauge: Address, user: Address, tokenId: bigint): Promise<bigint>;
+    /** Discover all pools that have active emission gauges */
+    discoverGaugedPools?(): Promise<GaugedPool[]>;
+}
+/** ve(3,3) Vote-escrow operations — lock tokens for veNFT */
+interface IVoteEscrow {
+    name(): string;
+    /** Create a new veNFT lock */
+    buildCreateLock(amount: bigint, lockDuration: number): Promise<DeFiTx>;
+    /** Increase lock amount */
+    buildIncreaseAmount(tokenId: bigint, amount: bigint): Promise<DeFiTx>;
+    /** Increase lock duration */
+    buildIncreaseUnlockTime(tokenId: bigint, lockDuration: number): Promise<DeFiTx>;
+    /** Withdraw after lock expires */
+    buildWithdrawExpired(tokenId: bigint): Promise<DeFiTx>;
+}
+/** ve(3,3) Voter operations — vote on gauge emissions */
+interface IVoter {
+    name(): string;
+    /** Vote for gauges with veNFT */
+    buildVote(tokenId: bigint, pools: Address[], weights: bigint[]): Promise<DeFiTx>;
+    /** Claim bribes for voted pools */
+    buildClaimBribes(bribes: Address[], tokenId: bigint): Promise<DeFiTx>;
+    /** Claim trading fees */
+    buildClaimFees(fees: Address[], tokenId: bigint): Promise<DeFiTx>;
+}
+/** Combined ve(3,3) system — gauge staking + vote-escrow + voter */
+interface IGaugeSystem extends IGauge, IVoteEscrow, IVoter {
+}
+
+/** ERC-4626 Vault interface — covers Capital Allocators, Yield Aggregators, and Yield vaults */
+interface IVault {
+    name(): string;
+    buildDeposit(assets: bigint, receiver: Address): Promise<DeFiTx>;
+    buildWithdraw(assets: bigint, receiver: Address, owner: Address): Promise<DeFiTx>;
+    totalAssets(): Promise<bigint>;
+    convertToShares(assets: bigint): Promise<bigint>;
+    convertToAssets(shares: bigint): Promise<bigint>;
+    getVaultInfo(): Promise<VaultInfo>;
+}
+
+interface ILiquidStaking {
+    name(): string;
+    buildStake(params: StakeParams): Promise<DeFiTx>;
+    buildUnstake(params: UnstakeParams): Promise<DeFiTx>;
+    getInfo(): Promise<StakingInfo>;
+}
+
+interface ICdp {
+    name(): string;
+    buildOpen(params: OpenCdpParams): Promise<DeFiTx>;
+    buildAdjust(params: AdjustCdpParams): Promise<DeFiTx>;
+    buildClose(params: CloseCdpParams): Promise<DeFiTx>;
+    getCdpInfo(cdpId: bigint): Promise<CdpInfo>;
+}
+
+/** Oracle price feed — reads prices from lending protocol oracles or price feeds */
+interface IOracle {
+    name(): string;
+    /** Get price for an asset from this oracle */
+    getPrice(asset: Address): Promise<PriceData>;
+    /** Get prices for multiple assets */
+    getPrices(assets: Address[]): Promise<PriceData[]>;
+}
+
+interface IDerivatives {
+    name(): string;
+    buildOpenPosition(params: DerivativesPositionParams): Promise<DeFiTx>;
+    buildClosePosition(params: DerivativesPositionParams): Promise<DeFiTx>;
+}
+
+interface IOptions {
+    name(): string;
+    buildBuy(params: OptionParams): Promise<DeFiTx>;
+    buildSell(params: OptionParams): Promise<DeFiTx>;
+}
+
+interface IYieldSource {
+    name(): string;
+    getYields(): Promise<YieldInfo[]>;
+    buildDeposit(pool: string, amount: bigint, recipient: Address): Promise<DeFiTx>;
+    buildWithdraw(pool: string, amount: bigint, recipient: Address): Promise<DeFiTx>;
+}
+
+interface IYieldAggregator {
+    name(): string;
+    getVaults(): Promise<VaultInfo[]>;
+    buildDeposit(vault: Address, amount: bigint, recipient: Address): Promise<DeFiTx>;
+    buildWithdraw(vault: Address, amount: bigint, recipient: Address, owner: Address): Promise<DeFiTx>;
+}
+
+interface NftCollectionInfo {
+    address: Address;
+    name: string;
+    symbol: string;
+    total_supply?: bigint;
+    floor_price?: bigint;
+    floor_price_currency?: string;
+}
+interface NftTokenInfo {
+    collection: Address;
+    token_id: bigint;
+    owner: Address;
+    token_uri?: string;
+}
+interface INft {
+    name(): string;
+    getCollectionInfo(collection: Address): Promise<NftCollectionInfo>;
+    getTokenInfo(collection: Address, tokenId: bigint): Promise<NftTokenInfo>;
+    getBalance(owner: Address, collection: Address): Promise<bigint>;
+}
+
+declare class ChainConfig {
+    name: string;
+    chain_id: number;
+    rpc_url: string;
+    explorer_url?: string;
+    native_token: string;
+    wrapped_native?: string;
+    multicall3?: string;
+    effectiveRpcUrl(): string;
+}
+
+interface TokenEntry {
+    symbol: string;
+    name: string;
+    address: Address;
+    decimals: number;
+    is_native_wrapper?: boolean;
+    tags?: string[];
+}
+
+declare enum ProtocolCategory {
+    Dex = "dex",
+    Lending = "lending",
+    Cdp = "cdp",
+    Bridge = "bridge",
+    LiquidStaking = "liquid_staking",
+    YieldSource = "yield_source",
+    YieldAggregator = "yield_aggregator",
+    Vault = "vault",
+    Derivatives = "derivatives",
+    Options = "options",
+    LiquidityManager = "liquidity_manager",
+    Nft = "nft",
+    Other = "other"
+}
+declare function protocolCategoryLabel(category: ProtocolCategory): string;
+interface PoolInfo {
+    name: string;
+    address: Address;
+    token0: string;
+    token1: string;
+    tick_spacing?: number;
+    gauge?: Address;
+    stable?: boolean;
+}
+interface ProtocolEntry {
+    name: string;
+    slug: string;
+    category: ProtocolCategory;
+    interface: string;
+    chain: string;
+    native?: boolean;
+    verified?: boolean;
+    contracts?: Record<string, Address>;
+    pools?: PoolInfo[];
+    description?: string;
+}
+
+declare class Registry {
+    chains: Map<string, ChainConfig>;
+    tokens: Map<string, TokenEntry[]>;
+    protocols: ProtocolEntry[];
+    private constructor();
+    static loadEmbedded(): Registry;
+    private static loadChains;
+    private static loadTokens;
+    private static loadProtocols;
+    getChain(name: string): ChainConfig;
+    getProtocol(name: string): ProtocolEntry;
+    getProtocolsByCategory(category: ProtocolCategory): ProtocolEntry[];
+    getProtocolsForChain(chain: string, includeUnverified?: boolean): ProtocolEntry[];
+    resolveToken(chain: string, symbol: string): TokenEntry;
+    /**
+     * Resolve a pool by name (e.g. "WHYPE/USDC") from a protocol's pool list.
+     * Returns the pool info or throws if not found.
+     */
+    resolvePool(protocolSlug: string, poolName: string): PoolInfo;
+}
+
+export { type ActionResult, type AddLiquidityParams, type AdjustCdpParams, type BorrowParams, type CdpInfo, ChainConfig, type CloseCdpParams, type DeFiTx, DefiError, type DefiErrorCode, type DefiPosition, type DerivativesPositionParams, type GaugeInfo, type GaugedPool, type ICdp, type IDerivatives, type IDex, type IGauge, type IGaugeSystem, type ILending, type ILiquidStaking, type INft, type IOptions, type IOracle, type IVault, type IVoteEscrow, type IVoter, type IYieldAggregator, type IYieldSource, InterestRateMode, type LendingRates, MULTICALL3_ADDRESS, type NftCollectionInfo, type NftTokenInfo, type OpenCdpParams, type OptionParams, type PoolInfo, type PortfolioPnL, type PortfolioSnapshot, type PositionAsset, type PriceData, ProtocolCategory, type ProtocolEntry, type QuoteParams, type QuoteResult, Registry, type RemoveLiquidityParams, type RepayParams, type Result, type RewardInfo, type Slippage, type StakeParams, type StakingInfo, type SupplyParams, type SwapParams, type TokenAmount, type TokenBalance, type TokenChange, type TokenEntry, TxStatus, type UnstakeParams, type UserPosition, type VaultInfo, type VeNftInfo, type WithdrawParams, type YieldInfo, applyMinSlippage, buildApprove, buildMulticall, buildTransfer, clearProviderCache, decodeU128, decodeU256, defaultSwapSlippage, erc20Abi, formatHuman, getProvider, jsonReplacer, jsonReplacerDecimal, jsonStringify, multicallRead, newSlippage, parseBigInt, protocolCategoryLabel };

package/dist/index.js

@@ -0,0 +1,471 @@
+// src/types.ts
+var TxStatus = /* @__PURE__ */ ((TxStatus2) => {
+  TxStatus2["DryRun"] = "dry_run";
+  TxStatus2["Simulated"] = "simulated";
+  TxStatus2["SimulationFailed"] = "simulation_failed";
+  TxStatus2["NeedsApproval"] = "needs_approval";
+  TxStatus2["Pending"] = "pending";
+  TxStatus2["Confirmed"] = "confirmed";
+  TxStatus2["Failed"] = "failed";
+  return TxStatus2;
+})(TxStatus || {});
+function formatHuman(t) {
+  const divisor = 10n ** BigInt(t.decimals);
+  const whole = t.amount / divisor;
+  const frac = t.amount % divisor;
+  return `${whole}.${frac.toString().padStart(t.decimals, "0")} ${t.symbol}`;
+}
+function newSlippage(bps) {
+  return { bps };
+}
+function defaultSwapSlippage() {
+  return { bps: 50 };
+}
+function applyMinSlippage(slippage, amount) {
+  return amount * BigInt(1e4 - slippage.bps) / 10000n;
+}
+var InterestRateMode = /* @__PURE__ */ ((InterestRateMode2) => {
+  InterestRateMode2["Variable"] = "variable";
+  InterestRateMode2["Stable"] = "stable";
+  return InterestRateMode2;
+})(InterestRateMode || {});
+
+// src/error.ts
+var DefiError = class _DefiError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "DefiError";
+    this.code = code;
+  }
+  static protocolNotFound(name) {
+    return new _DefiError("PROTOCOL_NOT_FOUND", `Protocol not found: ${name}`);
+  }
+  static tokenNotFound(name) {
+    return new _DefiError("TOKEN_NOT_FOUND", `Token not found: ${name}`);
+  }
+  static chainNotFound(name) {
+    return new _DefiError("CHAIN_NOT_FOUND", `Chain not found: ${name}`);
+  }
+  static insufficientBalance(needed, available) {
+    return new _DefiError(
+      "INSUFFICIENT_BALANCE",
+      `Insufficient balance: need ${needed}, have ${available}`
+    );
+  }
+  static insufficientAllowance(spender) {
+    return new _DefiError(
+      "INSUFFICIENT_ALLOWANCE",
+      `Insufficient allowance for spender ${spender}`
+    );
+  }
+  static slippageExceeded(expected, actual) {
+    return new _DefiError(
+      "SLIPPAGE_EXCEEDED",
+      `Slippage exceeded: expected ${expected}, got ${actual}`
+    );
+  }
+  static simulationFailed(reason) {
+    return new _DefiError(
+      "SIMULATION_FAILED",
+      `Transaction simulation failed: ${reason}`
+    );
+  }
+  static abiError(reason) {
+    return new _DefiError("ABI_ERROR", `ABI encoding error: ${reason}`);
+  }
+  static registryError(reason) {
+    return new _DefiError("REGISTRY_ERROR", `Registry error: ${reason}`);
+  }
+  static rpcError(reason) {
+    return new _DefiError("RPC_ERROR", `RPC error: ${reason}`);
+  }
+  static providerError(reason) {
+    return new _DefiError("PROVIDER_ERROR", `Provider error: ${reason}`);
+  }
+  static contractError(reason) {
+    return new _DefiError("CONTRACT_ERROR", `Contract error: ${reason}`);
+  }
+  static invalidParam(reason) {
+    return new _DefiError("INVALID_PARAM", `Invalid parameter: ${reason}`);
+  }
+  static unsupported(operation) {
+    return new _DefiError(
+      "UNSUPPORTED",
+      `Unsupported operation: ${operation}`
+    );
+  }
+  static internal(reason) {
+    return new _DefiError("INTERNAL", `Internal error: ${reason}`);
+  }
+  toJSON() {
+    return { error: this.message };
+  }
+};
+
+// src/json.ts
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return "0x" + value.toString(16);
+  }
+  return value;
+}
+function jsonReplacerDecimal(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+function jsonStringify(data, pretty = true) {
+  return pretty ? JSON.stringify(data, jsonReplacerDecimal, 2) : JSON.stringify(data, jsonReplacerDecimal);
+}
+function parseBigInt(value) {
+  if (value.startsWith("0x") || value.startsWith("0X")) {
+    return BigInt(value);
+  }
+  return BigInt(value);
+}
+
+// src/erc20.ts
+import { encodeFunctionData, parseAbi } from "viem";
+var erc20Abi = parseAbi([
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function totalSupply() view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function transferFrom(address from, address to, uint256 amount) returns (bool)"
+]);
+function buildApprove(token, spender, amount) {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [spender, amount]
+  });
+  return {
+    description: `Approve ${spender} to spend ${amount} of token ${token}`,
+    to: token,
+    data,
+    value: 0n,
+    gas_estimate: 6e4
+  };
+}
+function buildTransfer(token, to, amount) {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [to, amount]
+  });
+  return {
+    description: `Transfer ${amount} of token ${token} to ${to}`,
+    to: token,
+    data,
+    value: 0n,
+    gas_estimate: 65e3
+  };
+}
+
+// src/provider.ts
+import { createPublicClient, http } from "viem";
+var providerCache = /* @__PURE__ */ new Map();
+function getProvider(rpcUrl) {
+  const cached = providerCache.get(rpcUrl);
+  if (cached) return cached;
+  const client = createPublicClient({ transport: http(rpcUrl) });
+  providerCache.set(rpcUrl, client);
+  return client;
+}
+function clearProviderCache() {
+  providerCache.clear();
+}
+
+// src/multicall.ts
+import { encodeFunctionData as encodeFunctionData2, decodeFunctionResult, parseAbi as parseAbi2 } from "viem";
+var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var multicall3Abi = parseAbi2([
+  "struct Call3 { address target; bool allowFailure; bytes callData; }",
+  "struct Result { bool success; bytes returnData; }",
+  "function aggregate3(Call3[] calls) returns (Result[] returnData)"
+]);
+function buildMulticall(calls) {
+  const mcCalls = calls.map(([target, callData]) => ({
+    target,
+    allowFailure: true,
+    callData
+  }));
+  const data = encodeFunctionData2({
+    abi: multicall3Abi,
+    functionName: "aggregate3",
+    args: [mcCalls]
+  });
+  return {
+    description: `Multicall3 batch (${calls.length} calls)`,
+    to: MULTICALL3_ADDRESS,
+    data,
+    value: 0n
+  };
+}
+async function multicallRead(rpcUrl, calls) {
+  const client = getProvider(rpcUrl);
+  const mcCalls = calls.map(([target, callData]) => ({
+    target,
+    allowFailure: true,
+    callData
+  }));
+  const result = await client.call({
+    to: MULTICALL3_ADDRESS,
+    data: encodeFunctionData2({
+      abi: multicall3Abi,
+      functionName: "aggregate3",
+      args: [mcCalls]
+    })
+  });
+  if (!result.data) return calls.map(() => null);
+  const decoded = decodeFunctionResult({
+    abi: multicall3Abi,
+    functionName: "aggregate3",
+    data: result.data
+  });
+  return decoded.map((r) => r.success ? r.returnData : null);
+}
+function decodeU256(data) {
+  if (!data || data.length < 66) return 0n;
+  return BigInt(data.slice(0, 66));
+}
+function decodeU128(data) {
+  if (!data || data.length < 66) return 0n;
+  const val = BigInt(data.slice(0, 66));
+  return val & (1n << 128n) - 1n;
+}
+
+// src/registry/chain.ts
+var ChainConfig = class {
+  name;
+  chain_id;
+  rpc_url;
+  explorer_url;
+  native_token;
+  wrapped_native;
+  multicall3;
+  effectiveRpcUrl() {
+    const chainEnv = this.name.toUpperCase().replace(/ /g, "_") + "_RPC_URL";
+    return process.env[chainEnv] ?? process.env["HYPEREVM_RPC_URL"] ?? this.rpc_url;
+  }
+};
+
+// src/registry/protocol.ts
+var ProtocolCategory = /* @__PURE__ */ ((ProtocolCategory2) => {
+  ProtocolCategory2["Dex"] = "dex";
+  ProtocolCategory2["Lending"] = "lending";
+  ProtocolCategory2["Cdp"] = "cdp";
+  ProtocolCategory2["Bridge"] = "bridge";
+  ProtocolCategory2["LiquidStaking"] = "liquid_staking";
+  ProtocolCategory2["YieldSource"] = "yield_source";
+  ProtocolCategory2["YieldAggregator"] = "yield_aggregator";
+  ProtocolCategory2["Vault"] = "vault";
+  ProtocolCategory2["Derivatives"] = "derivatives";
+  ProtocolCategory2["Options"] = "options";
+  ProtocolCategory2["LiquidityManager"] = "liquidity_manager";
+  ProtocolCategory2["Nft"] = "nft";
+  ProtocolCategory2["Other"] = "other";
+  return ProtocolCategory2;
+})(ProtocolCategory || {});
+function protocolCategoryLabel(category) {
+  switch (category) {
+    case "dex" /* Dex */:
+      return "DEX";
+    case "lending" /* Lending */:
+      return "Lending";
+    case "cdp" /* Cdp */:
+      return "CDP";
+    case "bridge" /* Bridge */:
+      return "Bridge";
+    case "liquid_staking" /* LiquidStaking */:
+      return "Liquid Staking";
+    case "yield_source" /* YieldSource */:
+      return "Yield Source";
+    case "yield_aggregator" /* YieldAggregator */:
+      return "Yield Aggregator";
+    case "vault" /* Vault */:
+      return "Vault";
+    case "derivatives" /* Derivatives */:
+      return "Derivatives";
+    case "options" /* Options */:
+      return "Options";
+    case "liquidity_manager" /* LiquidityManager */:
+      return "Liquidity Manager";
+    case "nft" /* Nft */:
+      return "NFT";
+    case "other" /* Other */:
+      return "Other";
+  }
+}
+
+// src/registry/registry.ts
+import { readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { parse } from "smol-toml";
+import { existsSync } from "fs";
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+function findConfigDir() {
+  const candidates = [
+    resolve(__dirname, "../../../config"),
+    // from dist/registry/ (monorepo build)
+    resolve(__dirname, "../../../../config"),
+    // from src/registry/ (vitest)
+    resolve(__dirname, "../config"),
+    // from dist/ (npm bundle — config at package root)
+    resolve(__dirname, "../../config")
+    // from dist/subdir (npm bundle variant)
+  ];
+  for (const dir of candidates) {
+    if (existsSync(resolve(dir, "chains.toml"))) return dir;
+  }
+  throw new Error(`Config directory not found. Searched: ${candidates.join(", ")}`);
+}
+var CONFIG_DIR = findConfigDir();
+function readToml(relPath) {
+  return readFileSync(resolve(CONFIG_DIR, relPath), "utf-8");
+}
+var Registry = class _Registry {
+  chains;
+  tokens;
+  protocols;
+  constructor(chains, tokens, protocols) {
+    this.chains = chains;
+    this.tokens = tokens;
+    this.protocols = protocols;
+  }
+  static loadEmbedded() {
+    const chains = _Registry.loadChains();
+    const tokens = _Registry.loadTokens();
+    const protocols = _Registry.loadProtocols();
+    return new _Registry(chains, tokens, protocols);
+  }
+  static loadChains() {
+    const raw = parse(readToml("chains.toml"));
+    const map = /* @__PURE__ */ new Map();
+    for (const [key, data] of Object.entries(raw.chain)) {
+      const cfg = Object.assign(new ChainConfig(), data);
+      map.set(key, cfg);
+    }
+    return map;
+  }
+  static loadTokens() {
+    const map = /* @__PURE__ */ new Map();
+    const tokensDir = resolve(CONFIG_DIR, "tokens");
+    try {
+      const files = readdirSync(tokensDir).filter((f) => f.endsWith(".toml"));
+      for (const file of files) {
+        const chain = file.replace(".toml", "");
+        try {
+          const raw = parse(readToml(`tokens/${file}`));
+          map.set(chain, raw.token);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return map;
+  }
+  static loadProtocols() {
+    const protocols = [];
+    const protocolsDir = resolve(CONFIG_DIR, "protocols");
+    const categories = ["dex", "lending", "cdp", "vault", "liquid_staking", "yield_aggregator", "yield_source", "derivatives", "options", "nft", "bridge"];
+    for (const category of categories) {
+      const catDir = resolve(protocolsDir, category);
+      try {
+        if (!existsSync(catDir)) continue;
+        const files = readdirSync(catDir).filter((f) => f.endsWith(".toml"));
+        for (const file of files) {
+          try {
+            const raw = parse(readToml(`protocols/${category}/${file}`));
+            protocols.push(raw.protocol);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return protocols;
+  }
+  getChain(name) {
+    const chain = this.chains.get(name);
+    if (!chain) throw new Error(`Chain not found: ${name}`);
+    return chain;
+  }
+  getProtocol(name) {
+    const protocol = this.protocols.find(
+      (p) => p.name.toLowerCase() === name.toLowerCase() || p.slug.toLowerCase() === name.toLowerCase()
+    );
+    if (!protocol) throw new Error(`Protocol not found: ${name}`);
+    return protocol;
+  }
+  getProtocolsByCategory(category) {
+    return this.protocols.filter((p) => p.category === category);
+  }
+  getProtocolsForChain(chain, includeUnverified = false) {
+    return this.protocols.filter(
+      (p) => p.chain.toLowerCase() === chain.toLowerCase() && (includeUnverified || p.verified !== false)
+    );
+  }
+  resolveToken(chain, symbol) {
+    const tokens = this.tokens.get(chain);
+    if (!tokens) throw new Error(`Chain not found: ${chain}`);
+    const token = tokens.find(
+      (t) => t.symbol.toLowerCase() === symbol.toLowerCase()
+    );
+    if (!token) throw new Error(`Token not found: ${symbol}`);
+    return token;
+  }
+  /**
+   * Resolve a pool by name (e.g. "WHYPE/USDC") from a protocol's pool list.
+   * Returns the pool info or throws if not found.
+   */
+  resolvePool(protocolSlug, poolName) {
+    const protocol = this.getProtocol(protocolSlug);
+    if (!protocol.pools || protocol.pools.length === 0) {
+      throw new Error(`Protocol ${protocol.name} has no pools configured`);
+    }
+    const pool = protocol.pools.find(
+      (p) => p.name.toLowerCase() === poolName.toLowerCase()
+    );
+    if (!pool) {
+      const available = protocol.pools.map((p) => p.name).join(", ");
+      throw new Error(`Pool '${poolName}' not found in ${protocol.name}. Available: ${available}`);
+    }
+    return pool;
+  }
+};
+export {
+  ChainConfig,
+  DefiError,
+  InterestRateMode,
+  MULTICALL3_ADDRESS,
+  ProtocolCategory,
+  Registry,
+  TxStatus,
+  applyMinSlippage,
+  buildApprove,
+  buildMulticall,
+  buildTransfer,
+  clearProviderCache,
+  decodeU128,
+  decodeU256,
+  defaultSwapSlippage,
+  erc20Abi,
+  formatHuman,
+  getProvider,
+  jsonReplacer,
+  jsonReplacerDecimal,
+  jsonStringify,
+  multicallRead,
+  newSlippage,
+  parseBigInt,
+  protocolCategoryLabel
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/error.ts","../src/json.ts","../src/erc20.ts","../src/provider.ts","../src/multicall.ts","../src/registry/chain.ts","../src/registry/protocol.ts","../src/registry/registry.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\n\n// === Transaction Types ===\n\n/** A built DeFi transaction ready for simulation or broadcast */\nexport interface DeFiTx {\n  description: string;\n  to: Address;\n  data: Hex;\n  value: bigint;\n  gas_estimate?: number;\n  /** ERC20 approvals to check and send before broadcasting this tx */\n  approvals?: Array<{\n    token: Address;\n    spender: Address;\n    amount: bigint;\n  }>;\n  /** Pre-transactions to execute before the main tx (e.g. farming approval) */\n  pre_txs?: DeFiTx[];\n}\n\n/** Result of executing or simulating a transaction */\nexport interface ActionResult {\n  tx_hash?: string;\n  status: TxStatus;\n  gas_used?: number;\n  description: string;\n  details: Record<string, unknown>;\n}\n\n/** Transaction status (serde: snake_case) */\nexport enum TxStatus {\n  DryRun = \"dry_run\",\n  Simulated = \"simulated\",\n  SimulationFailed = \"simulation_failed\",\n  NeedsApproval = \"needs_approval\",\n  Pending = \"pending\",\n  Confirmed = \"confirmed\",\n  Failed = \"failed\",\n}\n\n// === Token Types ===\n\n/** Token amount with decimals-aware formatting */\nexport interface TokenAmount {\n  token: Address;\n  symbol: string;\n  amount: bigint;\n  decimals: number;\n}\n\nexport function formatHuman(t: TokenAmount): string {\n  const divisor = 10n ** BigInt(t.decimals);\n  const whole = t.amount / divisor;\n  const frac = t.amount % divisor;\n  return `${whole}.${frac.toString().padStart(t.decimals, \"0\")} ${t.symbol}`;\n}\n\n/** Slippage tolerance in basis points */\nexport interface Slippage {\n  bps: number;\n}\n\nexport function newSlippage(bps: number): Slippage {\n  return { bps };\n}\n\nexport function defaultSwapSlippage(): Slippage {\n  return { bps: 50 };\n}\n\nexport function applyMinSlippage(slippage: Slippage, amount: bigint): bigint {\n  return (amount * BigInt(10000 - slippage.bps)) / 10000n;\n}\n\n// === Oracle / Price Types ===\n\nexport interface PriceData {\n  source: string;\n  source_type: string;\n  asset: Address;\n  price_usd: bigint;\n  price_f64: number;\n  block_number?: number;\n  timestamp?: number;\n}\n\n// === DEX Types ===\n\nexport interface SwapParams {\n  protocol: string;\n  token_in: Address;\n  token_out: Address;\n  amount_in: bigint;\n  slippage: Slippage;\n  recipient: Address;\n  deadline?: number;\n}\n\nexport interface QuoteParams {\n  protocol: string;\n  token_in: Address;\n  token_out: Address;\n  amount_in: bigint;\n}\n\nexport interface QuoteResult {\n  protocol: string;\n  amount_out: bigint;\n  price_impact_bps?: number;\n  fee_bps?: number;\n  route: string[];\n}\n\nexport interface AddLiquidityParams {\n  protocol: string;\n  token_a: Address;\n  token_b: Address;\n  amount_a: bigint;\n  amount_b: bigint;\n  recipient: Address;\n  /** Optional lower tick for concentrated LP (defaults to full range) */\n  tick_lower?: number;\n  /** Optional upper tick for concentrated LP (defaults to full range) */\n  tick_upper?: number;\n  /** ±N% concentrated range around current price (e.g. 2 for ±2%) */\n  range_pct?: number;\n  /** Optional pool address for tick detection / single-side LP */\n  pool?: Address;\n}\n\nexport interface RemoveLiquidityParams {\n  protocol: string;\n  token_a: Address;\n  token_b: Address;\n  liquidity: bigint;\n  recipient: Address;\n}\n\n// === Lending Types ===\n\nexport interface SupplyParams {\n  protocol: string;\n  asset: Address;\n  amount: bigint;\n  on_behalf_of: Address;\n}\n\nexport interface BorrowParams {\n  protocol: string;\n  asset: Address;\n  amount: bigint;\n  interest_rate_mode: InterestRateMode;\n  on_behalf_of: Address;\n}\n\n/** Interest rate mode (serde: snake_case) */\nexport enum InterestRateMode {\n  Variable = \"variable\",\n  Stable = \"stable\",\n}\n\nexport interface RepayParams {\n  protocol: string;\n  asset: Address;\n  amount: bigint;\n  interest_rate_mode: InterestRateMode;\n  on_behalf_of: Address;\n}\n\nexport interface WithdrawParams {\n  protocol: string;\n  asset: Address;\n  amount: bigint;\n  to: Address;\n}\n\nexport interface LendingRates {\n  protocol: string;\n  asset: Address;\n  supply_apy: number;\n  borrow_variable_apy: number;\n  borrow_stable_apy?: number;\n  utilization: number;\n  total_supply: bigint;\n  total_borrow: bigint;\n  /** Reward token addresses for supply-side incentives */\n  supply_reward_tokens?: string[];\n  /** Reward token addresses for borrow-side incentives */\n  borrow_reward_tokens?: string[];\n  /** Emissions per second per supply reward token (raw uint256 as string) */\n  supply_emissions_per_second?: string[];\n  /** Emissions per second per borrow reward token (raw uint256 as string) */\n  borrow_emissions_per_second?: string[];\n  /** Supply-side incentive APY (%) from reward token emissions */\n  supply_incentive_apy?: number;\n  /** Borrow-side incentive APY (%) from reward token emissions (negative = subsidized) */\n  borrow_incentive_apy?: number;\n}\n\nexport interface UserPosition {\n  protocol: string;\n  user: Address;\n  supplies: PositionAsset[];\n  borrows: PositionAsset[];\n  health_factor?: number;\n  net_apy?: number;\n}\n\nexport interface PositionAsset {\n  asset: Address;\n  symbol: string;\n  amount: bigint;\n  value_usd?: number;\n}\n\n// === CDP Types ===\n\nexport interface OpenCdpParams {\n  protocol: string;\n  collateral: Address;\n  collateral_amount: bigint;\n  debt_amount: bigint;\n  recipient: Address;\n}\n\nexport interface AdjustCdpParams {\n  protocol: string;\n  cdp_id: bigint;\n  collateral_delta?: bigint;\n  debt_delta?: bigint;\n  add_collateral: boolean;\n  add_debt: boolean;\n}\n\nexport interface CloseCdpParams {\n  protocol: string;\n  cdp_id: bigint;\n}\n\nexport interface CdpInfo {\n  protocol: string;\n  cdp_id: bigint;\n  collateral: TokenAmount;\n  debt: TokenAmount;\n  collateral_ratio: number;\n  liquidation_price?: number;\n}\n\n// === Liquid Staking Types ===\n\nexport interface StakeParams {\n  protocol: string;\n  amount: bigint;\n  recipient: Address;\n}\n\nexport interface UnstakeParams {\n  protocol: string;\n  amount: bigint;\n  recipient: Address;\n}\n\nexport interface StakingInfo {\n  protocol: string;\n  staked_token: Address;\n  liquid_token: Address;\n  exchange_rate: number;\n  apy?: number;\n  total_staked: bigint;\n}\n\n// === Vault Types (ERC-4626) ===\n\nexport interface VaultInfo {\n  protocol: string;\n  vault_address: Address;\n  asset: Address;\n  total_assets: bigint;\n  total_supply: bigint;\n  apy?: number;\n}\n\n// === Derivatives Types ===\n\nexport interface DerivativesPositionParams {\n  protocol: string;\n  market: string;\n  size: bigint;\n  collateral: bigint;\n  is_long: boolean;\n}\n\n// === Options Types ===\n\nexport interface OptionParams {\n  protocol: string;\n  underlying: Address;\n  strike_price: bigint;\n  expiry: number;\n  is_call: boolean;\n  amount: bigint;\n}\n\n// === ve(3,3) Types ===\n\n/** A pool that has an active emission gauge */\nexport interface GaugedPool {\n  pool: Address;\n  gauge: Address;\n  token0: string;  // symbol\n  token1: string;  // symbol\n  token0Addr?: Address;\n  token1Addr?: Address;\n  type: \"V2\" | \"CL\";\n  tickSpacing?: number;  // for CL pools\n  stable?: boolean;      // for V2 pools\n  /** Reward rate in wei per second (from gauge.rewardRate or rewardData) */\n  rewardRate?: bigint;\n  /** Total LP staked in gauge (wei) */\n  totalStaked?: bigint;\n  /** Reward token address */\n  rewardToken?: Address;\n  /** Calculated emission APR (%) — set by caller if prices available */\n  aprPercent?: number;\n  /** Pool TVL in USD — set by caller if prices available */\n  poolTvlUsd?: number;\n}\n\nexport interface RewardInfo {\n  token: Address;\n  symbol: string;\n  amount: bigint;\n  value_usd?: number;\n}\n\nexport interface GaugeInfo {\n  gauge: Address;\n  pool: Address;\n  total_staked: bigint;\n  reward_rate: bigint;\n  rewards: RewardInfo[];\n}\n\nexport interface VeNftInfo {\n  token_id: bigint;\n  amount: bigint;\n  unlock_time: number;\n  voting_power: bigint;\n}\n\n// === Yield Types ===\n\nexport interface YieldInfo {\n  protocol: string;\n  pool: string;\n  apy: number;\n  tvl: bigint;\n  tokens: Address[];\n}\n\n// === Portfolio Tracker Types ===\nexport interface PortfolioSnapshot {\n  timestamp: number;\n  chain: string;\n  wallet: string;\n  tokens: TokenBalance[];\n  defi_positions: DefiPosition[];\n  total_value_usd: number;\n}\n\nexport interface TokenBalance {\n  token: string;\n  symbol: string;\n  balance: bigint;\n  value_usd: number;\n  price_usd: number;\n}\n\nexport interface DefiPosition {\n  protocol: string;\n  type: \"lending_supply\" | \"lending_borrow\" | \"lp\" | \"staking\" | \"vault\";\n  asset: string;\n  amount: bigint;\n  value_usd: number;\n}\n\nexport interface PortfolioPnL {\n  period: string;\n  start_value_usd: number;\n  end_value_usd: number;\n  pnl_usd: number;\n  pnl_pct: number;\n  token_changes: TokenChange[];\n}\n\nexport interface TokenChange {\n  symbol: string;\n  balance_change: bigint;\n  value_change_usd: number;\n}\n","import type { Address } from \"viem\";\n\nexport type DefiErrorCode =\n  | \"PROTOCOL_NOT_FOUND\"\n  | \"TOKEN_NOT_FOUND\"\n  | \"CHAIN_NOT_FOUND\"\n  | \"INSUFFICIENT_BALANCE\"\n  | \"INSUFFICIENT_ALLOWANCE\"\n  | \"SLIPPAGE_EXCEEDED\"\n  | \"SIMULATION_FAILED\"\n  | \"ABI_ERROR\"\n  | \"REGISTRY_ERROR\"\n  | \"RPC_ERROR\"\n  | \"PROVIDER_ERROR\"\n  | \"CONTRACT_ERROR\"\n  | \"INVALID_PARAM\"\n  | \"UNSUPPORTED\"\n  | \"TX_FAILED\"\n  | \"INTERNAL\";\n\nexport class DefiError extends Error {\n  readonly code: DefiErrorCode;\n\n  constructor(code: DefiErrorCode, message: string) {\n    super(message);\n    this.name = \"DefiError\";\n    this.code = code;\n  }\n\n  static protocolNotFound(name: string): DefiError {\n    return new DefiError(\"PROTOCOL_NOT_FOUND\", `Protocol not found: ${name}`);\n  }\n\n  static tokenNotFound(name: string): DefiError {\n    return new DefiError(\"TOKEN_NOT_FOUND\", `Token not found: ${name}`);\n  }\n\n  static chainNotFound(name: string): DefiError {\n    return new DefiError(\"CHAIN_NOT_FOUND\", `Chain not found: ${name}`);\n  }\n\n  static insufficientBalance(needed: string, available: string): DefiError {\n    return new DefiError(\n      \"INSUFFICIENT_BALANCE\",\n      `Insufficient balance: need ${needed}, have ${available}`,\n    );\n  }\n\n  static insufficientAllowance(spender: Address): DefiError {\n    return new DefiError(\n      \"INSUFFICIENT_ALLOWANCE\",\n      `Insufficient allowance for spender ${spender}`,\n    );\n  }\n\n  static slippageExceeded(expected: string, actual: string): DefiError {\n    return new DefiError(\n      \"SLIPPAGE_EXCEEDED\",\n      `Slippage exceeded: expected ${expected}, got ${actual}`,\n    );\n  }\n\n  static simulationFailed(reason: string): DefiError {\n    return new DefiError(\n      \"SIMULATION_FAILED\",\n      `Transaction simulation failed: ${reason}`,\n    );\n  }\n\n  static abiError(reason: string): DefiError {\n    return new DefiError(\"ABI_ERROR\", `ABI encoding error: ${reason}`);\n  }\n\n  static registryError(reason: string): DefiError {\n    return new DefiError(\"REGISTRY_ERROR\", `Registry error: ${reason}`);\n  }\n\n  static rpcError(reason: string): DefiError {\n    return new DefiError(\"RPC_ERROR\", `RPC error: ${reason}`);\n  }\n\n  static providerError(reason: string): DefiError {\n    return new DefiError(\"PROVIDER_ERROR\", `Provider error: ${reason}`);\n  }\n\n  static contractError(reason: string): DefiError {\n    return new DefiError(\"CONTRACT_ERROR\", `Contract error: ${reason}`);\n  }\n\n  static invalidParam(reason: string): DefiError {\n    return new DefiError(\"INVALID_PARAM\", `Invalid parameter: ${reason}`);\n  }\n\n  static unsupported(operation: string): DefiError {\n    return new DefiError(\n      \"UNSUPPORTED\",\n      `Unsupported operation: ${operation}`,\n    );\n  }\n\n  static internal(reason: string): DefiError {\n    return new DefiError(\"INTERNAL\", `Internal error: ${reason}`);\n  }\n\n  toJSON() {\n    return { error: this.message };\n  }\n}\n\nexport type Result<T> = T;\n","/**\n * BigInt JSON serialization utilities.\n *\n * Rust's alloy U256 (backed by ruint) serializes to JSON as 0x-prefixed\n * lowercase hex strings (e.g., \"0x75bcd15\"). We must match this exactly\n * for behavioral parity.\n */\n\n/** JSON replacer for Rust parity — bigint becomes 0x-hex string */\nexport function jsonReplacer(_key: string, value: unknown): unknown {\n  if (typeof value === \"bigint\") {\n    return \"0x\" + value.toString(16);\n  }\n  return value;\n}\n\n/** JSON replacer for SDK consumers — bigint becomes decimal string */\nexport function jsonReplacerDecimal(_key: string, value: unknown): unknown {\n  if (typeof value === \"bigint\") {\n    return value.toString();\n  }\n  return value;\n}\n\n/** Stringify with decimal bigint handling */\nexport function jsonStringify(data: unknown, pretty = true): string {\n  return pretty\n    ? JSON.stringify(data, jsonReplacerDecimal, 2)\n    : JSON.stringify(data, jsonReplacerDecimal);\n}\n\n/** Parse a 0x-hex or decimal string to bigint */\nexport function parseBigInt(value: string): bigint {\n  if (value.startsWith(\"0x\") || value.startsWith(\"0X\")) {\n    return BigInt(value);\n  }\n  return BigInt(value);\n}\n","import type { Address, Hex } from \"viem\";\nimport { encodeFunctionData, parseAbi } from \"viem\";\nimport type { DeFiTx } from \"./types.js\";\n\nconst erc20Abi = parseAbi([\n  \"function name() view returns (string)\",\n  \"function symbol() view returns (string)\",\n  \"function decimals() view returns (uint8)\",\n  \"function totalSupply() view returns (uint256)\",\n  \"function balanceOf(address account) view returns (uint256)\",\n  \"function transfer(address to, uint256 amount) returns (bool)\",\n  \"function allowance(address owner, address spender) view returns (uint256)\",\n  \"function approve(address spender, uint256 amount) returns (bool)\",\n  \"function transferFrom(address from, address to, uint256 amount) returns (bool)\",\n]);\n\nexport { erc20Abi };\n\nexport function buildApprove(\n  token: Address,\n  spender: Address,\n  amount: bigint,\n): DeFiTx {\n  const data = encodeFunctionData({\n    abi: erc20Abi,\n    functionName: \"approve\",\n    args: [spender, amount],\n  });\n  return {\n    description: `Approve ${spender} to spend ${amount} of token ${token}`,\n    to: token,\n    data,\n    value: 0n,\n    gas_estimate: 60_000,\n  };\n}\n\nexport function buildTransfer(\n  token: Address,\n  to: Address,\n  amount: bigint,\n): DeFiTx {\n  const data = encodeFunctionData({\n    abi: erc20Abi,\n    functionName: \"transfer\",\n    args: [to, amount],\n  });\n  return {\n    description: `Transfer ${amount} of token ${token} to ${to}`,\n    to: token,\n    data,\n    value: 0n,\n    gas_estimate: 65_000,\n  };\n}\n","import { createPublicClient, http, type PublicClient } from \"viem\";\n\nconst providerCache = new Map<string, PublicClient>();\n\nexport function getProvider(rpcUrl: string): PublicClient {\n  const cached = providerCache.get(rpcUrl);\n  if (cached) return cached;\n\n  const client = createPublicClient({ transport: http(rpcUrl) });\n  providerCache.set(rpcUrl, client);\n  return client;\n}\n\nexport function clearProviderCache(): void {\n  providerCache.clear();\n}\n","import type { Address, Hex } from \"viem\";\nimport { encodeFunctionData, decodeFunctionResult, parseAbi } from \"viem\";\nimport type { DeFiTx } from \"./types.js\";\nimport { getProvider } from \"./provider.js\";\n\nexport const MULTICALL3_ADDRESS: Address =\n  \"0xcA11bde05977b3631167028862bE2a173976CA11\";\n\nconst multicall3Abi = parseAbi([\n  \"struct Call3 { address target; bool allowFailure; bytes callData; }\",\n  \"struct Result { bool success; bytes returnData; }\",\n  \"function aggregate3(Call3[] calls) returns (Result[] returnData)\",\n]);\n\nexport function buildMulticall(calls: Array<[Address, Hex]>): DeFiTx {\n  const mcCalls = calls.map(([target, callData]) => ({\n    target,\n    allowFailure: true,\n    callData,\n  }));\n\n  const data = encodeFunctionData({\n    abi: multicall3Abi,\n    functionName: \"aggregate3\",\n    args: [mcCalls],\n  });\n\n  return {\n    description: `Multicall3 batch (${calls.length} calls)`,\n    to: MULTICALL3_ADDRESS,\n    data,\n    value: 0n,\n  };\n}\n\nexport async function multicallRead(\n  rpcUrl: string,\n  calls: Array<[Address, Hex]>,\n): Promise<(Hex | null)[]> {\n  const client = getProvider(rpcUrl);\n\n  const mcCalls = calls.map(([target, callData]) => ({\n    target,\n    allowFailure: true,\n    callData,\n  }));\n\n  const result = await client.call({\n    to: MULTICALL3_ADDRESS,\n    data: encodeFunctionData({\n      abi: multicall3Abi,\n      functionName: \"aggregate3\",\n      args: [mcCalls],\n    }),\n  });\n\n  if (!result.data) return calls.map(() => null);\n\n  const decoded = decodeFunctionResult({\n    abi: multicall3Abi,\n    functionName: \"aggregate3\",\n    data: result.data,\n  }) as Array<{ success: boolean; returnData: Hex }>;\n\n  return decoded.map((r) => (r.success ? r.returnData : null));\n}\n\nexport function decodeU256(data: Hex | null): bigint {\n  if (!data || data.length < 66) return 0n;\n  return BigInt(data.slice(0, 66));\n}\n\nexport function decodeU128(data: Hex | null): bigint {\n  if (!data || data.length < 66) return 0n;\n  const val = BigInt(data.slice(0, 66));\n  return val & ((1n << 128n) - 1n);\n}\n","export class ChainConfig {\n  name!: string;\n  chain_id!: number;\n  rpc_url!: string;\n  explorer_url?: string;\n  native_token!: string;\n  wrapped_native?: string;\n  multicall3?: string;\n\n  effectiveRpcUrl(): string {\n    const chainEnv = this.name.toUpperCase().replace(/ /g, \"_\") + \"_RPC_URL\";\n    return (\n      process.env[chainEnv] ??\n      process.env[\"HYPEREVM_RPC_URL\"] ??\n      this.rpc_url\n    );\n  }\n}\n","import type { Address } from \"viem\";\n\nexport enum ProtocolCategory {\n  Dex = \"dex\",\n  Lending = \"lending\",\n  Cdp = \"cdp\",\n  Bridge = \"bridge\",\n  LiquidStaking = \"liquid_staking\",\n  YieldSource = \"yield_source\",\n  YieldAggregator = \"yield_aggregator\",\n  Vault = \"vault\",\n  Derivatives = \"derivatives\",\n  Options = \"options\",\n  LiquidityManager = \"liquidity_manager\",\n  Nft = \"nft\",\n  Other = \"other\",\n}\n\nexport function protocolCategoryLabel(category: ProtocolCategory): string {\n  switch (category) {\n    case ProtocolCategory.Dex:\n      return \"DEX\";\n    case ProtocolCategory.Lending:\n      return \"Lending\";\n    case ProtocolCategory.Cdp:\n      return \"CDP\";\n    case ProtocolCategory.Bridge:\n      return \"Bridge\";\n    case ProtocolCategory.LiquidStaking:\n      return \"Liquid Staking\";\n    case ProtocolCategory.YieldSource:\n      return \"Yield Source\";\n    case ProtocolCategory.YieldAggregator:\n      return \"Yield Aggregator\";\n    case ProtocolCategory.Vault:\n      return \"Vault\";\n    case ProtocolCategory.Derivatives:\n      return \"Derivatives\";\n    case ProtocolCategory.Options:\n      return \"Options\";\n    case ProtocolCategory.LiquidityManager:\n      return \"Liquidity Manager\";\n    case ProtocolCategory.Nft:\n      return \"NFT\";\n    case ProtocolCategory.Other:\n      return \"Other\";\n  }\n}\n\nexport interface PoolInfo {\n  name: string;\n  address: Address;\n  token0: string;\n  token1: string;\n  tick_spacing?: number;\n  gauge?: Address;\n  stable?: boolean;\n}\n\nexport interface ProtocolEntry {\n  name: string;\n  slug: string;\n  category: ProtocolCategory;\n  interface: string;\n  chain: string;\n  native?: boolean;\n  verified?: boolean;\n  contracts?: Record<string, Address>;\n  pools?: PoolInfo[];\n  description?: string;\n}\n","import { readFileSync, readdirSync } from \"fs\";\nimport { resolve } from \"path\";\nimport { fileURLToPath } from \"url\";\nimport { parse } from \"smol-toml\";\nimport { ChainConfig } from \"./chain.js\";\nimport type { TokenEntry } from \"./token.js\";\nimport { type ProtocolEntry, type PoolInfo, ProtocolCategory } from \"./protocol.js\";\n\nimport { existsSync } from \"fs\";\n\nconst __dirname = fileURLToPath(new URL(\".\", import.meta.url));\n\n// Resolve config dir: works from src/ (vitest), dist/ (built), and npm bundle (npx)\nfunction findConfigDir(): string {\n  const candidates = [\n    resolve(__dirname, \"../../../config\"),   // from dist/registry/ (monorepo build)\n    resolve(__dirname, \"../../../../config\"), // from src/registry/ (vitest)\n    resolve(__dirname, \"../config\"),          // from dist/ (npm bundle — config at package root)\n    resolve(__dirname, \"../../config\"),       // from dist/subdir (npm bundle variant)\n  ];\n  for (const dir of candidates) {\n    if (existsSync(resolve(dir, \"chains.toml\"))) return dir;\n  }\n  throw new Error(`Config directory not found. Searched: ${candidates.join(\", \")}`);\n}\n\nconst CONFIG_DIR = findConfigDir();\n\nfunction readToml(relPath: string): string {\n  return readFileSync(resolve(CONFIG_DIR, relPath), \"utf-8\");\n}\n\ninterface ChainConfigWrapper {\n  chain: Record<string, ChainConfig>;\n}\n\ninterface TokensWrapper {\n  token: TokenEntry[];\n}\n\ninterface ProtocolWrapper {\n  protocol: ProtocolEntry;\n}\n\nexport class Registry {\n  chains: Map<string, ChainConfig>;\n  tokens: Map<string, TokenEntry[]>;\n  protocols: ProtocolEntry[];\n\n  private constructor(\n    chains: Map<string, ChainConfig>,\n    tokens: Map<string, TokenEntry[]>,\n    protocols: ProtocolEntry[],\n  ) {\n    this.chains = chains;\n    this.tokens = tokens;\n    this.protocols = protocols;\n  }\n\n  static loadEmbedded(): Registry {\n    const chains = Registry.loadChains();\n    const tokens = Registry.loadTokens();\n    const protocols = Registry.loadProtocols();\n    return new Registry(chains, tokens, protocols);\n  }\n\n  private static loadChains(): Map<string, ChainConfig> {\n    const raw = parse(readToml(\"chains.toml\")) as unknown as ChainConfigWrapper;\n    const map = new Map<string, ChainConfig>();\n    for (const [key, data] of Object.entries(raw.chain)) {\n      const cfg = Object.assign(new ChainConfig(), data);\n      map.set(key, cfg);\n    }\n    return map;\n  }\n\n  private static loadTokens(): Map<string, TokenEntry[]> {\n    // Dynamically discover all token files in config/tokens/\n    const map = new Map<string, TokenEntry[]>();\n    const tokensDir = resolve(CONFIG_DIR, \"tokens\");\n    try {\n      const files = readdirSync(tokensDir).filter(f => f.endsWith(\".toml\"));\n      for (const file of files) {\n        const chain = file.replace(\".toml\", \"\");\n        try {\n          const raw = parse(readToml(`tokens/${file}`)) as unknown as TokensWrapper;\n          map.set(chain, raw.token);\n        } catch { /* skip invalid token files */ }\n      }\n    } catch { /* tokens dir may not exist */ }\n    return map;\n  }\n\n  private static loadProtocols(): ProtocolEntry[] {\n    // Dynamically discover all protocol TOML files across all categories\n    const protocols: ProtocolEntry[] = [];\n    const protocolsDir = resolve(CONFIG_DIR, \"protocols\");\n    const categories = [\"dex\", \"lending\", \"cdp\", \"vault\", \"liquid_staking\", \"yield_aggregator\", \"yield_source\", \"derivatives\", \"options\", \"nft\", \"bridge\"];\n\n    for (const category of categories) {\n      const catDir = resolve(protocolsDir, category);\n      try {\n        if (!existsSync(catDir)) continue;\n        const files = readdirSync(catDir).filter(f => f.endsWith(\".toml\"));\n        for (const file of files) {\n          try {\n            const raw = parse(readToml(`protocols/${category}/${file}`)) as unknown as ProtocolWrapper;\n            protocols.push(raw.protocol);\n          } catch { /* skip invalid protocol files */ }\n        }\n      } catch { /* category dir may not exist */ }\n    }\n    return protocols;\n  }\n\n  getChain(name: string): ChainConfig {\n    const chain = this.chains.get(name);\n    if (!chain) throw new Error(`Chain not found: ${name}`);\n    return chain;\n  }\n\n  getProtocol(name: string): ProtocolEntry {\n    const protocol = this.protocols.find(\n      (p) =>\n        p.name.toLowerCase() === name.toLowerCase() ||\n        p.slug.toLowerCase() === name.toLowerCase(),\n    );\n    if (!protocol) throw new Error(`Protocol not found: ${name}`);\n    return protocol;\n  }\n\n  getProtocolsByCategory(category: ProtocolCategory): ProtocolEntry[] {\n    return this.protocols.filter((p) => p.category === category);\n  }\n\n  getProtocolsForChain(chain: string, includeUnverified = false): ProtocolEntry[] {\n    return this.protocols.filter(\n      (p) =>\n        p.chain.toLowerCase() === chain.toLowerCase() &&\n        (includeUnverified || p.verified !== false),\n    );\n  }\n\n  resolveToken(chain: string, symbol: string): TokenEntry {\n    const tokens = this.tokens.get(chain);\n    if (!tokens) throw new Error(`Chain not found: ${chain}`);\n    const token = tokens.find(\n      (t) => t.symbol.toLowerCase() === symbol.toLowerCase(),\n    );\n    if (!token) throw new Error(`Token not found: ${symbol}`);\n    return token;\n  }\n\n  /**\n   * Resolve a pool by name (e.g. \"WHYPE/USDC\") from a protocol's pool list.\n   * Returns the pool info or throws if not found.\n   */\n  resolvePool(protocolSlug: string, poolName: string): PoolInfo {\n    const protocol = this.getProtocol(protocolSlug);\n    if (!protocol.pools || protocol.pools.length === 0) {\n      throw new Error(`Protocol ${protocol.name} has no pools configured`);\n    }\n    const pool = protocol.pools.find(\n      (p) => p.name.toLowerCase() === poolName.toLowerCase(),\n    );\n    if (!pool) {\n      const available = protocol.pools.map(p => p.name).join(\", \");\n      throw new Error(`Pool '${poolName}' not found in ${protocol.name}. Available: ${available}`);\n    }\n    return pool;\n  }\n}\n"],"mappings":"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","names":["TxStatus","InterestRateMode","encodeFunctionData","parseAbi","parseAbi","encodeFunctionData","ProtocolCategory"]}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@hypurrquant/defi-core",
+  "version": "0.5.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "config/"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "smol-toml": "^1.3.0",
+    "viem": "^2.23.0",
+    "zod": "^3.24.0"
+  }
+}