Struct TipFeeManager 

pub struct TipFeeManager {
    pub validator_tokens: <Mapping<Address, Address> as StorableType>::Handler,
    pub user_tokens: <Mapping<Address, Address> as StorableType>::Handler,
    pub collected_fees: <Mapping<Address, Mapping<Address, Uint<256, 4>>> as StorableType>::Handler,
    pub pools: <Mapping<FixedBytes<32>, Pool> as StorableType>::Handler,
    pub total_supply: <Mapping<FixedBytes<32>, Uint<256, 4>> as StorableType>::Handler,
    pub liquidity_balances: <Mapping<FixedBytes<32>, Mapping<Address, Uint<256, 4>>> as StorableType>::Handler,
    pub pending_fee_swap_reservation: <Mapping<FixedBytes<32>, u128> as StorableType>::Handler,
    pub two_hop_intermediate: <Address as StorableType>::Handler,
    address: Address,
    storage: StorageCtx,
}

Fields

validator_tokens: <Mapping<Address, Address> as StorableType>::Handler

user_tokens: <Mapping<Address, Address> as StorableType>::Handler

collected_fees: <Mapping<Address, Mapping<Address, Uint<256, 4>>> as StorableType>::Handler

pools: <Mapping<FixedBytes<32>, Pool> as StorableType>::Handler

total_supply: <Mapping<FixedBytes<32>, Uint<256, 4>> as StorableType>::Handler

liquidity_balances: <Mapping<FixedBytes<32>, Mapping<Address, Uint<256, 4>>> as StorableType>::Handler

pending_fee_swap_reservation: <Mapping<FixedBytes<32>, u128> as StorableType>::Handler

two_hop_intermediate: <Address as StorableType>::Handler

address: Address

storage: StorageCtx

Implementations

impl TipFeeManager

pub fn pool_id( &self, user_token: Address, validator_token: Address, ) -> FixedBytes<32>

Returns the deterministic pool ID for a directional token pair. Note that the pool id is order-dependent: (A, B) produces a different ID than (B, A).

pub fn get_pool(&self, call: getPoolCall) -> Result<Pool, TempoPrecompileError>

Returns the [Pool] reserves for the given user/validator token pair.

pub fn reserve_pool_liquidity( &mut self, pool_id: FixedBytes<32>, amount: u128, ) -> Result<(), TempoPrecompileError>

Reserves pool liquidity in transient storage for a pending fee swap.

pub fn rebalance_swap( &mut self, msg_sender: Address, user_token: Address, validator_token: Address, amount_out: Uint<256, 4>, to: Address, ) -> Result<Uint<256, 4>, TempoPrecompileError>

Executes a rebalance swap: sells amount_out of user-token from the pool in exchange for validator-token at the rebalance rate (N / SCALE). Used by arbitrageurs to rebalance reserves.

Errors

• InvalidAmount — amount_out is zero or exceeds u128
• InsufficientReserves — adding amount_in overflows the validator reserve
• InsufficientLiquidity — remaining reserve would violate the pending reservation (T1C+)
• UnderOverflow — arithmetic overflow computing amount_in

pub fn mint( &mut self, msg_sender: Address, user_token: Address, validator_token: Address, amount_validator_token: Uint<256, 4>, to: Address, ) -> Result<Uint<256, 4>, TempoPrecompileError>

Mints LP tokens by depositing validator-token into a pool.

On first deposit the pool is initialized with equal reserves and [MIN_LIQUIDITY] is permanently locked. Subsequent deposits mint pro-rata to existing supply. Both tokens must be distinct, USD-denominated TIP-20s.

NOTE: Validators who also provide liquidity have an information advantage over non-validator LPs. Because validators choose their preferred fee token and control transaction inclusion order as block producers, a validator-LP can predict which pool will receive fee-swap revenue and position liquidity accordingly.

Errors

• IdenticalAddresses — user_token equals validator_token
• InvalidAmount — amount_validator_token is zero or exceeds u128
• InvalidCurrency — either token is not USD-denominated
• InsufficientLiquidity — initial deposit ≤ MIN_LIQUIDITY, or zero liquidity minted
• InvalidSwapCalculation — pro-rata arithmetic fails
• UnderOverflow — supply or balance overflow

pub fn burn( &mut self, msg_sender: Address, user_token: Address, validator_token: Address, liquidity: Uint<256, 4>, to: Address, ) -> Result<(Uint<256, 4>, Uint<256, 4>), TempoPrecompileError>

Burns LP tokens and returns the pro-rata share of both pool tokens to to.

On T1C+ the burn is rejected if the remaining validator-token reserve would fall below the pending fee-swap reservation set by TipFeeManager::reserve_pool_liquidity.

Errors

• IdenticalAddresses — user_token equals validator_token
• InvalidAmount — liquidity is zero or amounts exceed u128
• InvalidCurrency — either token is not USD-denominated
• InsufficientLiquidity — caller’s balance < liquidity, or remaining reserve would violate the pending reservation (T1C+)
• InsufficientReserves — pool reserves underflow after withdrawal
• UnderOverflow — supply or balance arithmetic overflows

pub fn plan_fee_route( &self, user_token: Address, validator_token: Address, max_amount: Uint<256, 4>, ) -> Result<(Option<FeeRoute>, Option<Address>, Vec<((Address, Address), u128)>), TempoPrecompileError>

Plans the AMM path needed to swap max_amount of user_token into validator_token under the active hardfork. Read-only; does not reserve.

On T5+ falls back to a two-hop path through userToken.quoteToken() as per TIP-1033. Returns (route, queried_intermediate, pools):

• route is None when no path has sufficient liquidity.
• queried_intermediate is Some(addr) whenever userToken.quoteToken() was read, regardless of whether the value is usable. Callers can cache it to skip the cold storage read on subsequent admissions.
• pools lists every pool slot read during planning, paired with its observed reserve.

Errors

• InvalidToken — user_token does not have a valid TIP-20 prefix
• UnderOverflow — fee-amount arithmetic overflows

pub fn execute_fee_swap( &mut self, user_token: Address, validator_token: Address, amount_in: Uint<256, 4>, ) -> Result<Uint<256, 4>, TempoPrecompileError>

Executes a fee swap, converting user_token to validator_token at a fixed rate m = 0.997 Called internally by TipFeeManager::collect_fee_post_tx during post-tx fee collection.

Errors

• InsufficientLiquidity — pool validator-token reserve is below the required output
• UnderOverflow — reserve arithmetic overflows or amounts exceed u128

pub fn get_total_supply( &self, pool_id: FixedBytes<32>, ) -> Result<Uint<256, 4>, TempoPrecompileError>

Returns the total supply of LP tokens for the given pool.

pub fn get_liquidity_balances( &self, pool_id: FixedBytes<32>, user: Address, ) -> Result<Uint<256, 4>, TempoPrecompileError>

Returns the LP token balance for user in the given pool.

impl TipFeeManager

pub fn new() -> TipFeeManager

Creates an instance of the precompile.

Caution: This does not initialize the account, see Self::initialize.

impl TipFeeManager

pub const FEE_BPS: u64 = 25

Swap fee in basis points (0.25%).

pub const BASIS_POINTS: u64 = 10000

Basis-point denominator (10 000 = 100%).

pub const MINIMUM_BALANCE: Uint<256, 4>

Minimum TIP-20 balance required for fee operations (1e9).

pub fn initialize(&mut self) -> Result<(), TempoPrecompileError>

Initializes the fee manager precompile.

pub fn get_validator_token( &self, beneficiary: Address, ) -> Result<Address, TempoPrecompileError>

Returns the validator’s preferred fee token, falling back to [DEFAULT_FEE_TOKEN].

pub fn set_validator_token( &mut self, sender: Address, call: setValidatorTokenCall, beneficiary: Address, ) -> Result<(), TempoPrecompileError>

Sets the caller’s preferred fee token as a validator.

Rejects the call if sender is the current block’s beneficiary (prevents mid-block fee-token changes) or if the token is not a valid USD-denominated TIP-20 registered in [TIP20Factory].

Errors

• InvalidToken — token is not a deployed TIP-20 in [TIP20Factory]
• CannotChangeWithinBlock — sender equals the current block beneficiary
• InvalidCurrency — token is not USD-denominated

pub fn set_user_token( &mut self, sender: Address, call: setUserTokenCall, ) -> Result<(), TempoPrecompileError>

Sets the caller’s preferred fee token as a user. Must be a valid USD-denominated TIP-20 registered in [TIP20Factory].

Errors

• InvalidToken — token is not a deployed TIP-20 in [TIP20Factory]
• InvalidCurrency — token is not USD-denominated

pub fn collect_fee_pre_tx( &mut self, fee_payer: Address, user_token: Address, max_amount: Uint<256, 4>, beneficiary: Address, skip_liquidity_check: bool, ) -> Result<Address, TempoPrecompileError>

Collects fees from fee_payer before transaction execution.

Transfers max_amount of user_token to the fee manager via [TIP20Token] and, if the validator prefers a different token, verifies sufficient pool liquidity. Reserves liquidity on T1C+, with a two-hop fallback through userToken.quoteToken() on T5+. Returns the user’s fee token.

Errors

• InvalidToken — user_token does not have a valid TIP-20 prefix
• PolicyForbids — TIP-403 policy rejects the fee token transfer
• InsufficientLiquidity — AMM pool lacks liquidity for the fee swap (T5+: with two-hop fallback)

pub fn collect_fee_post_tx( &mut self, fee_payer: Address, actual_spending: Uint<256, 4>, refund_amount: Uint<256, 4>, fee_token: Address, beneficiary: Address, ) -> Result<Uint<256, 4>, TempoPrecompileError>

Finalizes fee collection after transaction execution.

Refunds unused user_token to fee_payer via [TIP20Token], executes the fee swap through the AMM pool if tokens differ, and accumulates fees for the validator. Returns the validator-credited amount (post-feeAMM haircut, in the validator’s fee token), which is used by the payload builder to score blocks by actual proposer revenue.

Errors

• InvalidToken — fee_token does not have a valid TIP-20 prefix
• InsufficientLiquidity — AMM pool lacks liquidity for the fee swap
• UnderOverflow — collected-fee accumulator overflows

pub fn distribute_fees( &mut self, validator: Address, token: Address, ) -> Result<(), TempoPrecompileError>

Transfers a validator’s accumulated fee balance to their address via [TIP20Token] and zeroes the ledger. No-ops when the balance is zero.

Errors

• InvalidToken — token does not have a valid TIP-20 prefix

pub fn user_tokens( &self, call: userTokensCall, ) -> Result<Address, TempoPrecompileError>

Reads the stored fee token preference for a user.

impl TipFeeManager

pub fn create_precompile(cfg: &CfgEnv<TempoHardfork>) -> DynPrecompile

Creates the EVM precompile for this type.

Trait Implementations

impl ContractStorage for TipFeeManager

fn address(&self) -> Address

Contract address.

fn storage(&self) -> &StorageCtx

Contract storage accessor.

fn storage_mut(&mut self) -> &mut StorageCtx

Contract storage mutable accessor.

fn is_initialized(&self) -> Result<bool, TempoPrecompileError>

Returns true if the contract has been initialized (has bytecode deployed).

impl Default for TipFeeManager

fn default() -> TipFeeManager

Returns the “default value” for a type.

impl Precompile for TipFeeManager

fn call( &mut self, calldata: &[u8], msg_sender: Address, ) -> Result<PrecompileOutput, PrecompileError>

Dispatches an EVM call to this precompile.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 816 bytes