# Infinite Trading Protocol

Infinite Trading Protocol documentation

Infinite Trading Protocol (ITP) is a DeFi infrastructure and product ecosystem for automated strategies, onchain vaults, and execution APIs.

This documentation is focused on the current ITP stack:

* ITP-native vault products (Uniswap and Velodrome auto-compounders)
* Infinite Trading Perpetuals (Orderly deployment)
* Strategy automation infrastructure (Infinite Trading Cloud)
* stSATO and cbEGGS ecosystem deployments
* API gateway + execution layer for automated portfolio actions
* Value accrual model around ITP utility and usage

## Why this matters

Infinite Trading is built for users who want:

* automated strategy exposure without giving up custody
* transparent onchain execution
* composable products across Base and Optimism ecosystems
* performance-focused vault design with clear fee mechanics

## ITP value flow

At a high level:

1. More users deposit into ITP-aligned vaults and strategies.
2. More strategy volume and automation activity flows through ITP infrastructure.
3. More fee-generating actions happen (vault flows, compounding, API actions).
4. More ecosystem visibility and utility is created for ITP-based products.
5. New vaults and strategy surfaces launch on top of the same stack.

## Where to start

Recommended reading order:

* **Infinite Trading App** for user workflows
* **ITP Token & Staking** for token utility and rewards context
* **Vaults** for strategy descriptions
* **API** for builders and automation teams

> This documentation is informational only and is not financial advice.


# Infinite Trading App

Infinite Trading App overview

The Infinite Trading App is the user layer for participating in ITP-powered vaults, automation strategies, and ecosystem products.

## What the app does

* Connects self-custody wallets to strategy vaults
* Shows live vault metrics and performance context
* Provides one-click entry/exit flows for supported products
* Surfaces risk/performance data in a way users can act on

## Core product surfaces

1. **Vault marketplace**
   * Uniswap auto-compounders
   * Velodrome auto-compounders
   * Agentic Managed Vaults (Infinite Trading Cloud)
2. **Perpetuals interface**
   * Infinite Trading Perpetuals powered by Orderly infrastructure
   * Live access: `https://perps.infinitetrading.io`
3. **ITP ecosystem pages**
   * ITP utility and staking context
   * stSATO and cbEGGS deployment context
   * Fee and value-accrual explanation
4. **Builder and manager tooling**
   * API gateway for automation
   * Strategy control via authenticated API routes
   * Introspection docs for AI agents (`/llmIntrospect`)
   * Manager workflows for gas wallets, API keys, approvals, and bot setup

## Quick links

* [✨ Benefits](/introduction/infinite-trading-app/benefits)
* [🛠️ Setup workflow](/introduction/infinite-trading-app/getting-set-up)
* [💰 Understanding Fees](/introduction/infinite-trading-app/understanding-fees)

## Who this is for

* Users who want strategy exposure without custody risk
* Advanced users who want LP and compounding products
* Managers and builders who want programmable strategy execution


# Benefits

## Self-custody first

Users connect self-custody wallets and interact directly with vault contracts. Asset control remains with the wallet owner before and after each transaction.

## Strategy infrastructure

Infinite Trading combines:

* strategy logic from Infinite Trading Cloud
* vault wrappers with explicit fee mechanics
* API-managed automation for operations at scale
* frontends that expose metrics and controls clearly

## Why users are interested in ITP

ITP utility grows as products are used:

1. **Vault participation and LP products**
2. **Auto-compounder reward flows across supported pools**
3. **Ecosystem deployments (including cbEGGS and stSATO context)**
4. **API and automation usage by strategy operators**

This supports token utility through measurable product usage across the ecosystem.

## Transparent execution

* Onchain deposits, withdrawals, and compounding
* Clear fee disclosure at product level
* Performance tooling (alpha and drawdown context where available)
* Public contract integrations and auditable addresses


# Setup Workflow

Setup guide for Infinite Trading vault participation

## 1) Create a wallet

* Install Rabby or MetaMask
* Secure the seed phrase offline
* Keep a small gas balance on the selected network

## 2) Fund the wallet

* Buy assets on an exchange and withdraw to the wallet
* For Base/Optimism products, bridge or withdraw directly to the target chain
* Keep gas token available for approvals and transactions

## 3) Connect to the app

* Open the Infinite Trading frontend
* Connect wallet
* Switch to the required network when prompted

## 4) Execute initial vault deposit

1. Choose a vault
2. Select input token and amount
3. Approve token spending
4. Submit deposit (or zap if supported)
5. Confirm transaction in wallet

## 5) Track and manage position

* Review position share and current value
* Monitor vault performance metrics and benchmark context
* Withdraw partially or fully based on strategy requirements

## 6) Operational best practices

* Start with smaller size to understand strategy behavior
* Avoid deploying all capital in one vault
* Read each vault's strategy profile before depositing
* Keep realistic expectations: returns and risk both vary across market regimes


# Understanding Fees

Decoding Fees in Digital Asset Transactions

Infinite Trading products can include several fee layers depending on the vault or API action.

## Vault-level fees

* **Management fees** (where configured): ongoing operational compensation
* **Performance fees** (where configured): charged only when strategy gains are realized above the relevant threshold model
* **Entry/exit mechanics**: depending on vault type, deposits/withdrawals can include product-specific fee logic

## Auto-compounder fee mechanics

In the Uniswap auto-compounder integrations:

* **Zap-in fee** can apply on single-token entry
* **Compounding fee split** includes DAO and executor allocation

In Velodrome auto-compounder operations:

* Rewards are harvested and restaked
* Harvester incentive logic can include an ITP-denominated reward path

## API monetization fees

The API layer includes action-based pricing for automation operations (for example trade/approve/lend/borrow classes), while many read endpoints remain free-tier usage surfaces.

This model allows:

* sustainable infrastructure operation
* gas wallet abstraction for strategy operators
* programmable execution across networks

## User impact

* Fees are explicit and tied to concrete operations.
* Most user-facing vault analytics already reflect net behavior after fee effects.
* Fee-backed infrastructure helps keep products maintained and evolving.

> Always review fee settings of a specific vault or endpoint before transacting.


# Infinite Trading Perpetuals

Infinite Trading Perpetuals overview

Infinite Trading Perpetuals is the ITP perpetual futures product deployment, built on Orderly infrastructure.

## Access

* Live product: `https://perps.infinitetrading.io`

## What it provides

* Onchain-aligned perpetual trading experience through the Infinite Trading interface
* Long and short market exposure with perpetual instruments
* Unified product surface alongside the rest of the ITP ecosystem

## Why it is part of the ITP stack

* Extends the protocol from vault-based strategies into perpetual trading
* Broadens active user flows and strategy coverage across ITP products
* Complements API, vault, and manager workflows for advanced participants

## Product positioning

Infinite Trading Perpetuals is positioned as the derivatives layer of the ecosystem, while vaults and Agentic Managed Vaults remain the structured strategy layer.


# ITP Token & Staking

This section documents the ITP staking implementation used in production flows.

## Network and contract addresses (current Staking V1 flow)

| Item                                | Network  | Address                                      |
| ----------------------------------- | -------- | -------------------------------------------- |
| ITP token (staking asset)           | Optimism | `0x0a7B751FcDBBAA8BB988B9217ad5Fb5cfe7bf7A0` |
| Staking vault contract (Staking V1) | Optimism | `0x23371aEEaF8718955C93aEC726b3CAFC772B9E37` |
| Price oracle used by staking UI     | Optimism | `0x395942C2049604a314d39F370Dfb8D87AAC89e16` |

## What Staking V1 does

Staking V1 lets users lock ITP with lock multipliers (1–4 years), then withdraw when unlocked or early-withdraw with penalty logic.

Core user actions:

1. Approve ITP to staking vault
2. Deposit with selected lock multiplier
3. Track lock entries and unlock timestamps
4. Withdraw on unlock (or early withdraw with penalty)
5. Optionally extend lock

## Core staking actions and methods

Staking V1 exposes the following primary methods:

* `deposit(uint256 amount, uint256 lockMultiplier)`
* `withdraw(uint256[] tokenIds)`
* `earlyWithdraw(uint256 tokenId)`
* `extendLock(uint256 tokenId, uint256 lockMultiplier)`
* `getStakeInfo(address account)`
* `getVaultInfo()`

Operational methods also include:

* `depositRewards(uint256 amount)`
* `withdrawRewards(uint256 amount)`
* `withdrawPenalty(uint256 amount)`
* `burnPenalty(uint256 amount)`
* `convertPenaltyIntoRewards(uint256 amount)`

## Staking metrics shown in the app

The staking interface displays:

* `totalStaked`
* `totalRewards`
* `totalRewardsLeft`
* `totalPenalty`
* `totalPenaltyBurned`
* `rewardsRatePerLockMultiplierBps`
* `penaltyRateBps`

Staking behavior includes:

* dynamic APY by lock period (1Y/2Y/3Y/4Y)
* rewards projection by amount + lock duration
* early-withdraw penalty explanation (decreasing over lock time)
* lock table with status and action buttons

## Interface behavior

The app workflow includes approvals, lock creation, lock extension, standard withdrawal after unlock, and early withdrawal with penalty conditions.

## Burns and penalties relationship

Staking penalties and burn metrics are part of the staking contract state model (`totalPenalty`, `totalPenaltyBurned`) and are surfaced in frontend staking analytics.

For broader ecosystem burn context (including operations and revenue linkage), see [🔥 ITP Burns](/introduction/itp-burns).

## Practical notes for users

* Staking is on Optimism in the current documented flow.
* Always verify contract address in-app before transacting.
* Early withdraw can reduce principal via penalty path.
* Lock duration choice materially changes reward profile and liquidity flexibility.


# ITP Burns

ITP burn activity is tied to ecosystem operations.

## Why burns exist

The burn mechanism is used to reduce circulating supply over time and align long-term token value with real protocol usage.

## Burn sources

In the current ecosystem model, burns can be driven by:

1. **Revenue-linked operations** (treasury/fee allocation policies)
2. **Automated operational flows** where configured
3. **DAO-led burn actions** visible onchain

## Onchain tracking

ITP burn history is tracked and can be surfaced in frontend tooling, including:

* total burn count
* average burn size
* latest burn activity
* transaction-level history to burn addresses

Burn-address tracking commonly includes:

* `0x000000000000000000000000000000000000dead`
* `0x0000000000000000000000000000000000000000`

## Token context used in burn tracking

* **ITP (Optimism, Staking V1 token in app flows)**: `0x0a7B751FcDBBAA8BB988B9217ad5Fb5cfe7bf7A0`
* **ITP (Optimism, legacy burn-history dataset token)**: `0x2aF68d8e6f0964789e3ee0e54427258B69E9B8F0`
* Initial supply reference used in burn dashboards: `1,000,000,000 ITP`

## Why this matters for holders

Burn mechanics should be assessed alongside overall product usage across vaults, LP products, and automation infrastructure.


# Vaults

Infinite Trading vaults are built to package advanced onchain strategy execution into simple deposit/withdraw user experiences.

## Vault families

1. **Uniswap auto-compounders (Base-focused in current deployment set)**
2. **Velodrome auto-compounders (Optimism-focused in current deployment set)**
3. **Agentic Managed Vaults (Infinite Trading Cloud signal + execution automation)**

## What users should expect

* transparent onchain interactions
* strategy-specific risk/return profiles
* periodic compounding or active rebalancing depending on product
* clear fee models defined by vault architecture

## About strategy descriptions

This documentation describes strategy intent, behavior, and risk profile at an architectural level.


# Uniswap Auto-Compounders

Uniswap auto-compounder vaults convert concentrated liquidity management into a structured vault-share model.

## How they work (high level)

1. User deposits through dual-token or zap flow
2. Vault maintains LP position
3. Fees are harvested and reinvested
4. User shares represent proportional ownership

## Current ITP-aligned deployment examples

* ITP/USDC
* cbEGGS/WETH
* ITP/cbXRP

## Strategy mechanics

* disciplined fee harvesting cadence
* automated reinvestment logic
* slippage-aware execution paths
* strategy-level controls around pool selection and maintenance

## Why users like this model

* no need to manually harvest/rebalance LP positions
* compounding can improve long-term efficiency
* easier access to sophisticated LP behavior in a single product


# Velodrome Auto-Compounders

Velodrome auto-compounders target Optimism LP opportunities with automated reward harvesting and restaking.

## Core flow

1. Claim gauge rewards
2. Convert rewards into pool components
3. Add liquidity
4. Restake for continued yield accumulation

## Current pool universe (ITP stack)

Examples include:

* ITP/VELO
* ITP/DHT
* ITP/wstETH
* ITP/OP
* ITP/WBTC
* ITP/USDC

## Strategy profile

* automation-first compounding cadence
* low-touch user operation after deposit
* designed for repeatable growth across multiple LP pairs

## Key benefit

Users get exposure to Velodrome reward mechanics without manually running the harvest/compound cycle themselves.


# Agentic Managed Vaults (Infinite Trading Cloud)

These vaults are connected to Infinite Trading Cloud strategy infrastructure and API-managed execution, with automated controllers managing risk posture and vault state transitions.

## What makes them different

* strategy signal generation and updates from cloud workflows
* operational control via authenticated API actions
* deployable across multiple supported EVM networks
* automated risk-management loops that shift side/exposure based on strategy state

## Strategy styles

* **Trend-following rotations**: switch between risk-on and defensive states
* **Neutral/cash states**: preserve optionality during weak conditions
* **Pair-specific automation**: asset-focused strategy execution with bounded trade parameters
* **Yield overlays**: lend/compound integrations where enabled

## Operational architecture

* strategy side updates through API (`setBot` style control)
* vault composition checks and approval gates
* gas-wallet-based execution model for automation
* continuous agent-driven monitoring and execution decisions

## What users should understand

* performance can differ by market regime
* active automation improves consistency, not certainty
* performance depends on disciplined execution across market regimes


# Managers: Deploy Vaults & Tradebots

This page is for managers using the frontend manager area and API to deploy and operate Agentic Managed Vaults.

## Frontend manager navigation map

Manager interface sections:

* **Gas Wallets** (<https://www.infinitetrading.io/managers?section=gaswallets>): create, associate, monitor, and refill gas wallets
* **Managed Vaults** (<https://www.infinitetrading.io/managers?section=vaults>): review vaults and trader linkage
* **API Linked Vaults** (<https://www.infinitetrading.io/managers?section=api>): verify vault-to-gas-wallet associations
* **Trading Bots** (<https://www.infinitetrading.io/managers?section=bots>): deploy bots, edit parameters, and generate API code snippets
* **Create Vault** (`Create Vault` tab in manager navigation): create a new dHEDGE vault from the manager workflow

## What this guide covers

* creating and securing gas wallet credentials
* refilling gas wallets from the frontend ("Fill Gas Tank" flow)
* creating a vault and setting trader permissions
* approving assets and deploying the bot
* generating tradebot code snippets for automation

## Prerequisites

* Manager access in the frontend manager area
* A vault address (created on dHEDGE app flow)
* Supported network selection (Optimism, Base, Arbitrum, or Polygon where applicable)

## Step 1) Create and secure a gas wallet

Generate a wallet from **Gas Wallets** (backed by `GET /createGasWallet`).

The generated payload includes:

* gas wallet address
* private key
* gas-wallet API key

Immediately:

* back up private key and API key in secure storage
* associate the wallet in the manager flow so it appears in the manager wallet list

## Step 2) Refill the gas tank in the frontend

In **Gas Wallets**, **Managed Vaults**, and **Trading Bots**, each linked wallet shows a gas-tank icon.

1. Click the gas-tank icon (**Click to refill**)
2. Confirm network and destination wallet in the refill modal
3. Enter amount (USD), use MAX or percentage shortcuts if needed
4. Submit **Refill** and confirm wallet transaction

Operational notes:

* ETH is used on Optimism/Base/Arbitrum/Ethereum
* POL is used on Polygon
* Balance checks are available through `GET /getGasBalance?apiKey=...&network=...`

## Step 3) Create vault and assign trader permission

Create the vault in the dHEDGE flow, then set the gas wallet as **Trader** for that vault.

Verify trader assignment:

`GET /isPoolTrader?apiKey=...&protocol=dhedge&network=...&pool=...`

## Step 4) Deploy the tradebot from Trading Bots

Before bot trades can run, approve each required asset:

`POST /approve`

Typical payload fields include:

* `apiKey`
* `network`
* `protocol` (`dhedge`)
* `pool` (vault address)
* `asset` (e.g., USDC, WETH, WBTC, MORPHO)
* `platform` (e.g., odos)

Then configure bot parameters and deploy through `POST /setBot`:

`pair`, `side`, `threshold`, `slippage`, `share`, `platform`, `lending`

## Step 5) Generate tradebot code snippets in the frontend

In **Trading Bots**:

1. Open create/edit bot dialog
2. Click **Show API Code**
3. Select output format:
   * Webhook URL
   * Python
   * R
   * JavaScript
4. Copy snippet and run it in the target automation environment

These snippets are generated from the current bot payload, matching the selected vault, pair, network, and side.

## Step 6) Verify bot status

`GET /getBotStatus?apiKey=...&protocol=dhedge&network=...&pool=...`

Use this to confirm side, pair, and active status.

## Step 7) Optional immediate trade

For immediate positioning:

`POST /vaultTrade`

with `from`, `to`, `share`, `slippage`, and routing fields.

## Common manager mistakes

* not funding gas wallet before approvals/trades
* forgetting to add gas wallet as vault Trader
* skipping the refill step after creating a new gas wallet
* calling `setBot` before approvals are done
* misconfigured side/share/slippage values

## Security checklist

* rotate/restrict keys in internal systems
* never expose private keys in frontend bundles
* use dedicated wallets per strategy cluster
* monitor gas wallet balances continuously


# ChamberFi (previously dHEDGE)

ChamberFi is the continuation of the earlier dHEDGE product line and remains an important protocol layer in manager and vault workflows.

## Protocol role

ChamberFi provides managed-vault infrastructure where:

* vault managers define strategy mandates
* users deposit into shared vault structures
* portfolio actions execute through onchain transactions
* performance and position states remain transparent onchain

## Relevance to Infinite Trading

Within the ITP ecosystem, ChamberFi-aligned flows are used for:

* manager vault operations
* trader permission workflows
* strategy execution through API-linked automation
* bot-controlled side and allocation updates

## Operational model

The standard workflow is:

1. Create or select a compatible vault.
2. Configure trader permissions for the execution wallet.
3. Set asset approvals required for strategy routes.
4. Apply strategy parameters through bot configuration.
5. Monitor positions, balances, and strategy state continuously.

## Risk and controls

* execution quality depends on liquidity and route conditions
* manager permissions should be restricted and audited
* gas-wallet balances must be maintained to avoid operational interruptions
* all contract interactions should be verified in the live interface before submission


# Velodrome in the ITP Stack

Velodrome's role in Infinite Trading products

Velodrome is a key execution and yield layer for ITP products on Optimism.

## Why it matters for Infinite Trading

* Deep LP markets for ITP-aligned pairs
* Native gauge rewards that can be harvested and compounded
* Low-friction operational environment for automated vault upkeep

## Velodrome auto-compounder model

Current ITP operations include daily harvest/compound flows across multiple Velodrome pools.

The process is straightforward:

1. harvest rewards
2. swap into LP components
3. add liquidity
4. restake
5. distribute configured incentive path

## Product implications for users

* less manual reward management
* more consistent compounding cadence
* cleaner UX for LP holders who want automation

## Impact on ITP ecosystem operations

As more TVL moves through ITP-connected Velodrome products, the ITP ecosystem gets:

* broader token utility across active products
* stronger operational fit for automation users
* repeatable launch patterns for additional strategy vaults

## Supported pool set and expansion path

ITP’s current Velodrome integration includes a multi-pool deployment path (e.g. ITP/VELO, ITP/DHT, ITP/wstETH, ITP/OP, ITP/WBTC, ITP/USDC) with scheduled compounding operations.

As this set grows, users get broader strategy choice while staying inside one consistent product architecture.


# API

The Infinite Trading API is the automation backbone for strategy operators and advanced users.

## Architecture

The production stack follows a layered model:

1. **Gateway layer** (public entry)
2. **Validation/routing layer**
3. **Execution layer** for blockchain interactions

This separation improves reliability, endpoint management, and protocol-specific execution flows.

## What the API can do

* Configure and update automated bot behavior (`setBot`, status, deletion flows)
* Execute vault trades (`vaultTrade`)
* Manage approvals and portfolio operations
* Support lending and credit workflows (`lend`, `unlend`, `borrow`, `repay`)
* Support Aave V3 route operations (`aaveV3`, health-factor and pool-data flows)
* Support additional lending routes including Compound and Fluid where enabled
* Return machine-readable endpoint docs with `llmIntrospect`

## API reference

* Interactive endpoint reference: `https://api.infinitetrading.io/__docs__`
* Machine-readable endpoint metadata: `/llmIntrospect`

## Authentication model

* Manager or gas-wallet API keys are used for privileged actions
* Non-sensitive introspection and selected query routes can be open/read-only

## Monetization model

API execution is monetized by action class, with live conversion into native gas-token payments from configured wallets.

Documented examples from the current gateway stack include:

| Action class                           | Example documented price           |
| -------------------------------------- | ---------------------------------- |
| trade                                  | $0.10                              |
| approve                                | $0.02                              |
| lend / borrow / repay                  | $0.05                              |
| deposit / withdraw / composition reads | free-tier in current documentation |

Exact behavior can vary by route and environment, but the model is consistently usage-based.

## Endpoint billing matrix

### Paid endpoints

The following endpoints are billed in current gateway operations:

* `vaultTrade` (trade class)
* `approve` (approval class)
* `lend`
* `unlend`
* `borrow`
* `repay`
* `aaveV3` (including lending subroutes such as lend, unlend, borrow, repay)
* `addLiquidity`
* `removeLiquidity`
* `mintManagerFee`

Additional lending operations supported in current cloud API workflows are also billed when executed:

* `depositFluid`
* `withdrawFluid`
* `depositCompoundV3`
* `withdrawCompoundV3`
* `POST /api/cex/chargeFee` (CEX trading fee charge)

### Free endpoints

The following endpoints are currently free (no explicit API action fee):

* `associateGasWallet`
* `createGasWallet`
* `deactivateCEXBot`
* `deassociateGasWallet`
* `deleteBot`
* `deleteCEXBot`
* `deleteCEXSubaccount`
* `getAllBots`
* `getAllCEXSubaccounts`
* `getAllGasBalance`
* `getAllYields`
* `getAssociatedGasWallets`
* `getCEXSide`
* `getCandles`
* `getContract`
* `getEstimatedAnualYield`
* `getGasBalance`
* `getGasWalletPools`
* `getHealthFactor`
* `getNewApiKey`
* `getPoolAaveData`
* `getSymbol`
* `getTicks`
* `getTotalYield`
* `linkGasWallet`
* `llmIntrospect`
* `poolComposition`
* `registerCEXSubaccount`
* `setBot`
* `setCEXSide`
* `setCEXStrategy`
* `unlinkGasWallet`
* `GET /api/cex/calculateFee`
* `GET /eth-price`
* `GET /token-price/:network`
* `GET /calculate-fee/:action/:network`
* `GET /all-actions`
* `GET /test/:network`

### Notes on CEX and documentation endpoints

* `https://api.infinitetrading.io/__docs__` provides interactive route documentation.
* `/llmIntrospect` provides machine-readable endpoint metadata.
* CEX fee charging is exposed through dedicated CEX fee routes in the cloud API stack.

## Why this matters for ITP

The API is core product infrastructure that:

* powers vault automation and strategy operations
* enables third-party integration paths
* increases sticky ecosystem usage across ITP products

## LLM and agent support

The `/llmIntrospect` endpoint provides structured endpoint metadata so AI agents can discover and safely call API capabilities without hardcoded assumptions.


# Product Roadmap

This roadmap summarizes active direction from product and infrastructure workstreams.

## Application roadmap themes

### 1) Auto-compounder UX expansion

* richer position views
* broader pool coverage
* deeper history and performance displays
* more complete deposit/withdraw lifecycle tooling

### 2) Analytics and comparison tooling

* benchmark comparison surfaces
* alpha and drawdown metrics
* expanded strategy quality diagnostics over time

### 3) Boosted LP quality-of-life

* cooldown visibility
* emergency mode handling
* reward-type previews
* safer action guidance in edge states

### 4) Product consistency

* common vault interaction patterns across pages
* cleaner manager and advanced-user workflows
* ongoing performance and reliability optimization

## API and cloud roadmap themes

* stronger AI/agent-native API discoverability
* broader endpoint coverage with clean namespace design
* execution reliability hardening for strategy automation
* continued multi-network strategy deployment support

## Ecosystem growth direction

* expansion of ITP-aligned auto-compounder and vault families
* deeper integration between deployment-specific products and the main app
* stronger utility linkage around ITP through sustained product usage

> Roadmap items are directional and can evolve with market, security, and liquidity conditions.


# What Is Ethereum?

Ethereum is the base settlement layer for most of modern DeFi, including the ecosystem where Infinite Trading products operate.

## Why Ethereum still matters for ITP users

* It is the trust layer behind smart contracts and asset custody.
* It enables transparent, non-custodial vault interactions.
* It powers the L2 ecosystems (Base, Optimism, Polygon) used for lower-cost execution.

## How this connects to Infinite Trading

Infinite Trading is built on Ethereum-compatible networks so users can:

* keep custody in their own wallets
* verify transactions and vault behavior onchain
* access automated strategies without centralized account risk

## Ethereum + Layer 2 in practice

Most users interact on L2s rather than Ethereum mainnet for day-to-day product usage:

* **Base** for fast and cost-efficient product flows
* **Optimism** for deep DeFi liquidity and automation routes
* **Polygon** for additional EVM compatibility and access patterns

This is why network setup is a core step in onboarding.

## Wallet UX and execution

Rabby and MetaMask remain core wallet options in the ecosystem. They are the bridge between user custody and smart-contract actions (approve, deposit, withdraw, trade, compound).

## Security reminder

Ethereum gives strong transparency and control, but user security still depends on wallet hygiene:

* protect seed phrase/private keys
* verify domains before signing
* check transaction details before approval


# Scaling Solutions

Ethereum Layer 2 networks increase throughput and reduce transaction costs while preserving Ethereum settlement guarantees.

## Why this section exists

Infinite Trading products operate across multiple EVM networks. Network selection affects:

* execution cost
* transaction confirmation speed
* available liquidity routes
* product availability by vault type

## Core networks used in this documentation

* **Optimism**: deep DeFi liquidity and mature infrastructure
* **Base**: efficient execution and active ecosystem growth
* **Polygon**: broad EVM compatibility and low-fee transaction environments

## Operational considerations

Before using any vault or manager workflow:

1. Confirm the required network in the product interface.
2. Hold sufficient native gas token for approvals and transactions.
3. Verify destination addresses and bridge routes before transfer.

## Related pages

* [🔴 What Is Optimism?](/additional-references/what-is-ethereum/scaling-solutions/what-is-optimism)
* [🔵 What Is Base?](/additional-references/what-is-ethereum/scaling-solutions/what-is-base)
* [🟣 What Is Polygon?](/additional-references/what-is-ethereum/scaling-solutions/what-is-polygon)


# What Is Polygon?

Polygon is an EVM-compatible network family designed for lower-cost and higher-throughput transaction execution relative to Ethereum mainnet.

## Why Polygon matters in DeFi operations

* broad EVM tooling compatibility
* lower average transaction cost for frequent operations
* active ecosystem coverage across wallets, bridges, and DeFi protocols

## Relevance to Infinite Trading users

Polygon is relevant when workflows require:

* cost-sensitive transaction paths
* network diversification across supported vault ecosystems
* additional execution environments for automation and strategy routing

## Operational checklist

1. Confirm network selection before approving or depositing.
2. Hold POL for transaction fees.
3. Verify contract addresses in official product interfaces.
4. Validate bridge destination chain before transfer.

## Risk and execution notes

* bridge risk and liquidity fragmentation can affect execution outcomes
* network congestion can still occur during high-activity periods
* token symbols may map to different contracts across networks


# What Is Optimism?

Optimism is an Ethereum Layer 2 network built for lower transaction costs and higher execution throughput while retaining Ethereum settlement guarantees.

## Why Optimism matters in this ecosystem

* deep liquidity across major DeFi venues
* broad support for EVM tooling and wallets
* strong suitability for automated, high-frequency strategy operations

## Relevance to Infinite Trading products

Optimism is used for:

* vault operations in Optimism-based product lines
* staking and token-related workflows where configured
* manager and bot execution paths that require lower operational cost

## Operational checklist

1. Confirm that the selected vault or feature is on Optimism.
2. Hold ETH for gas.
3. Verify all approval and transaction details before signature.
4. Monitor slippage and route quality during volatile periods.

## Risk and execution notes

* bridge finality and transfer windows vary by route
* gas cost can increase during congestion
* execution quality depends on pool depth and market conditions


# What Is Base?

Base network reference for Infinite Trading users

Base is an Ethereum Layer 2 network optimized for lower-cost, high-throughput transaction execution.

## Why Base matters in this ecosystem

* efficient execution for frequent vault operations
* broad compatibility with EVM wallets and developer tooling
* expanding liquidity and protocol coverage for DeFi products

## Relevance to Infinite Trading products

Base is used for:

* selected auto-compounder vault deployments
* cbEGGS-linked product and liquidity surfaces
* manager and API operations where Base is an enabled network

## Operational checklist

1. Confirm that the selected vault or operation is on Base.
2. Hold ETH for Base gas fees.
3. Verify token contract addresses before approvals.
4. Review bridge route and destination network before transfer.

## Risk and execution notes

* cross-chain transfers introduce bridge and settlement risk
* execution quality depends on route liquidity and market conditions
* transaction costs can vary under network congestion


# Rabby Wallet

Rabby Wallet reference for Infinite Trading users

Rabby is a multi-chain EVM wallet with transaction simulation and risk-screening features.

## Role in Infinite Trading workflows

Rabby is commonly used for:

* connecting to the application interface
* reviewing transaction effects before signature
* signing approvals, deposits, withdrawals, and trade operations
* handling frequent network changes across supported chains

## Setup checklist

1. Install Rabby from the official source.
2. Create or import wallet credentials.
3. Back up seed phrase offline.
4. Confirm support for required networks.
5. Hold native gas token balances for each active chain.

## Operating practices

* verify destination address and network before every transfer
* confirm approval scope before signing
* review simulation output for token balance changes
* maintain separate wallets for daily activity and treasury balances

## Security baseline

* use official download links only
* protect seed phrase and private keys in offline storage
* avoid signing unknown payloads
* apply hardware-wallet workflows for higher-value operations


# MetaMask

MetaMask reference for Infinite Trading users

MetaMask is a self-custody wallet used to sign transactions and interact with EVM applications.

## Role in Infinite Trading workflows

MetaMask can be used for:

* wallet connection to the application interface
* token approvals for vault interactions
* deposit and withdrawal transaction signing
* network switching across Ethereum, Optimism, Base, Arbitrum, and Polygon

## Setup checklist

1. Install MetaMask from the official source.
2. Create or import a wallet.
3. Back up seed phrase offline.
4. Add required networks.
5. Fund the wallet with native gas tokens for each network in use.

## Security baseline

* verify domain and contract details before signing
* review token allowance scope for each approval
* avoid storing seed phrase or private keys in cloud notes or chat systems
* use hardware-wallet integration for larger balances

## Practical notes

* transaction cost depends on network conditions
* bridge transfers should be confirmed before vault deposit attempts
* failed transactions generally consume gas and should be retried only after root-cause review