Krushitel

On TON, chains and contracts follow strict rules: deterministic execution, precise fees, clear storage costs. People, on the other hand, think in simpler terms like “swap this”, “earn that”, “adjust later”. STONfi’s job is to stand in the middle and translate.
For users, it presents actions in human terms: swap, add liquidity, stake, claim. For the chain, it expresses those actions as carefully structured transactions that follow all the underlying rules about precision, timing, routing and fees.
Because STONfi focuses on this translation layer, wallets, bots and applications can stay clos

On TON, every contract state change has a cost, and every extra field stored in a contract matters over time. This pushes protocols to design data structures that are compact, predictable and easy to maintain.
STONfi follows this by tracking liquidity via pool shares and rewards via simple accumulators, instead of storing a separate full snapshot for each user at every step. Pools know total balances and total shares; farming contracts know total rewards and per share indices. Everything else is derived when neededThis approach keeps STONfi light on storage while still giving integrators eno

Not every user on TON wants the same risk profile. Some prefer to stay close to TON itself, others are willing to explore more volatile tokens or experimental projects. STONfi provides a common surface where these preferences can coexist.
Core pools with deep liquidity and known assets form the conservative side. Pairs with project tokens, memecoins or synthetic assets sit further out on the spectrum. Routing connects them, but each user can decide how far they want to go by choosing which pools and farms to interact with.
Because everything runs through the same contracts and SDK, changes

Fast finality on TON means that once a transaction is confirmed, the network quickly agrees that it is part of the canonical history. For protocols like STONfi, this is more than a convenience, it is a structural advantage.
When swaps and liquidity operations finalize quickly, applications can safely chain actions without long waiting periods. A user can complete a swap, see the result and immediately use that new balance in another operation, all within a short window. Strategies that depend on precise sequencing become practical.
STONfi leans into this by designing flows that assume quic

For many users, their first contact with DeFi on TON is not a whitepaper or a tutorial, but a simple swap or pool interaction on STONfi. In that sense, the protocol doubles as a teaching tool for how things work under the hood. Concepts like routing, liquidity, fees, farming and risk become concrete through repeated use. Each successful action is a small, practical lesson in how contracts and assets behave. Over time, users who start with “just swap this” build an intuition for deeper mechanics without needing formal training. STONfi’s design encourages this gradual learning. It exposes enou

STONfi uses different pool curves to better match asset behavior. For assets with independent price movement, pools rely on a classic automated market maker curve. For assets that are expected to stay close in value, stable oriented curves concentrate liquidity around a narrower band, making small trades cheaper.
These curve choices are reflected in pool metadata and tags. Integrators using the STONfi SDK can read these details and decide how to present pools to users or which pools to prefer for certain strategies. Omniston routing also considers curve types when combining pools into larger

TON uses a consensus design where validators agree on blocks with strict timing and deterministic execution rules. Every honest node runs the same code and processes the same transactions in the same order, which guarantees that contract state evolves identically across the network.
STONfi relies on this determinism for all its pools, routing and farming logic. When the STONfi SDK simulates a swap or a liquidity operation, it expects that the same inputs on chain will produce the same result. As long as state does not change between simulation and execution, the outcome is exactly what was p

Because TON processes transactions in parallel across multiple chains, applications can increase throughput by spreading activity rather than concentrating it in a single bottleneck. The base protocol is designed so that new shards appear when they are needed, which keeps queues shorter and confirmation times stable.
For STONfi, this means that an increase in swap volume does not automatically translate into long waiting times for users. Even during busy periods, transactions that interact with STONfi contracts can be placed into different parts of the network, and the routing layer can cont

The fee model on TON assigns a small cost to each on chain operation, but recent improvements have pushed this cost down to a fraction of what it used to be. As a result, complex operations that involve several contract calls can still remain inexpensive in absolute terms.
STONfi uses this margin to offer richer flows without making them feel heavy. A single user action can include route selection, multi hop swaps, internal conversions for Arbitrary Provision and optional farming enrollment, yet the total fee remains low enough for everyday use.
From the user’s point of view, this means th

The broader TON ecosystem includes games, digital collectibles, payment tools and Telegram based services. Each of these domains introduces its own tokens and user flows, but they all eventually need a way to convert value between assets and connect to the rest of the network.
STONfi fills this role by acting as the connector between these domains. When a game issues a reward token, a messaging bot introduces a new asset or a payment tool uses its own unit, they can all attach to STONfi pools and routes to reach the main TON liquidity. The STONfi SDK makes this integration straightforward fo

TON stores contract state in a structured tree format, where each contract has its own isolated storage and code. Updates happen by applying transactions to this storage, and every change can be traced through the chain of blocks.
STONfi uses this model to keep pools, routing components and farming contracts clearly separated. Each pool has its own state tree with balances, fee parameters and share information. Farming contracts maintain separate trees for reward tracking, while routing logic focuses on building transactions that touch these components in a controlled sequence.
For integra

In TON, operations are built around messages that travel between contracts. A single transaction can send several messages, which are processed in order and can trigger further calls. This design allows complex interactions to be expressed as a chain of messages rather than a single function call.
STONfi uses this mechanism when executing multi step operations. A user initiated swap can trigger messages that move assets into a pool, perform the swap, send results back and optionally notify another contract about the outcome. The same pattern applies to liquidity additions, withdrawals and fa

On TON, contract storage has an explicit carrying cost. Each cell of state incurs a small ongoing fee, which encourages contracts to keep their data compact and avoid unnecessary long lived entries.
STONfi takes this into account in its pool and farming design. Liquidity positions are tracked through pool shares rather than per position balance copies, and farming contracts store only essential values such as staked shares and accumulated reward indices. This keeps the storage footprint small relative to the amount of activity.
For users and integrators, this means that long term positions

TON executes contract logic through asynchronous messages. A single transaction can trigger a chain of messages between contracts, which may be processed across several blocks while preserving a defined order within each chain.
STONfi uses this model when executing complex routes. A swap can generate messages that move funds into a pool, perform internal conversions, update farming positions and return the final result. Each step is a message to a specific STONfi contract, and the whole chain either completes or reverts as one unit.
Applications using the STONfi SDK only see the initial re

TON allows wallets to be implemented as contracts with custom logic rather than as fixed templates. This enables features like multi signature control, time based restrictions or additional checks to be enforced directly at the wallet level.
STONfi fits naturally into this model. Any wallet contract that can construct and sign standard calls can interact with STONfi pools, routing and farming contracts. This includes classic user wallets, more advanced custody solutions and programmatic Agentic Wallets.
Developers can therefore design their own security and access schemes while still using

The TON ecosystem provides compilers, debuggers, explorers and standard libraries for working with contracts and state. On top of this foundation, the STONfi SDK acts as a specialized layer that focuses on swaps, routing and liquidity operations.
A developer can build an application using standard TON tooling and then plug in the STONfi SDK to add price discovery, route construction and transaction preparation. Complex operations such as multi hop swaps or single sided liquidity provision become a small number of SDK calls instead of a large amount of low level code.
This division of respo

TON stores contract data in structured trees, where each contract maintains its own isolated state. Every update is a deterministic transformation of this tree, and the full history can be reconstructed from blocks.
STONfi uses this structure to keep pools, farming contracts and routing components clearly separated. Each pool contract maintains its own balances, fee parameters and share counters. Farming contracts keep their own reward indices and stake records, while routing related contracts focus on path selection and configuration.
Because all of this state is on chain and readable, to

While STONfi focuses on swaps inside the TON network, the Omniston routing layer it uses can participate in cross chain flows. In tested designs, swaps can move value between TON and other networks through native execution paths instead of relying on wrapped tokens stored in a central bridge.
On the TON side, STONfi provides the pools and contracts that source or deliver assets. Omniston coordinates with contracts on the external network so that both sides complete under matching conditions or revert together. The user interacts with STONfi as usual, even though part of the transaction is ex

Analytical tools available on top of STONfi help liquidity providers understand how their positions behave over time. APR values are derived from current fee and reward flows relative to total liquidity in a pool, while APY estimates show what happens if rewards are regularly reinvested into the position.
These metrics update as on chain conditions change. When swap volume increases or farming rewards grow, APR and APY reflect that rise. When liquidity increases faster than income, they move in the opposite direction. Integrations that use the STONfi SDK can surface the same metrics directly

The TON ecosystem provides compilers, debuggers, explorers and standard libraries for working with contracts and state. On top of this foundation, the STONfi SDK acts as a specialized layer that focuses on swaps, routing and liquidity operations.
A developer can build an application using standard TON tooling and then plug in the STONfi SDK to add price discovery, route construction and transaction preparation. Complex operations such as multi hop swaps or single sided liquidity provision become a small number of SDK calls instead of a large amount of low level code.
This division of respo