import * as viem from 'viem'; import { Address, Hex, Hash, PublicClient, WalletClient } from 'viem'; import * as abitype from 'abitype'; import * as viem_chains from 'viem/chains'; interface TokenConfig { tokenAdmin: Address; name: string; symbol: string; salt: Hex; image: string; metadata: string; context: string; originatingChainId: bigint; } interface PoolConfig { hook: Address; pairedToken: Address; tickIfToken0IsLiquid: number; tickSpacing: number; poolData: Hex; } interface LockerConfig { locker: Address; rewardAdmins: Address[]; rewardRecipients: Address[]; rewardBps: number[]; tickLower: number[]; tickUpper: number[]; positionBps: number[]; lockerData: Hex; } interface MevModuleConfig { mevModule: Address; mevModuleData: Hex; } interface ExtensionConfig { extension: Address; msgValue: bigint; extensionBps: number; extensionData: Hex; } interface DeploymentConfig { tokenConfig: TokenConfig; poolConfig: PoolConfig; lockerConfig: LockerConfig; mevModuleConfig: MevModuleConfig; extensionConfigs: ExtensionConfig[]; } interface DevBuyParams { /** Amount of ETH to spend on the dev buy */ ethAmount: bigint; /** Address to receive the purchased tokens */ recipient: Address; } interface VaultExtensionParams { /** Address that can claim vested tokens */ admin: Address; /** Percentage of supply to lock, in BPS (1–9000 = 0.01%–90%) */ allocationBps: number; /** Lockup duration in seconds (minimum 604800 = 7 days). Tokens are fully locked during this period. */ lockupDuration: number; /** Vesting duration in seconds after lockup ends (0 = no vesting, tokens unlock all at once) */ vestingDuration?: number; } interface AirdropExtensionParams { /** Address allowed to `updateAdmin`, `updateMerkleRoot` (under conditions), * and `adminClaim` the remainder after claim expiration. */ admin: Address; /** Merkle root over leaves `keccak256(bytes.concat(keccak256(abi.encode( * recipient, allocatedAmount))))`. Double-hashed per OZ convention. */ merkleRoot: Hex; /** Percentage of supply to reserve for the airdrop, in BPS (1–9000). */ allocationBps: number; /** Lockup in seconds before any recipient can claim. Min 86400 (1 day). */ lockupDuration: number; /** Linear vesting after lockup. 0 = instant claim of full entitlement at * lockup end. */ vestingDuration?: number; } interface DeployTokenParams { name: string; symbol: string; image?: string; metadata?: string; context?: string; tokenAdmin?: Address; salt?: Hex; /** Hook address. Defaults to HOOK_STATIC_FEE_V2 (1% fee) */ hook?: Address; /** Quote token. Defaults to WETH */ pairedToken?: Address; /** Starting tick. Defaults to -230400 (≈10 ETH market cap) */ tickIfToken0IsLiquid?: number; /** Tick spacing. Defaults to 200 */ tickSpacing?: number; /** Pool-specific hook data. Defaults to static 1% fee encoded for V2 hook */ poolData?: Hex; /** LP locker address. Defaults to LP_LOCKER */ locker?: Address; /** Reward admin addresses */ rewardAdmins?: Address[]; /** Reward recipient addresses */ rewardRecipients?: Address[]; /** Reward basis points per recipient */ rewardBps?: number[]; /** Tick lower bounds per position */ tickLower?: number[]; /** Tick upper bounds per position */ tickUpper?: number[]; /** Position BPS splits */ positionBps?: number[]; /** Locker-specific data */ lockerData?: Hex; /** MEV module address. Defaults to SNIPER_AUCTION_V2 */ mevModule?: Address; /** MEV module data. Defaults to 80%→40% decay over 20s */ mevModuleData?: Hex; /** Extension configs (vault, airdrop, etc.) */ extensions?: ExtensionConfig[]; /** Dev buy: buy tokens with ETH at launch. Adds the Univ4EthDevBuy extension automatically. */ devBuy?: DevBuyParams; } interface DeploymentInfo { token: Address; hook: Address; locker: Address; extensions: Address[]; } interface PoolKey { currency0: Address; currency1: Address; fee: number; tickSpacing: number; hooks: Address; } interface PoolDynamicConfigVars { baseFee: number; maxLpFee: number; referenceTickFilterPeriod: bigint; resetPeriod: bigint; resetTickFilter: number; feeControlNumerator: bigint; decayFilterBps: number; } interface PoolDynamicFeeVars { referenceTick: number; resetTick: number; resetTickTimestamp: bigint; lastSwapTimestamp: bigint; appliedVR: number; prevVA: number; } interface VaultAllocation { token: Address; amountTotal: bigint; amountClaimed: bigint; lockupEndTime: bigint; vestingEndTime: bigint; admin: Address; } interface TokenCreatedEvent { msgSender: Address; tokenAddress: Address; tokenAdmin: Address; tokenImage: string; tokenName: string; tokenSymbol: string; tokenMetadata: string; tokenContext: string; startingTick: number; poolHook: Address; poolId: Hex; pairedToken: Address; locker: Address; mevModule: Address; extensionsSupply: bigint; extensions: Address[]; /** Block number where the token was created (populated by discovery methods) */ blockNumber?: bigint; } /** Options for querying deployed tokens. */ interface GetTokensOptions { /** Filter by deployer address (msgSender). If omitted, returns all tokens. */ deployer?: Address; /** Starting block to search from (defaults to factory deployment block) */ fromBlock?: bigint; /** Ending block to search to (defaults to 'latest') */ toBlock?: bigint | "latest"; } interface AirdropInfo { admin: Address; merkleRoot: Hex; totalSupply: bigint; totalClaimed: bigint; lockupEndTime: bigint; vestingEndTime: bigint; adminClaimTime: bigint; adminClaimed: boolean; } interface SniperAuctionFeeConfig { startingFee: number; endingFee: number; secondsToDecay: bigint; } interface SniperAuctionState { nextAuctionBlock: bigint; round: bigint; gasPeg: bigint; currentFee: number; } interface TokenRewardInfo { token: Address; poolKey: PoolKey; positionId: bigint; numPositions: bigint; rewardBps: number[]; rewardAdmins: Address[]; rewardRecipients: Address[]; } interface LiquidSDKConfig { publicClient?: any; walletClient?: any; } interface BidInAuctionParams { /** The pool key identifying the token's Uniswap V4 pool */ poolKey: PoolKey; /** * Swap direction. Set `true` when WETH is currency0 (buying token with ETH). * Determine via: `poolKey.currency0.toLowerCase() === WETH.toLowerCase()` */ zeroForOne: boolean; /** * Amount of WETH to swap (in wei). Pulled from caller's WETH balance via * `transferFrom` — separate from the bid. The SDK auto-wraps ETH → WETH * and approves SniperUtilV2 if balance or allowance is insufficient. */ amountIn: bigint; /** Minimum output tokens to receive (slippage protection) */ amountOutMinimum: bigint; /** The auction round to bid in (must match current round on-chain) */ round: bigint; /** ETH bid amount — sent as msg.value, must equal (gasPrice - gasPeg) × paymentPerGasUnit */ bidAmount: bigint; } interface BidInAuctionResult { txHash: Hash; } interface DeployTokenResult { tokenAddress: Address; txHash: Hash; event: TokenCreatedEvent; } declare class LiquidSDK { readonly publicClient: PublicClient; readonly walletClient?: WalletClient; constructor(config: LiquidSDKConfig); /** * Build an ExtensionConfig for a dev buy (buy tokens with ETH at launch). * The paired token must be WETH for simple dev buys. */ buildDevBuyExtension(devBuy: DevBuyParams): ExtensionConfig; /** * Build a vault extension config for token deployment. * * Locks a percentage of the token supply with a lockup period * followed by optional linear vesting. * * @param vault - Vault parameters * @returns ExtensionConfig to include in `deployToken({ extensions })` * * @example * ```typescript * const vaultExt = sdk.buildVaultExtension({ * admin: account.address, * allocationBps: 2000, // 20% of supply * lockupDuration: 2592000, // 30 days in seconds * vestingDuration: 7776000, // 90 days linear vesting after lockup * }); * const result = await sdk.deployToken({ * name: "My Token", symbol: "MTK", * extensions: [vaultExt], * }); * ``` */ buildVaultExtension(vault: VaultExtensionParams): ExtensionConfig; /** * Build an ExtensionConfig that reserves a percentage of supply into * the LiquidAirdropV2 contract for merkle-tree-based distribution. * * The airdrop contract expects `AirdropV2ExtensionData`: * { address admin, bytes32 merkleRoot, uint256 lockupDuration, uint256 vestingDuration } * * Leaf encoding used by LiquidAirdropV2.claim (note: **double hashed** * — OZ's standard 2nd-preimage-resistant pattern): * leaf = keccak256(bytes.concat(keccak256(abi.encode(recipient, allocatedAmount)))) * * @example * ```typescript * const airdropExt = sdk.buildAirdropExtension({ * admin: account.address, * merkleRoot: "0x…", * allocationBps: 2000, // 20% * lockupDuration: 86400, // 1 day (minimum) * vestingDuration: 0, // instant claim after lockup * }); * ``` */ buildAirdropExtension(airdrop: AirdropExtensionParams): ExtensionConfig; /** * Validate a DeploymentConfig before sending to the contract. * Catches common mistakes client-side with clear error messages. */ private validateDeploymentConfig; deployToken(params: DeployTokenParams): Promise; getDeploymentInfo(tokenAddress: Address): Promise; getTokenInfo(tokenAddress: Address): Promise<{ address: `0x${string}`; name: string; symbol: string; decimals: number; totalSupply: bigint; deployment: DeploymentInfo; }>; getPoolConfig(poolId: Hex, hookAddress?: Address): Promise; getPoolFeeState(poolId: Hex, hookAddress?: Address): Promise; getPoolCreationTimestamp(poolId: Hex, hookAddress?: Address): Promise; isLiquidToken0(poolId: Hex, hookAddress?: Address): Promise; /** * Get uncollected fees for a fee owner. * @param feeOwner - Address that receives fees (reward recipient) * @param feeToken - The token fees are denominated in. Defaults to WETH * (correct for all pools using LP_LOCKER_FEE_CONVERSION). */ getAvailableFees(feeOwner: Address, feeToken?: Address): Promise; /** * Get collected, claimable fees for a fee owner. * @param feeOwner - Address that receives fees (reward recipient) * @param feeToken - The token fees are denominated in. Defaults to WETH. */ getFeesToClaim(feeOwner: Address, feeToken?: Address): Promise; /** * Claim all accumulated fees for a fee owner. * @param feeOwner - Address that receives fees (reward recipient) * @param feeToken - The token fees are denominated in. Defaults to WETH. */ claimFees(feeOwner: Address, feeToken?: Address): Promise; getVaultAllocation(tokenAddress: Address): Promise; getVaultClaimable(tokenAddress: Address): Promise; claimVault(tokenAddress: Address): Promise; isFactoryDeprecated(): Promise; isLockerEnabled(locker: Address, hook: Address): Promise; getAuctionState(poolId: Hex): Promise; getAuctionFeeConfig(poolId: Hex): Promise; getAuctionDecayStartTime(poolId: Hex): Promise; getAuctionMaxRounds(): Promise; getAuctionGasPriceForBid(auctionGasPeg: bigint, desiredBidAmount: bigint): Promise; /** * Bid in a sniper auction for early access to a newly launched token. * * The auction lets bidders compete via gas price — the bid amount is * determined by how much your tx.gasprice exceeds the pool's gasPeg. * * **Important:** The `amountIn` (swap input) is pulled from the caller's * WETH balance via `transferFrom`. The SDK automatically wraps ETH → WETH * and approves the SniperUtilV2 if needed. The `bidAmount` is sent as * `msg.value` (separate from the swap). * * Gas price must exceed the pool's `gasPeg` — the delta encodes the bid. * Both `maxFeePerGas` and `maxPriorityFeePerGas` are set to ensure the * effective gas price matches on Base (EIP-1559). Gas estimation is skipped * because `eth_estimateGas` simulates at `baseFee` which is below `gasPeg`. * * @example * ```typescript * // 1. Get auction state & pool key * const state = await sdk.getAuctionState(poolId); * const rewards = await sdk.getTokenRewards(tokenAddress); * * // 2. Calculate gas price for desired bid * const gasPrice = await sdk.getAuctionGasPriceForBid(state.gasPeg, bidAmount); * * // 3. Bid (SDK auto-wraps WETH + approves if needed) * const result = await sdk.bidInAuction({ * poolKey: rewards.poolKey, * zeroForOne: true, // ETH → token * amountIn: parseEther("0.1"), // swap 0.1 ETH (pulled from WETH balance) * amountOutMinimum: 0n, // set slippage * round: state.round, * bidAmount: parseEther("0.01"), * }, gasPrice); * ``` */ bidInAuction(params: BidInAuctionParams, maxFeePerGas: bigint): Promise; getAirdropInfo(tokenAddress: Address): Promise; getAirdropClaimable(tokenAddress: Address, recipient: Address, allocatedAmount: bigint): Promise; claimAirdrop(tokenAddress: Address, recipient: Address, allocatedAmount: bigint, proof: Hex[]): Promise; getTokenRewards(tokenAddress: Address, lockerAddress?: Address): Promise; collectRewards(tokenAddress: Address, lockerAddress?: Address): Promise; collectRewardsWithoutUnlock(tokenAddress: Address, lockerAddress?: Address): Promise; updateRewardRecipient(tokenAddress: Address, rewardIndex: bigint, newRecipient: Address, lockerAddress?: Address): Promise; isExtensionEnabled(extensionAddress: Address): Promise; getMevDescendingFeesBlockDelay(): Promise; /** @deprecated Use getMevDescendingFeesBlockDelay() */ getMevBlockDelay(): Promise; getPoolUnlockTime(poolId: Hex): Promise; /** * Update a token's image. Must be called by the token admin. */ updateImage(tokenAddress: Address, newImage: string): Promise; /** * Update a token's metadata. Must be called by the token admin. */ updateMetadata(tokenAddress: Address, newMetadata: string): Promise; /** * Get all tokens deployed by a specific address by querying TokenCreated events. * @param deployer - The address that deployed the tokens (msgSender) * @param fromBlock - Starting block to search from (defaults to 0n) * @param toBlock - Ending block to search to (defaults to 'latest') */ getDeployedTokens(deployer: Address, fromBlock?: bigint, toBlock?: bigint | "latest"): Promise; /** * Query TokenCreated events with optional filtering. * * Use this for token discovery, indexing, or building token lists. * Returns events in chronological order with block numbers for pagination. * * @example * // Get all tokens * const allTokens = await sdk.getTokens(); * * // Get tokens by deployer * const myTokens = await sdk.getTokens({ deployer: myAddress }); * * // Paginate with block ranges * const page1 = await sdk.getTokens({ fromBlock: 20000000n, toBlock: 20100000n }); * const page2 = await sdk.getTokens({ fromBlock: 20100001n, toBlock: 20200000n }); */ getTokens(options?: GetTokensOptions): Promise; /** * Look up a single token's on-chain event data by contract address. * * Returns the full TokenCreated event including metadata, context, poolId, * hook, locker, extensions — everything a wallet or aggregator needs to * display the token. Returns `null` if not found. * * This is indexed on-chain (tokenAddress is indexed in the event), so it's * a single RPC call regardless of how many tokens exist. */ getTokenEvent(tokenAddress: Address): Promise; } declare const ADDRESSES: { readonly FACTORY: Address; readonly POOL_EXTENSION_ALLOWLIST: Address; readonly FEE_LOCKER: Address; readonly LP_LOCKER_FEE_CONVERSION: Address; readonly VAULT: Address; readonly HOOK_DYNAMIC_FEE_V2: Address; readonly HOOK_STATIC_FEE_V2: Address; readonly SNIPER_AUCTION_V2: Address; readonly SNIPER_UTIL_V2: Address; readonly MEV_DESCENDING_FEES: Address; readonly AIRDROP_V2: Address; readonly UNIV4_ETH_DEV_BUY: Address; readonly UNIV3_ETH_DEV_BUY: Address; readonly PRESALE_ETH_TO_CREATOR: Address; readonly PRESALE_ALLOWLIST: Address; }; declare const EXTERNAL: { readonly POOL_MANAGER: Address; readonly WETH: Address; /** DIEM — Liquid's intelligence-economy token. Also a pair token for * agent-token launches (see `createLiquidPositionsUSD`). */ readonly DIEM: Address; readonly UNIVERSAL_ROUTER: Address; readonly PERMIT2: Address; }; declare const FEE: { /** Fee denominator used by Uniswap v4 (1,000,000 = 100%) */ readonly DENOMINATOR: 1000000; /** Protocol fee numerator: 200,000 / 1,000,000 = 20% of LP fees */ readonly PROTOCOL_FEE_NUMERATOR: 200000; /** Max LP fee: 10% (100,000 / 1,000,000) */ readonly MAX_LP_FEE: 100000; /** Max MEV fee: 80% (800,000 / 1,000,000) */ readonly MAX_MEV_FEE: 800000; /** BPS denominator for token supply splits */ readonly BPS: 10000; }; declare const TOKEN: { /** Total supply for every token: 100 billion with 18 decimals */ readonly SUPPLY: bigint; readonly DECIMALS: 18; readonly MAX_EXTENSIONS: 10; readonly MAX_EXTENSION_BPS: 9000; }; interface PoolPosition { tickLower: number; tickUpper: number; positionBps: number; } /** * Pre-built position configurations. * * - **Standard**: Single position covering full range (~$20K → $1.5B). * Default starting tick -230400 (≈10 ETH market cap). * * - **Liquid**: 3-tranche default for Liquid Protocol. * Hardcoded for ≈10 ETH start at ~$2070/ETH. * For dynamic market cap targets, use `createPositionsUSD()` instead. * * Note: positionBps must sum to 10,000 (100%). */ declare const POOL_POSITIONS: { /** Single position, 100% of liquidity in one range */ readonly Standard: PoolPosition[]; /** 5-position layout with concentrated mid-range liquidity */ readonly Liquid: PoolPosition[]; }; /** * Liquid protocol defaults. * * - Hook: Static fee V2, 1% on both buys and sells * - MEV: Sniper Auction V2 — 80% → 40% decaying over 20 seconds * - Tick spacing: 200 * - Starting tick: -230400 (≈10 ETH market cap) * - Positions: 3-tranche Liquid default (40/50/10) */ declare const DEFAULTS: { readonly HOOK: `0x${string}`; /** LP Locker with fee conversion (converts fees to WETH before distributing) */ readonly LOCKER: `0x${string}`; readonly TICK_SPACING: 200; readonly TICK_IF_TOKEN0_IS_LIQUID: -230400; /** Static fee on buys (ETH → token): 1% (100 bps) */ readonly PAIRED_FEE_BPS: 100; /** Static fee on sells (token → ETH): 1% (100 bps) */ readonly LIQUID_FEE_BPS: 100; /** MEV module: Sniper Auction V2 */ readonly MEV_MODULE: `0x${string}`; /** Sniper auction starting fee: 80% (800,000 uniBps) */ readonly SNIPER_STARTING_FEE: 800000; /** Sniper auction ending fee: 40% (400,000 uniBps) */ readonly SNIPER_ENDING_FEE: 400000; /** Sniper auction decay period: 20 seconds */ readonly SNIPER_SECONDS_TO_DECAY: 20; }; declare const DEFAULT_CHAIN: { blockExplorers: { readonly default: { readonly name: "Basescan"; readonly url: "https://basescan.org"; readonly apiUrl: "https://api.basescan.org/api"; }; }; blockTime: 2000; contracts: { readonly disputeGameFactory: { readonly 1: { readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"; }; }; readonly l2OutputOracle: { readonly 1: { readonly address: "0x56315b90c40730925ec5485cf004d835058518A0"; }; }; readonly multicall3: { readonly address: "0xca11bde05977b3631167028862be2a173976ca11"; readonly blockCreated: 5022; }; readonly portal: { readonly 1: { readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"; readonly blockCreated: 17482143; }; }; readonly l1StandardBridge: { readonly 1: { readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35"; readonly blockCreated: 17482143; }; }; readonly gasPriceOracle: { readonly address: "0x420000000000000000000000000000000000000F"; }; readonly l1Block: { readonly address: "0x4200000000000000000000000000000000000015"; }; readonly l2CrossDomainMessenger: { readonly address: "0x4200000000000000000000000000000000000007"; }; readonly l2Erc721Bridge: { readonly address: "0x4200000000000000000000000000000000000014"; }; readonly l2StandardBridge: { readonly address: "0x4200000000000000000000000000000000000010"; }; readonly l2ToL1MessagePasser: { readonly address: "0x4200000000000000000000000000000000000016"; }; }; ensTlds?: readonly string[] | undefined; id: 8453; name: "Base"; nativeCurrency: { readonly name: "Ether"; readonly symbol: "ETH"; readonly decimals: 18; }; experimental_preconfirmationTime?: number | undefined | undefined; rpcUrls: { readonly default: { readonly http: readonly ["https://mainnet.base.org"]; }; }; sourceId: 1; testnet?: boolean | undefined | undefined; custom?: Record | undefined; extendSchema?: Record | undefined; fees?: viem.ChainFees | undefined; formatters: { readonly block: { exclude: [] | undefined; format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => { baseFeePerGas: bigint | null; blobGasUsed: bigint; difficulty: bigint; excessBlobGas: bigint; extraData: viem.Hex; gasLimit: bigint; gasUsed: bigint; hash: `0x${string}` | null; logsBloom: `0x${string}` | null; miner: abitype.Address; mixHash: viem.Hash; nonce: `0x${string}` | null; number: bigint | null; parentBeaconBlockRoot?: `0x${string}` | undefined; parentHash: viem.Hash; receiptsRoot: viem.Hex; sealFields: viem.Hex[]; sha3Uncles: viem.Hash; size: bigint; stateRoot: viem.Hash; timestamp: bigint; totalDifficulty: bigint | null; transactions: `0x${string}`[] | viem_chains.OpStackTransaction[]; transactionsRoot: viem.Hash; uncles: viem.Hash[]; withdrawals?: viem.Withdrawal[] | undefined | undefined; withdrawalsRoot?: `0x${string}` | undefined; } & {}; type: "block"; }; readonly transaction: { exclude: [] | undefined; format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({ blockHash: `0x${string}` | null; blockNumber: bigint | null; from: abitype.Address; gas: bigint; hash: viem.Hash; input: viem.Hex; nonce: number; r: viem.Hex; s: viem.Hex; to: abitype.Address | null; transactionIndex: number | null; typeHex: viem.Hex | null; v: bigint; value: bigint; yParity: number; gasPrice?: undefined | undefined; maxFeePerBlobGas?: undefined | undefined; maxFeePerGas: bigint; maxPriorityFeePerGas: bigint; isSystemTx?: boolean; mint?: bigint | undefined | undefined; sourceHash: viem.Hex; type: "deposit"; } | { r: viem.Hex; s: viem.Hex; v: bigint; to: abitype.Address | null; from: abitype.Address; gas: bigint; nonce: number; value: bigint; blockHash: `0x${string}` | null; blockNumber: bigint | null; hash: viem.Hash; input: viem.Hex; transactionIndex: number | null; typeHex: viem.Hex | null; accessList?: undefined | undefined; authorizationList?: undefined | undefined; blobVersionedHashes?: undefined | undefined; chainId?: number | undefined; yParity?: undefined | undefined; type: "legacy"; gasPrice: bigint; maxFeePerBlobGas?: undefined | undefined; maxFeePerGas?: undefined | undefined; maxPriorityFeePerGas?: undefined | undefined; isSystemTx?: undefined | undefined; mint?: undefined | undefined; sourceHash?: undefined | undefined; } | { blockHash: `0x${string}` | null; blockNumber: bigint | null; from: abitype.Address; gas: bigint; hash: viem.Hash; input: viem.Hex; nonce: number; r: viem.Hex; s: viem.Hex; to: abitype.Address | null; transactionIndex: number | null; typeHex: viem.Hex | null; v: bigint; value: bigint; yParity: number; accessList: viem.AccessList; authorizationList?: undefined | undefined; blobVersionedHashes?: undefined | undefined; chainId: number; type: "eip2930"; gasPrice: bigint; maxFeePerBlobGas?: undefined | undefined; maxFeePerGas?: undefined | undefined; maxPriorityFeePerGas?: undefined | undefined; isSystemTx?: undefined | undefined; mint?: undefined | undefined; sourceHash?: undefined | undefined; } | { blockHash: `0x${string}` | null; blockNumber: bigint | null; from: abitype.Address; gas: bigint; hash: viem.Hash; input: viem.Hex; nonce: number; r: viem.Hex; s: viem.Hex; to: abitype.Address | null; transactionIndex: number | null; typeHex: viem.Hex | null; v: bigint; value: bigint; yParity: number; accessList: viem.AccessList; authorizationList?: undefined | undefined; blobVersionedHashes?: undefined | undefined; chainId: number; type: "eip1559"; gasPrice?: undefined | undefined; maxFeePerBlobGas?: undefined | undefined; maxFeePerGas: bigint; maxPriorityFeePerGas: bigint; isSystemTx?: undefined | undefined; mint?: undefined | undefined; sourceHash?: undefined | undefined; } | { blockHash: `0x${string}` | null; blockNumber: bigint | null; from: abitype.Address; gas: bigint; hash: viem.Hash; input: viem.Hex; nonce: number; r: viem.Hex; s: viem.Hex; to: abitype.Address | null; transactionIndex: number | null; typeHex: viem.Hex | null; v: bigint; value: bigint; yParity: number; accessList: viem.AccessList; authorizationList?: undefined | undefined; blobVersionedHashes: readonly viem.Hex[]; chainId: number; type: "eip4844"; gasPrice?: undefined | undefined; maxFeePerBlobGas: bigint; maxFeePerGas: bigint; maxPriorityFeePerGas: bigint; isSystemTx?: undefined | undefined; mint?: undefined | undefined; sourceHash?: undefined | undefined; } | { blockHash: `0x${string}` | null; blockNumber: bigint | null; from: abitype.Address; gas: bigint; hash: viem.Hash; input: viem.Hex; nonce: number; r: viem.Hex; s: viem.Hex; to: abitype.Address | null; transactionIndex: number | null; typeHex: viem.Hex | null; v: bigint; value: bigint; yParity: number; accessList: viem.AccessList; authorizationList: viem.SignedAuthorizationList; blobVersionedHashes?: undefined | undefined; chainId: number; type: "eip7702"; gasPrice?: undefined | undefined; maxFeePerBlobGas?: undefined | undefined; maxFeePerGas: bigint; maxPriorityFeePerGas: bigint; isSystemTx?: undefined | undefined; mint?: undefined | undefined; sourceHash?: undefined | undefined; }) & {}; type: "transaction"; }; readonly transactionReceipt: { exclude: [] | undefined; format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => { blobGasPrice?: bigint | undefined; blobGasUsed?: bigint | undefined; blockHash: viem.Hash; blockNumber: bigint; blockTimestamp?: bigint | undefined; contractAddress: abitype.Address | null | undefined; cumulativeGasUsed: bigint; effectiveGasPrice: bigint; from: abitype.Address; gasUsed: bigint; logs: viem.Log[]; logsBloom: viem.Hex; root?: `0x${string}` | undefined; status: "success" | "reverted"; to: abitype.Address | null; transactionHash: viem.Hash; transactionIndex: number; type: viem.TransactionType; l1GasPrice: bigint | null; l1GasUsed: bigint | null; l1Fee: bigint | null; l1FeeScalar: number | null; } & {}; type: "transactionReceipt"; }; }; prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: { phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters"; }) => Promise) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: { phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters"; }) => Promise) | undefined, options: { runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[]; }] | undefined; serializers: { readonly transaction: typeof viem_chains.serializeTransactionOpStack; }; verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise) | undefined; }; declare const DEFAULT_CHAIN_ID = 8453; declare const DEFAULT_RPC_URL = "https://base.drpc.org"; declare const LiquidFactoryAbi: readonly [{ readonly type: "function"; readonly name: "deployToken"; readonly inputs: readonly [{ readonly name: "deploymentConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "tokenConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "tokenAdmin"; readonly type: "address"; }, { readonly name: "name"; readonly type: "string"; }, { readonly name: "symbol"; readonly type: "string"; }, { readonly name: "salt"; readonly type: "bytes32"; }, { readonly name: "image"; readonly type: "string"; }, { readonly name: "metadata"; readonly type: "string"; }, { readonly name: "context"; readonly type: "string"; }, { readonly name: "originatingChainId"; readonly type: "uint256"; }]; }, { readonly name: "poolConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "hook"; readonly type: "address"; }, { readonly name: "pairedToken"; readonly type: "address"; }, { readonly name: "tickIfToken0IsLiquid"; readonly type: "int24"; }, { readonly name: "tickSpacing"; readonly type: "int24"; }, { readonly name: "poolData"; readonly type: "bytes"; }]; }, { readonly name: "lockerConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "locker"; readonly type: "address"; }, { readonly name: "rewardAdmins"; readonly type: "address[]"; }, { readonly name: "rewardRecipients"; readonly type: "address[]"; }, { readonly name: "rewardBps"; readonly type: "uint16[]"; }, { readonly name: "tickLower"; readonly type: "int24[]"; }, { readonly name: "tickUpper"; readonly type: "int24[]"; }, { readonly name: "positionBps"; readonly type: "uint16[]"; }, { readonly name: "lockerData"; readonly type: "bytes"; }]; }, { readonly name: "mevModuleConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "mevModule"; readonly type: "address"; }, { readonly name: "mevModuleData"; readonly type: "bytes"; }]; }, { readonly name: "extensionConfigs"; readonly type: "tuple[]"; readonly components: readonly [{ readonly name: "extension"; readonly type: "address"; }, { readonly name: "msgValue"; readonly type: "uint256"; }, { readonly name: "extensionBps"; readonly type: "uint16"; }, { readonly name: "extensionData"; readonly type: "bytes"; }]; }]; }]; readonly outputs: readonly [{ readonly name: "tokenAddress"; readonly type: "address"; }]; readonly stateMutability: "payable"; }, { readonly type: "function"; readonly name: "tokenDeploymentInfo"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "tuple"; readonly components: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "hook"; readonly type: "address"; }, { readonly name: "locker"; readonly type: "address"; }, { readonly name: "extensions"; readonly type: "address[]"; }]; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "deploymentInfoForToken"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "hook"; readonly type: "address"; }, { readonly name: "locker"; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "deprecated"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "bool"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "TOKEN_SUPPLY"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "BPS"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "teamFeeRecipient"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "enabledLockers"; readonly inputs: readonly [{ readonly name: "locker"; readonly type: "address"; }, { readonly name: "hook"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: "enabled"; readonly type: "bool"; }]; readonly stateMutability: "view"; }, { readonly type: "event"; readonly name: "TokenCreated"; readonly inputs: readonly [{ readonly name: "msgSender"; readonly type: "address"; readonly indexed: false; }, { readonly name: "tokenAddress"; readonly type: "address"; readonly indexed: true; }, { readonly name: "tokenAdmin"; readonly type: "address"; readonly indexed: true; }, { readonly name: "tokenImage"; readonly type: "string"; readonly indexed: false; }, { readonly name: "tokenName"; readonly type: "string"; readonly indexed: false; }, { readonly name: "tokenSymbol"; readonly type: "string"; readonly indexed: false; }, { readonly name: "tokenMetadata"; readonly type: "string"; readonly indexed: false; }, { readonly name: "tokenContext"; readonly type: "string"; readonly indexed: false; }, { readonly name: "startingTick"; readonly type: "int24"; readonly indexed: false; }, { readonly name: "poolHook"; readonly type: "address"; readonly indexed: false; }, { readonly name: "poolId"; readonly type: "bytes32"; readonly indexed: false; }, { readonly name: "pairedToken"; readonly type: "address"; readonly indexed: false; }, { readonly name: "locker"; readonly type: "address"; readonly indexed: false; }, { readonly name: "mevModule"; readonly type: "address"; readonly indexed: false; }, { readonly name: "extensionsSupply"; readonly type: "uint256"; readonly indexed: false; }, { readonly name: "extensions"; readonly type: "address[]"; readonly indexed: false; }]; readonly anonymous: false; }]; declare const LiquidFeeLockerAbi: readonly [{ readonly type: "function"; readonly name: "availableFees"; readonly inputs: readonly [{ readonly name: "feeOwner"; readonly type: "address"; }, { readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "feesToClaim"; readonly inputs: readonly [{ readonly name: "feeOwner"; readonly type: "address"; }, { readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: "balance"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "claim"; readonly inputs: readonly [{ readonly name: "feeOwner"; readonly type: "address"; }, { readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }]; declare const LiquidHookDynamicFeeV2Abi: readonly [{ readonly type: "function"; readonly name: "liquidIsToken0"; readonly inputs: readonly [{ readonly name: ""; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "bool"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolConfigVars"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "tuple"; readonly components: readonly [{ readonly name: "baseFee"; readonly type: "uint24"; }, { readonly name: "maxLpFee"; readonly type: "uint24"; }, { readonly name: "referenceTickFilterPeriod"; readonly type: "uint256"; }, { readonly name: "resetPeriod"; readonly type: "uint256"; }, { readonly name: "resetTickFilter"; readonly type: "int24"; }, { readonly name: "feeControlNumerator"; readonly type: "uint256"; }, { readonly name: "decayFilterBps"; readonly type: "uint24"; }]; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolFeeVars"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "tuple"; readonly components: readonly [{ readonly name: "referenceTick"; readonly type: "int24"; }, { readonly name: "resetTick"; readonly type: "int24"; }, { readonly name: "resetTickTimestamp"; readonly type: "uint256"; }, { readonly name: "lastSwapTimestamp"; readonly type: "uint256"; }, { readonly name: "appliedVR"; readonly type: "uint24"; }, { readonly name: "prevVA"; readonly type: "uint24"; }]; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolCreationTimestamp"; readonly inputs: readonly [{ readonly name: ""; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "protocolFee"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint24"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "factory"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolManager"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "locker"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "mevModule"; readonly inputs: readonly [{ readonly name: ""; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "mevModuleEnabled"; readonly inputs: readonly [{ readonly name: ""; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "bool"; }]; readonly stateMutability: "view"; }]; declare const LiquidVaultAbi: readonly [{ readonly type: "function"; readonly name: "allocation"; readonly inputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "amountTotal"; readonly type: "uint256"; }, { readonly name: "amountClaimed"; readonly type: "uint256"; }, { readonly name: "lockupEndTime"; readonly type: "uint256"; }, { readonly name: "vestingEndTime"; readonly type: "uint256"; }, { readonly name: "admin"; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "amountAvailableToClaim"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "claim"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }]; declare const LiquidSniperAuctionV2Abi: readonly [{ readonly type: "function"; readonly name: "nextAuctionBlock"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: "nextAuctionBlock"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "round"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: "round"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "gasPeg"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: "gasPeg"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "feeConfig"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: "startingFee"; readonly type: "uint24"; }, { readonly name: "endingFee"; readonly type: "uint24"; }, { readonly name: "secondsToDecay"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "getFee"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint24"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolDecayStartTime"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: "poolDecayStartTime"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "maxRounds"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "blocksBetweenAuction"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "blocksBetweenDeploymentAndFirstAuction"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "paymentPerGasUnit"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }]; declare const LiquidSniperUtilV2Abi: readonly [{ readonly type: "function"; readonly name: "bidInAuction"; readonly inputs: readonly [{ readonly name: "swapParams"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "poolKey"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "currency0"; readonly type: "address"; }, { readonly name: "currency1"; readonly type: "address"; }, { readonly name: "fee"; readonly type: "uint24"; }, { readonly name: "tickSpacing"; readonly type: "int24"; }, { readonly name: "hooks"; readonly type: "address"; }]; }, { readonly name: "zeroForOne"; readonly type: "bool"; }, { readonly name: "amountIn"; readonly type: "uint128"; }, { readonly name: "amountOutMinimum"; readonly type: "uint128"; }, { readonly name: "hookData"; readonly type: "bytes"; }]; }, { readonly name: "round"; readonly type: "uint256"; }]; readonly outputs: readonly []; readonly stateMutability: "payable"; }, { readonly type: "function"; readonly name: "getTxGasPriceForBidAmount"; readonly inputs: readonly [{ readonly name: "auctionGasPeg"; readonly type: "uint256"; }, { readonly name: "desiredBidAmount"; readonly type: "uint256"; }]; readonly outputs: readonly [{ readonly name: "txGasPrice"; readonly type: "uint256"; }]; readonly stateMutability: "view"; }]; declare const LiquidAirdropV2Abi: readonly [{ readonly type: "function"; readonly name: "airdrops"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: "admin"; readonly type: "address"; }, { readonly name: "merkleRoot"; readonly type: "bytes32"; }, { readonly name: "totalSupply"; readonly type: "uint256"; }, { readonly name: "totalClaimed"; readonly type: "uint256"; }, { readonly name: "lockupEndTime"; readonly type: "uint256"; }, { readonly name: "vestingEndTime"; readonly type: "uint256"; }, { readonly name: "adminClaimTime"; readonly type: "uint256"; }, { readonly name: "adminClaimed"; readonly type: "bool"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "amountAvailableToClaim"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "recipient"; readonly type: "address"; }, { readonly name: "allocatedAmount"; readonly type: "uint256"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "claim"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "recipient"; readonly type: "address"; }, { readonly name: "allocatedAmount"; readonly type: "uint256"; }, { readonly name: "proof"; readonly type: "bytes32[]"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "CLAIM_EXPIRATION_INTERVAL"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "MIN_LOCKUP_DURATION"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }]; declare const LiquidPoolExtensionAllowlistAbi: readonly [{ readonly type: "function"; readonly name: "enabledExtensions"; readonly inputs: readonly [{ readonly name: "extension"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: "enabled"; readonly type: "bool"; }]; readonly stateMutability: "view"; }]; declare const LiquidMevDescendingFeesAbi: readonly [{ readonly type: "function"; readonly name: "blockDelay"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolUnlockTime"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }]; declare const LiquidMevBlockDelayAbi: readonly [{ readonly type: "function"; readonly name: "blockDelay"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "poolUnlockTime"; readonly inputs: readonly [{ readonly name: "poolId"; readonly type: "bytes32"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }]; declare const LiquidLpLockerAbi: readonly [{ readonly type: "function"; readonly name: "tokenRewards"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "tuple"; readonly components: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "poolKey"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "currency0"; readonly type: "address"; }, { readonly name: "currency1"; readonly type: "address"; }, { readonly name: "fee"; readonly type: "uint24"; }, { readonly name: "tickSpacing"; readonly type: "int24"; }, { readonly name: "hooks"; readonly type: "address"; }]; }, { readonly name: "positionId"; readonly type: "uint256"; }, { readonly name: "numPositions"; readonly type: "uint256"; }, { readonly name: "rewardBps"; readonly type: "uint16[]"; }, { readonly name: "rewardAdmins"; readonly type: "address[]"; }, { readonly name: "rewardRecipients"; readonly type: "address[]"; }]; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "collectRewards"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "collectRewardsWithoutUnlock"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "updateRewardAdmin"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "rewardIndex"; readonly type: "uint256"; }, { readonly name: "newAdmin"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "updateRewardRecipient"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; }, { readonly name: "rewardIndex"; readonly type: "uint256"; }, { readonly name: "newRecipient"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "version"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "string"; }]; readonly stateMutability: "view"; }]; declare const LiquidTokenAbi: readonly [{ readonly type: "function"; readonly name: "updateImage"; readonly inputs: readonly [{ readonly name: "image_"; readonly type: "string"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "updateMetadata"; readonly inputs: readonly [{ readonly name: "metadata_"; readonly type: "string"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "updateAdmin"; readonly inputs: readonly [{ readonly name: "admin_"; readonly type: "address"; }]; readonly outputs: readonly []; readonly stateMutability: "nonpayable"; }, { readonly type: "event"; readonly name: "UpdateImage"; readonly inputs: readonly [{ readonly name: "image"; readonly type: "string"; readonly indexed: false; }]; readonly anonymous: false; }, { readonly type: "event"; readonly name: "UpdateMetadata"; readonly inputs: readonly [{ readonly name: "metadata"; readonly type: "string"; readonly indexed: false; }]; readonly anonymous: false; }, { readonly type: "event"; readonly name: "UpdateAdmin"; readonly inputs: readonly [{ readonly name: "oldAdmin"; readonly type: "address"; readonly indexed: false; }, { readonly name: "newAdmin"; readonly type: "address"; readonly indexed: false; }]; readonly anonymous: false; }]; declare const LiquidUniv4EthDevBuyAbi: readonly [{ readonly type: "constructor"; readonly inputs: readonly [{ readonly name: "factory_"; readonly type: "address"; }, { readonly name: "weth_"; readonly type: "address"; }, { readonly name: "universalRouter_"; readonly type: "address"; }, { readonly name: "permit2_"; readonly type: "address"; }]; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "factory"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "weth"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "universalRouter"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "permit2"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "address"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "receiveTokens"; readonly inputs: readonly [{ readonly name: "deploymentConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "tokenConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "tokenAdmin"; readonly type: "address"; }, { readonly name: "name"; readonly type: "string"; }, { readonly name: "symbol"; readonly type: "string"; }, { readonly name: "salt"; readonly type: "bytes32"; }, { readonly name: "image"; readonly type: "string"; }, { readonly name: "metadata"; readonly type: "string"; }, { readonly name: "context"; readonly type: "string"; }, { readonly name: "originatingChainId"; readonly type: "uint256"; }]; }, { readonly name: "poolConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "hook"; readonly type: "address"; }, { readonly name: "pairedToken"; readonly type: "address"; }, { readonly name: "tickIfToken0IsLiquid"; readonly type: "int24"; }, { readonly name: "tickSpacing"; readonly type: "int24"; }, { readonly name: "poolData"; readonly type: "bytes"; }]; }, { readonly name: "lockerConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "locker"; readonly type: "address"; }, { readonly name: "rewardAdmins"; readonly type: "address[]"; }, { readonly name: "rewardRecipients"; readonly type: "address[]"; }, { readonly name: "rewardBps"; readonly type: "uint16[]"; }, { readonly name: "tickLower"; readonly type: "int24[]"; }, { readonly name: "tickUpper"; readonly type: "int24[]"; }, { readonly name: "positionBps"; readonly type: "uint16[]"; }, { readonly name: "lockerData"; readonly type: "bytes"; }]; }, { readonly name: "mevModuleConfig"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "mevModule"; readonly type: "address"; }, { readonly name: "mevModuleData"; readonly type: "bytes"; }]; }, { readonly name: "extensionConfigs"; readonly type: "tuple[]"; readonly components: readonly [{ readonly name: "extension"; readonly type: "address"; }, { readonly name: "msgValue"; readonly type: "uint256"; }, { readonly name: "extensionBps"; readonly type: "uint16"; }, { readonly name: "extensionData"; readonly type: "bytes"; }]; }]; }, { readonly name: "tokenPoolKey"; readonly type: "tuple"; readonly components: readonly [{ readonly name: "currency0"; readonly type: "address"; }, { readonly name: "currency1"; readonly type: "address"; }, { readonly name: "fee"; readonly type: "uint24"; }, { readonly name: "tickSpacing"; readonly type: "int24"; }, { readonly name: "hooks"; readonly type: "address"; }]; }, { readonly name: "token"; readonly type: "address"; }, { readonly name: "extensionSupply"; readonly type: "uint256"; }, { readonly name: "extensionIndex"; readonly type: "uint256"; }]; readonly outputs: readonly []; readonly stateMutability: "payable"; }, { readonly type: "function"; readonly name: "supportsInterface"; readonly inputs: readonly [{ readonly name: "interfaceId"; readonly type: "bytes4"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "bool"; }]; readonly stateMutability: "pure"; }, { readonly type: "event"; readonly name: "EthDevBuy"; readonly inputs: readonly [{ readonly name: "token"; readonly type: "address"; readonly indexed: true; }, { readonly name: "user"; readonly type: "address"; readonly indexed: true; }, { readonly name: "ethAmount"; readonly type: "uint256"; readonly indexed: false; }, { readonly name: "tokenAmount"; readonly type: "uint256"; readonly indexed: false; }]; readonly anonymous: false; }, { readonly type: "error"; readonly name: "InvalidEthDevBuyPercentage"; readonly inputs: readonly []; }, { readonly type: "error"; readonly name: "InvalidMsgValue"; readonly inputs: readonly []; }, { readonly type: "error"; readonly name: "InvalidPairedTokenPoolKey"; readonly inputs: readonly []; }, { readonly type: "error"; readonly name: "ReentrancyGuardReentrantCall"; readonly inputs: readonly []; }, { readonly type: "error"; readonly name: "Unauthorized"; readonly inputs: readonly []; }]; declare const ERC20Abi: readonly [{ readonly type: "function"; readonly name: "name"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "string"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "symbol"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "string"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "decimals"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint8"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "totalSupply"; readonly inputs: readonly []; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "balanceOf"; readonly inputs: readonly [{ readonly name: "account"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "allowance"; readonly inputs: readonly [{ readonly name: "owner"; readonly type: "address"; }, { readonly name: "spender"; readonly type: "address"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "uint256"; }]; readonly stateMutability: "view"; }, { readonly type: "function"; readonly name: "approve"; readonly inputs: readonly [{ readonly name: "spender"; readonly type: "address"; }, { readonly name: "value"; readonly type: "uint256"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "bool"; }]; readonly stateMutability: "nonpayable"; }, { readonly type: "function"; readonly name: "transfer"; readonly inputs: readonly [{ readonly name: "to"; readonly type: "address"; }, { readonly name: "value"; readonly type: "uint256"; }]; readonly outputs: readonly [{ readonly name: ""; readonly type: "bool"; }]; readonly stateMutability: "nonpayable"; }]; /** * Tick ↔ market cap conversion utilities for Uniswap V4 concentrated liquidity. * * All tokens have 100B supply (10^11) with 18 decimals. * Price per token = marketCap / totalSupply. * Tick = log(price) / log(1.0001), aligned to tickSpacing. */ /** * Convert an ETH-denominated market cap to a Uniswap V4 tick. * * @param marketCapETH - Market cap in ETH (e.g. 10 for a 10 ETH starting cap) * @param tickSpacing - Tick spacing to align to (default 200) * @returns Tick value (int24) aligned to tickSpacing * * @example * ```ts * getTickFromMarketCapETH(10) // → -230400 (≈10 ETH market cap) * getTickFromMarketCapETH(200) // → -200200 (≈200 ETH) * ``` */ declare function getTickFromMarketCapETH(marketCapETH: number, tickSpacing?: number): number; /** * Convert a USD-denominated market cap to a Uniswap V4 tick. * * @param marketCapUSD - Market cap in USD (e.g. 500_000 for $500K) * @param ethPriceUSD - Current ETH price in USD (e.g. 2070) * @param tickSpacing - Tick spacing to align to (default 200) * @returns Tick value (int24) aligned to tickSpacing * * @example * ```ts * getTickFromMarketCapUSD(500_000, 2070) // tick for $500K market cap * getTickFromMarketCapUSD(10_000_000, 2070) // tick for $10M market cap * ``` */ declare function getTickFromMarketCapUSD(marketCapUSD: number, ethPriceUSD: number, tickSpacing?: number): number; /** * Convert a tick back to an ETH-denominated market cap. * * @param tick - Uniswap V4 tick value * @returns Market cap in ETH * * @example * ```ts * marketCapFromTickETH(-230400) // ≈ 10 ETH * ``` */ declare function marketCapFromTickETH(tick: number): number; /** * Convert a tick to a USD-denominated market cap. * * @param tick - Uniswap V4 tick value * @param ethPriceUSD - Current ETH price in USD * @returns Market cap in USD */ declare function marketCapFromTickUSD(tick: number, ethPriceUSD: number): number; /** * Convert a market cap in a stablecoin to a tick. * Supports any stablecoin decimal count (6 for USDC, 18 for DAI, etc.) * * @param marketCap - Market cap in stablecoin units * @param stableDecimals - Decimals of the stablecoin (e.g. 6 for USDC) * @param tickSpacing - Tick spacing (default 200) * @returns Tick value aligned to tickSpacing */ declare function getTickFromMarketCapStable(marketCap: number, stableDecimals: number, tickSpacing?: number): number; /** * Multi-tranche liquidity position builder. * * Creates position arrays (tickLower[], tickUpper[], positionBps[]) from * market cap milestones. Percentages represent share of the *pool supply* * (i.e. after dev buy, airdrop, and vault allocations are deducted). */ interface MarketCapTranche { /** Upper bound market cap in ETH for this tranche */ upperMarketCapETH: number; /** Percentage of pool supply allocated to this tranche (1-100) */ supplyPct: number; } interface MarketCapTrancheUSD { /** Upper bound market cap in USD for this tranche */ upperMarketCapUSD: number; /** Percentage of pool supply allocated to this tranche (1-100) */ supplyPct: number; } interface PositionConfig { tickLower: number; tickUpper: number; positionBps: number; } interface PositionArrays { tickLower: number[]; tickUpper: number[]; positionBps: number[]; } /** * Default Liquid tranches (USD-denominated). * * - Starting → $500K market cap: 40% of pool supply * - $500K → $10M market cap: 50% of pool supply * - $10M → $1B market cap: 10% of pool supply */ declare const DEFAULT_TRANCHES_USD: MarketCapTrancheUSD[]; /** * Build position arrays from ETH-denominated market cap tranches. * * @param startingMarketCapETH - Initial market cap in ETH (determines the starting tick) * @param tranches - Array of tranches with upper market cap bounds and supply percentages * @param tickSpacing - Tick spacing (default 200) * @returns Position arrays ready to pass to `deployToken()` * * @example * ```ts * const positions = createPositions(10, [ * { upperMarketCapETH: 241.5, supplyPct: 40 }, // ~$500K at $2070/ETH * { upperMarketCapETH: 4830, supplyPct: 50 }, // ~$10M * { upperMarketCapETH: 483050, supplyPct: 10 }, // ~$1B * ]); * // → { tickLower: [-230400, -198600, -168600], * // tickUpper: [-198600, -168600, -122400], * // positionBps: [4000, 5000, 1000] } * ``` */ declare function createPositions(startingMarketCapETH: number, tranches: MarketCapTranche[], tickSpacing?: number): PositionArrays; /** * Build position arrays from USD-denominated market cap tranches. * Convenience wrapper that converts USD → ETH using the provided ETH price. * * @param startingMarketCapUSD - Initial market cap in USD * @param ethPriceUSD - Current ETH price in USD * @param tranches - Array of tranches with upper USD market cap bounds * @param tickSpacing - Tick spacing (default 200) * @returns Position arrays ready to pass to `deployToken()` * * @example * ```ts * const positions = createPositionsUSD(20_000, 2070, [ * { upperMarketCapUSD: 500_000, supplyPct: 40 }, * { upperMarketCapUSD: 10_000_000, supplyPct: 50 }, * { upperMarketCapUSD: 1_000_000_000, supplyPct: 10 }, * ]); * ``` */ declare function createPositionsUSD(startingMarketCapUSD: number, ethPriceUSD: number, tranches: MarketCapTrancheUSD[], tickSpacing?: number): PositionArrays; /** * Build default Liquid positions using the standard 3-tranche split. * * - Starting → $500K: 40% of pool supply * - $500K → $10M: 50% of pool supply * - $10M → $1B: 10% of pool supply * * @param startingMarketCapUSD - Initial market cap in USD (e.g. 20_000 for ~10 ETH) * @param ethPriceUSD - Current ETH price in USD * @param tickSpacing - Tick spacing (default 200) * * @example * ```ts * const positions = createDefaultPositions(20_000, 2070); * const tx = await sdk.deployToken({ * name: "MyToken", * symbol: "MTK", * ...positions, * }); * ``` */ declare function createDefaultPositions(startingMarketCapUSD: number, ethPriceUSD: number, tickSpacing?: number): PositionArrays & { tickIfToken0IsLiquid: number; }; /** * Shift every tick in a position layout by a fixed amount, preserving the * positionBps splits. The primitive behind `createLiquidPositionsUSD` — it * re-anchors a fixed-shape layout (e.g. `POOL_POSITIONS.Liquid`) to a * different starting tick. * * `shiftBy` should be a multiple of the pool's tick spacing so the shifted * ticks stay aligned. A difference of two aligned ticks is always aligned, * so deriving it as `targetTick - sourceBottomTick` is safe. * * @param positions - Source positions (e.g. `POOL_POSITIONS.Liquid`) * @param shiftBy - Ticks to add to every tickLower/tickUpper (may be negative) * @returns A fresh array — the source is not mutated */ declare function shiftPositions(positions: readonly PoolPosition[], shiftBy: number): PoolPosition[]; /** * Build the canonical 5-position "Liquid" layout (10/50/15/20/5) re-anchored * to a starting market cap, denominated in the *paired token's* USD price. * * Works for any pair token — pass the price of whatever the pool is paired * against: * - WETH-paired: `createLiquidPositionsUSD(20_000, ethPriceUSD)` * - DIEM-paired: `createLiquidPositionsUSD(20_000, diemPriceUSD)` * * Unlike `createDefaultPositions` (a 3-tranche layout), this preserves the * exact shape of `POOL_POSITIONS.Liquid` — the same curve `deployToken()` * uses by default — just shifted so its bottom sits at the requested start. * * @param startingMarketCapUSD - Initial market cap in USD * @param pairedTokenPriceUSD - USD price of the token the pool is paired against * @param tickSpacing - Tick spacing (default 200) * @returns Position arrays + `tickIfToken0IsLiquid`, ready to spread into `deployToken()` * * @example * ```ts * import { LiquidSDK, EXTERNAL, createLiquidPositionsUSD } from "liquid-sdk"; * * const positions = createLiquidPositionsUSD(20_000, diemPriceUSD); * await sdk.deployToken({ * name: "Agent Token", * symbol: "AGENT", * pairedToken: EXTERNAL.DIEM, * ...positions, * }); * ``` */ declare function createLiquidPositionsUSD(startingMarketCapUSD: number, pairedTokenPriceUSD: number, tickSpacing?: number): PositionArrays & { tickIfToken0IsLiquid: number; }; /** * Describe positions as human-readable market cap ranges. * Useful for displaying position info in UIs. * * @param positions - Position arrays * @param ethPriceUSD - Optional ETH price for USD display */ declare function describePositions(positions: PositionArrays, ethPriceUSD?: number): Array<{ index: number; tickLower: number; tickUpper: number; supplyPct: number; marketCapLowerETH: number; marketCapUpperETH: number; marketCapLowerUSD?: number; marketCapUpperUSD?: number; }>; /** * ABI encoding helpers for pool data, fee configs, and MEV module data. */ /** * Encode pool data for the static fee V2 hook. * * Uses two-layer encoding: * 1. Inner: static fee params [liquidFee, pairedFee] in uniBps * 2. Outer: PoolInitializationData wrapper * * @param liquidFeeBps - Fee when swapping for the liquid token (in bps, e.g. 100 = 1%) * @param pairedFeeBps - Fee when swapping for the paired token (in bps, e.g. 100 = 1%) * @param extension - Optional pool extension address (defaults to zero) * @param extensionData - Optional pool extension init data (defaults to "0x") * @returns Encoded poolData hex string * * @example * ```ts * // 1% fee both directions (default) * const poolData = encodeStaticFeePoolData(100, 100); * ``` */ declare function encodeStaticFeePoolData(liquidFeeBps: number, pairedFeeBps: number, extension?: `0x${string}`, extensionData?: Hex): Hex; interface DynamicFeeConfig { /** Base LP fee in bps (e.g. 100 = 1%) */ baseFeeBps: number; /** Max LP fee in bps (e.g. 500 = 5%) */ maxFeeBps: number; /** Reference tick filter period in seconds */ referenceTickFilterPeriod: number; /** Reset period in seconds */ resetPeriod: number; /** Reset tick filter (tick units) */ resetTickFilter: number; /** Fee control numerator (scaling constant) */ feeControlNumerator: bigint; /** Decay filter in bps */ decayFilterBps: number; } /** * Encode pool data for the dynamic fee V2 hook. * * @param config - Dynamic fee configuration * @param extension - Optional pool extension address * @param extensionData - Optional pool extension init data * @returns Encoded poolData hex string */ declare function encodeDynamicFeePoolData(config: DynamicFeeConfig, extension?: `0x${string}`, extensionData?: Hex): Hex; interface SniperAuctionConfig { /** Starting fee in uniBps (e.g. 800_000 = 80%) */ startingFee: number; /** Ending fee in uniBps (e.g. 400_000 = 40%) */ endingFee: number; /** Seconds for fee to decay from starting to ending */ secondsToDecay: number; } /** * Encode MEV module data for the Sniper Auction V2. * * @param config - Sniper auction fee configuration * @returns Encoded mevModuleData hex string * * @example * ```ts * // 80% → 40% over 20 seconds (default) * const mevData = encodeSniperAuctionData({ * startingFee: 800_000, * endingFee: 400_000, * secondsToDecay: 20, * }); * ``` */ declare function encodeSniperAuctionData(config: SniperAuctionConfig): Hex; /** * Fee preference for LP_LOCKER_FEE_CONVERSION. * Determines which token each reward recipient receives their fees in. * * - `Both` (0): No conversion, fees paid in whichever token accrues * - `Paired` (1): Convert fees to paired token (usually WETH) * - `Liquid` (2): Convert fees to the liquid token */ declare enum FeePreference { Both = 0, Paired = 1, Liquid = 2 } /** * Encode lockerData for LP_LOCKER_FEE_CONVERSION. * * The fee conversion locker requires a `FeeIn[]` array with one entry per * reward recipient, specifying how each recipient wants their fees. * * @param feePreferences - Array of FeePreference values, one per reward recipient * @returns Encoded lockerData hex string * * @example * ```ts * // Single recipient, fees converted to WETH * const lockerData = encodeFeeConversionLockerData([FeePreference.Paired]); * * // Two recipients: first gets ETH, second gets the token * const lockerData = encodeFeeConversionLockerData([FeePreference.Paired, FeePreference.Liquid]); * ``` */ declare function encodeFeeConversionLockerData(feePreferences: FeePreference[]): Hex; /** Provenance — who launched the token and from where. */ interface LiquidContext { /** System that deployed the token (e.g. "SDK", "Rainbow Wallet", "Liquid CLI") */ interface: string; /** Social platform origin (e.g. "Farcaster", "Twitter") */ platform?: string; /** Social post/message ID that triggered the deploy */ messageId?: string; /** User ID on the originating platform */ id?: string; } /** Social media link for token metadata. */ interface SocialMediaUrl { platform: string; url: string; } /** Token info for aggregators and explorers. */ interface LiquidMetadata { /** Token/project description */ description?: string; /** Social media links */ socialMediaUrls?: SocialMediaUrl[]; /** Audit report URLs */ auditUrls?: string[]; } /** * Build a JSON string for the on-chain `context` field. * * @example * buildContext({ interface: "My App", platform: "Farcaster" }) * // '{"interface":"My App","platform":"Farcaster"}' */ declare function buildContext(input?: Partial): string; /** * Build a JSON string for the on-chain `metadata` field. * * @example * buildMetadata({ description: "A cool token" }) * // '{"description":"A cool token"}' */ declare function buildMetadata(input?: Partial): string; /** * Parse a context JSON string back into a typed object. * Returns `null` if the string is empty or not valid JSON. */ declare function parseContext(contextString: string): LiquidContext | null; /** * Parse a metadata JSON string back into a typed object. * Returns `null` if the string is empty or not valid JSON. */ declare function parseMetadata(metadataString: string): LiquidMetadata | null; export { ADDRESSES, type AirdropExtensionParams, type AirdropInfo, type BidInAuctionParams, type BidInAuctionResult, DEFAULTS, DEFAULT_CHAIN, DEFAULT_CHAIN_ID, DEFAULT_RPC_URL, DEFAULT_TRANCHES_USD, type DeployTokenParams, type DeployTokenResult, type DeploymentConfig, type DeploymentInfo, type DevBuyParams, type DynamicFeeConfig, ERC20Abi, EXTERNAL, type ExtensionConfig, FEE, FeePreference, type GetTokensOptions, LiquidAirdropV2Abi, type LiquidContext, LiquidFactoryAbi, LiquidFeeLockerAbi, LiquidHookDynamicFeeV2Abi, LiquidLpLockerAbi, type LiquidMetadata, LiquidMevBlockDelayAbi, LiquidMevDescendingFeesAbi, LiquidPoolExtensionAllowlistAbi, LiquidSDK, type LiquidSDKConfig, LiquidSniperAuctionV2Abi, LiquidSniperUtilV2Abi, LiquidTokenAbi, LiquidUniv4EthDevBuyAbi, LiquidVaultAbi, type LockerConfig, type MarketCapTranche, type MarketCapTrancheUSD, type MevModuleConfig, POOL_POSITIONS, type PoolConfig, type PoolDynamicConfigVars, type PoolDynamicFeeVars, type PoolKey, type PoolPosition, type PositionArrays, type PositionConfig, type SniperAuctionConfig, type SniperAuctionFeeConfig, type SniperAuctionState, type SocialMediaUrl, TOKEN, type TokenConfig, type TokenCreatedEvent, type TokenRewardInfo, type VaultAllocation, type VaultExtensionParams, buildContext, buildMetadata, createDefaultPositions, createLiquidPositionsUSD, createPositions, createPositionsUSD, describePositions, encodeDynamicFeePoolData, encodeFeeConversionLockerData, encodeSniperAuctionData, encodeStaticFeePoolData, getTickFromMarketCapETH, getTickFromMarketCapStable, getTickFromMarketCapUSD, marketCapFromTickETH, marketCapFromTickUSD, parseContext, parseMetadata, shiftPositions };