overview
what is factory?
factory is the first concentrated liquidity AMM (automated market maker) built on the octra FHE blockchain. it lets traders swap tokens and allows liquidity providers to deploy capital within custom price ranges — earning fees when the market price falls inside their range.
unlike traditional AMMs that spread liquidity evenly from zero to infinity, factory positions are capital-efficient: the same dollar amount covers a much tighter range and earns proportionally more fees when active.
factory runs natively on octra — an L1 blockchain built around fully homomorphic encryption.
key properties
- concentrated liquidity — LPs set a price range. capital outside that range earns nothing and is not at risk.
- multiple fee tiers — three fee levels to match different risk profiles.
- permissionless — any OCS01-standard token pair can be listed by deploying a new pool. no whitelisting.
- non-custodial — funds never leave your wallet until you initiate a transaction.
- octra-native — runs directly on the octra VM, not a bridge or layer on top.
overview
how it works
factory uses a tick-based concentrated liquidity model similar to Uniswap v3, adapted for the octra VM and AML contract language. each pool tracks a current price expressed as a square-root ratio and a set of initialized ticks that mark the boundaries of active LP positions.
pools
each pool is a deployed contract that holds reserves for exactly one token pair at one fee tier. a factory contract (the registry) tracks all deployed pools and routes creation requests. the router contract handles multi-hop swap routing across pools.
swaps
when a swap is submitted, the router queries the quoter to find the best path and expected output, then submits the trade to the relevant pool. the pool steps through initialized ticks, consuming liquidity from each active position until the input amount is fully used.
positions
an LP position is defined by three values: a lower tick, an upper tick, and a liquidity amount. positions are stored per-owner inside the pool contract. when the market price crosses into a position's range, that position starts accumulating fee shares proportional to its liquidity relative to total active liquidity.
overview
privacy & FHE
octra uses HFHE — Hypergraph Fully Homomorphic Encryption — a proprietary scheme built from scratch by the octra team. FHE allows computations to be performed on encrypted data without decrypting it first.
what this means for factory
factory runs as a set of AML contracts on the octra VM. octra is architecturally designed around FHE — the chain is built to support encrypted computation at the network level. factory inherits this infrastructure by running natively on octra.
factory is currently deployed on octra devnet. octra mainnet alpha launched in december 2025. factory's mainnet deployment is planned to follow.
octra vs. standard L1s
| property | standard L1 | octra |
|---|---|---|
| transaction state | public | public + optional encrypted balance layer |
| validator access to values | full plaintext | plaintext (FHE layer for encrypted balance path) |
| encryption scheme | — | HFHE (proprietary) |
| token standard | ERC-20 | OCS01 |
for traders
swapping
to trade on factory you need an octra-compatible wallet and some OCT to cover transaction fees. two wallets are currently supported: 0xio (browser extension for desktop) and Octra Wallet (mobile app for Android).
getting started
- install an octra-compatible wallet — 0xio browser extension (desktop) or Octra Wallet (Android). create or import your octra wallet.
- go to the factory app and click connect wallet. select your wallet and approve the connection.
- select the token pair you want to trade. enter an amount — the quoter will show the expected output and price impact.
- click swap and confirm the transaction in your wallet.
exact input vs. exact output
factory supports both swap directions:
- exact input — you specify how much you're spending. output varies with price.
- exact output — you specify how much you want to receive. input is calculated and may vary slightly.
for traders
fee tiers
each pool is deployed with one of three fee tiers. fees are taken from the input token on each swap and distributed to active LPs in that pool.
the fee tier of a pool is set at deployment and cannot be changed. multiple pools can exist for the same token pair at different fee tiers — liquidity is separate between them.
for traders
price impact & slippage
price impact
price impact is the change in market price caused by your trade. larger trades relative to pool depth move the price more. the factory interface shows estimated price impact before you confirm.
slippage tolerance
slippage tolerance is a bound you set on how much the price can move between quote and execution. if the final price falls outside this bound, the transaction reverts and your tokens are returned. the default is 1.0%. for volatile assets or thin pools, set it higher.
setting slippage too low causes failed transactions. setting it too high on low-liquidity pools can result in unfavorable fills. check pool depth before trading large sizes.
for LPs
providing liquidity
liquidity providers deposit two tokens into a pool and earn a share of swap fees whenever the market price is inside their chosen range. unlike traditional AMMs, you only earn fees when the price is actively inside your range.
adding a position
- go to the liquidity tab, select a pool, and click add liquidity.
- select a token pair and a fee tier.
- set your price range. the current market price is shown — your range must bracket the current price to be immediately active.
- enter the token amounts. the interface calculates the required ratio based on your range.
- click add liquidity and confirm in your wallet.
impermanent loss
when the price moves within your range, the pool rebalances your holdings between the two tokens. if you withdraw at a different price than you entered, you may have fewer tokens than if you had simply held. narrower ranges amplify this effect alongside the higher fee income.
for LPs
price ranges
when you create a position you set a lower price and an upper price. your liquidity is only active — and only earns fees — while the market price is between these two values.
narrow vs. wide ranges
| range width | fee APR (when in range) | out-of-range risk | best for |
|---|---|---|---|
| narrow | high | high | stable pairs, active management |
| wide | lower | low | volatile pairs, passive LPs |
| full range | lowest | none | set-and-forget |
out-of-range positions
if the price exits your range, your position stops earning fees and becomes 100% composed of one token. the position stays open and resumes earning when the price re-enters the range. you can close it at any time.
for LPs
collecting fees
fees accumulate inside the pool contract and are credited to your position as they accrue. they are not automatically sent to your wallet — you must claim them manually.
how to collect
- go to the positions tab in the top navigation.
- find the position with unclaimed fees. the interface shows the pending amount in USD and token amounts for each token.
- click claim and confirm the transaction in your wallet.
fees can be collected without closing your position. collecting does not affect your liquidity or price range.
protocol
contracts
factory is deployed as a set of AML contracts on the octra VM on octra devnet. contract addresses will be published here when the app launches publicly.
in the meantime, all deployed contracts can be found on devnet.octrascan.io.
protocol
token standard
factory supports any token that implements the OCS01 standard — octra's equivalent of ERC-20. OCS01 defines a common interface for fungible tokens on the octra VM: transfer, balance queries, and allowances.
creating a pool
factory is permissionless — anyone can create a pool for any OCS01 token pair without a whitelist or governance vote. each pool is a standalone contract deployed by the factory registry. multi-pool support per token pair is currently in development and will be available in a future release.
protocol
security
smart contract risk
factory contracts are written in AppliedML (.aml) and compile to octra bytecode. the codebase has not yet undergone a formal third-party audit. use the protocol with funds you are comfortable risking on devnet software.
factory is beta software on devnet. all tokens used for testing are available from the devnet faucet and have no real value.
no admin keys
pool contracts have no owner function or upgrade mechanism after deployment. the factory registry can deploy new pools but cannot modify existing ones.
reporting issues
found a bug or vulnerability? reach out on twitter @factory_oct or via the contact link in the footer. we take security reports seriously and will respond promptly.