# ApexiSwap Whitepaper

_A fee-in-transaction DEX aggregator and token launchpad on Arc_

| Field | Value |
| --- | --- |
| Whitepaper version | 2.0 |
| Protocol version | ApexiSwap 2026.09 |
| Router version | ApexisRouter (V5) (live) |
| Pump version | Apexis Pump, August 2026 revision (Factory + Curve + Token) |
| Last updated | September 2026 |

https://www.apexiswap.com

## Abstract

ApexiSwap is a decentralized exchange aggregator and a bonding-curve token launchpad (Apexis Pump) deployed on Arc, a network whose native gas asset is USDC. It routes swaps across the liquidity venues registered on the network, charges one protocol fee inside the swap transaction itself through its own on-chain router, and lets anyone launch a token whose price discovery happens on a bonding curve before graduating into a permanently seeded DEX pool that earns for its creator. This document describes the system as deployed. Where a capability exists in source but is not yet live, it is labelled as such.

## 1. The network

ApexiSwap runs on Arc (chain id 5042). Arc is an EVM chain whose native currency is USDC with 18 decimals: gas is paid in dollars, and a "native" balance in ApexiSwap is a USDC balance. Every figure in this document denominated in USDC refers to that native asset unless it says otherwise.

Because the native asset is also the quote asset, the platform needs no separate stablecoin leg. Swaps quote in USDC, bonding curves raise USDC, graduation pools are seeded with USDC, and protocol fees accrue in USDC. Where a DEX requires an ERC-20 form of the native asset, ApexiSwap wraps and unwraps through that DEX’s own WUSDC contract; the wrap is 1:1 and carries no protocol fee.

> The current deployment is on Arc mainnet (chain ID 5042), where USDC and tokens carry real value. Official addresses are listed in the Deployment Registry section of this document.

## 2. System overview

The platform is four on-chain contracts plus an off-chain application that reads them. None of the application’s state is required for a swap or a curve trade to settle; the app quotes, indexes and presents, the chain executes.

| Component | Role |
| --- | --- |
| ApexisRouter | Our own router. Takes the protocol fee inside the swap and forwards the net amount to the chosen DEX. Holds the graduation registry that switches a token to the graduated rate. |
| ApexisPumpFactory | Deploys a token and its bonding curve in one transaction, with the economics stamped in at creation. |
| ApexisPumpCurve | The bonding curve. Sells a fixed supply against USDC along a constant-product curve, withholds a liquidity reserve, and graduates the token to a DEX pool when the target is met. |
| ApexisPumpToken | The launched ERC-20. Takes no cut of any transfer. Enforces a venue lock: once graduated, its pair can only be traded through our router until the project wallet lifts the lock. |

**A swap, end to end**

```
USER (wallet)
  ↓
ApexiSwap interface
  ↓
Aggregator / quote engine (reads every registered DEX)
  ↓
ApexisRouter (takes the protocol fee, enforces minOut)
  ↓
Selected DEX router
  ↓
Liquidity pool
  ↓
USER (receives net output)
```

**A launch, end to end**

```
CREATOR (signs the content notice)
  ↓
ApexisPumpFactory
  ↓
ApexisPumpToken + ApexisPumpCurve (deployed together)
  ↓
Bonding curve trading (1.25% fee)
  ↓
Funding target reached (50,000 USDC)
  ↓
graduate(): pair created, seeded, LP burned
  ↓
TOKEN / WUSDC pool on the launch DEX
  ↓
ApexiSwap swaps (1% graduated fee via ApexisRouter)
```

## 3. The swap aggregator

A swap on ApexiSwap is a quote across venues followed by a single transaction to the best one. The quote engine reads on-chain reserves from every Uniswap V2-style DEX registered for the network and also evaluates cross-DEX routes that buy on one venue and sell on another through the native asset. The route with the highest net output after the protocol fee wins; alternatives are shown so the choice is auditable.

- DEXes are discovered from their factories and classified by on-chain evidence (a factory link, pair creation events), not by name. An operator reviews each discovery before it is enabled for routing.
- Slippage protection is set from the price impact of a fresh quote, not from a fixed default. The minimum output is enforced by the router contract on the balance the recipient actually gains, so a token that taxes or reflects on transfer cannot deliver less than the minimum and still succeed.
- Quotes and execution share one code path for fees: if a route cannot be charged, it cannot be quoted as charged.

## 4. ApexisRouter: routing and the protocol fee

Every swap that touches a Uniswap V2-style venue is executed through ApexisRouter, not by calling the DEX directly. The router takes a protocol fee of 0.3% (30 basis points) on the USDC side of the trade, in the same transaction, and forwards the remainder to the DEX. There is no prepaid balance, no separate approval to the platform and no off-chain accounting: the fee is a line in the swap.

How a DEX is selected and used: the router keeps an on-chain registry of DEX routers, each with a flavour (the call shape it speaks), the WUSDC contract that venue wraps with, and an enabled flag. Every entry point names a registered DEX; the router builds the DEX call itself and reverts on an unknown or disabled venue. It accepts no arbitrary calldata. The application mirrors the same list and refuses to send a swap the router cannot take.

| Registered venues (live) | Status |
| --- | --- |
| APEXISWAP | Registered, protocol fee waived |
| Uniswap | Registered, protocol fee charged |

| Fee rule | Value on the deployed contract |
| --- | --- |
| Standard protocol fee | 0.3% of the USDC leg, when neither token in the swap is a graduated Pump token |
| Graduated fee | 1% of the USDC leg, when either end of the swap is a graduated Pump token. It REPLACES the standard fee; the two are never both charged. |
| Graduated fee split | 80% to the token creator (claimable), 20% to the protocol |
| Hard cap for both rates | 3% (300 bps), a contract constant the owner cannot raise |
| Where the fee is taken | From the input on a buy, from the output on a sell, once on the native middle of a token-to-token route |
| USDC / WUSDC wrap | No fee; the router is not involved |
| Uniswap V3 routes | No protocol fee; the router does not build V3 calls (see section 5) |
| Per-DEX fee exemption | Available on this revision (V5): the owner can waive the STANDARD fee for a venue. The graduated fee is never waived. |

No double charge inside ApexiSwap: a swap pays exactly one router fee, chosen by whether a graduated token is at either end. The ApexisPumpToken contract takes no cut of transfers, so there is no second, token-level fee on a graduated trade. Whatever the DEX pool itself charges (its own LP fee, shown per venue) is the venue’s, not ApexiSwap’s.

Fees accrue in a balance separate from any swap funds. Protocol fees are pushed to the owner during the swap when possible and otherwise accrue for withdrawal; creator fees accrue per creator and are pulled by the creator. A sweep of unaccounted balance reserves both books, so the owner cannot withdraw creator earnings.

> The application refuses a swap it cannot route through the router rather than sending it to the DEX directly. A DEX that is not enabled, or a router configuration that cannot be loaded, pauses that route; it does not make it free.

## 5. Uniswap V2 and V3 venues

The two venue families are handled by different components and the difference matters for fees.

| Question | V2-style venues / V3 venues |
| --- | --- |
| Who quotes | V2: the application reads pair reserves directly. V3: the application calls the venue’s Quoter contract (which returns the amount by reverting; the app decodes it). |
| Who executes | V2: ApexisRouter, which then calls the DEX. V3: the wallet calls the Uniswap V3 SwapRouter directly. |
| Does ApexisRouter participate | V2: yes, always. V3: no. It does not build concentrated-liquidity calls. |
| Is a protocol fee charged | V2: yes (0.3% or 1%). V3: no. This is a known fee gap, not a promotion. |
| Current V3 limits | Single-hop exact-input swaps only, on fee tiers the operator registered by hand for the Quoter. No cross-DEX route includes a V3 leg. Pools with zero liquidity are skipped. |

> Until the router learns V3 call shapes, V3 routes are quoted and executed but not charged. The whitepaper will be updated when that changes; the application does not advertise the gap as a feature.

## 6. Apexis Pump: the launchpad

Apexis Pump lets anyone deploy a token and open it for trading in one transaction, without providing liquidity up front. The factory mints a fixed supply of 1,000,000,000 tokens, places 800,000,000 (80%) on a bonding curve and reserves the remaining 200,000,000 (20%) for the graduation pool. The creator receives no allocation and the token has no mint function after creation.

The curve is a constant-product market seeded with 12,500 virtual USDC, so the first buyer pays a defined, non-zero price and every purchase moves it deterministically. The virtual reserve is a pricing constant; it is never withdrawable. Buys and sells are open from the moment of creation until the curve’s real USDC reserve has grown by exactly the funding target.

| Parameter | Value |
| --- | --- |
| Total supply | 1,000,000,000 tokens, fixed |
| Sold on the curve | 800,000,000 tokens (80%) |
| Reserved for the graduation pool | 200,000,000 tokens (20%) |
| Virtual USDC reserve at launch | 12,500 USDC |
| Funding target | 50,000 USDC net into the curve |
| Creator allocation | None |
| Creation fee | Set by the factory owner; paid once at launch, shown before signing |

Before a launch is created, the creator signs a content notice in their wallet: an acknowledgement of what they are publishing and under what terms. The acceptance is stored and linked to the sale. Until graduation the token can only move between wallets and the curve: transfers where a contract is a counterparty are rejected unless that contract was exempted.

## 7. Curve economics

Every trade on a curve pays a fee of 1.25% (125 bps), split three ways at creation and copied into the curve’s own storage, so a curve keeps the terms it launched with even if the factory later changes them.

| Destination | Share of each trade |
| --- | --- |
| Protocol | 0.5% |
| Token creator | 0.5% |
| Liquidity reserve, withheld until graduation | 0.25% |
| Total paid by the trader | 1.25% |

The liquidity share is accounted outside the curve’s trading reserve. It cannot be sold against, it cannot be withdrawn by anyone, and its only exit is into the graduation pool. The protocol share is forwarded automatically; the creator share accrues and is claimable by the creator.

## 8. Graduation, step by step

Reaching 100%: the curve tracks the net USDC it holds against a target reserve. A buy whose net amount would exceed the remaining gap is trimmed to exactly the gap; the gross amount needed for that net is recomputed, the fee split is applied to the trimmed gross, and any surplus the buyer sent is refunded in the same transaction. Rounding dust between the recomputed net and the target is credited to protocol fees, never to the curve’s backing, so the reserve lands on the target exactly. The curve then moves from ACTIVE to READY and stops trading in both directions.

- Anyone can call graduate() on a READY curve; it needs gas and nothing else. The call returns a boolean rather than reverting on a downstream failure, records the failing selector, and can be retried. The operator console lists READY curves so a stuck one is visible.
- The pair TOKEN/WUSDC is created on the DEX chosen at launch (or reused if it already exists) using that DEX’s factory, then seeded with the reserved 20% of supply plus the raised USDC and the withheld liquidity reserve, wrapped to WUSDC.
- The LP tokens minted by the pool are sent to the burn address (0x…dEaD) in the same transaction. The liquidity is not locked for a period; it is permanently unrecoverable by anyone, including the protocol.
- Any token left in the curve after seeding is burned, so circulating supply is exactly what the curve sold plus what the pool holds.
- The token is registered on ApexisRouter with its creator and pair, which switches every swap in that token to the graduated fee schedule. Registration happens before the pool opens, so no trade can be charged the wrong rate.
- Trading on the token is enabled last, after the seeding transfer and the LP mint, because the token’s venue lock would otherwise reject the curve’s own liquidity transfer.
- The graduation DEX is validated at creation, not at graduation, so a launch cannot be pointed at a venue that would later leave it stuck.

After graduation, transfers change in one way: the pair may only be a counterparty while ApexisRouter is mid-swap on that token, and other contracts need an exemption from the lock manager. Wallet-to-wallet transfers are unrestricted and always were. The project wallet can lift the lock permanently, once, opening the pair to any router; it cannot re-lock.

## 9. Fees by stage

Everything a trader pays to ApexiSwap, by the stage a token is in. DEX pool fees (the venue’s own LP fee) are separate, belong to the venue and are shown per DEX in the interface.

| Stage | ApexiSwap fee |
| --- | --- |
| Apexis Pump, bonding curve | 1.25% of each trade: 0.5% protocol, 0.5% creator, 0.25% liquidity reserve. |
| After graduation | 1% of the USDC leg, taken by ApexisRouter, split 80% creator / 20% protocol. This replaces the standard fee. The token itself charges nothing on transfer. One fee per swap, never two. |
| Normal swaps (no graduated token) | 0.3% of the USDC leg, taken by ApexisRouter. |
| USDC / WUSDC wrap or unwrap | No fee. |
| Uniswap V3 routes | No fee in the current phase (section 5). |
| Adding or removing liquidity | No fee. |
| Cross-DEX routes on fee-exempt venues | The standard fee is waived only when BOTH venues are exempt; a graduated token at either end is always charged the graduated rate. |

## 10. Security architecture

The trust model, gathered in one place. Each line is enforced by contract code unless it says "application".

| Control | How it is enforced |
| --- | --- |
| DEX whitelist | The router only calls DEX routers in its on-chain registry and only when enabled. An unknown or disabled venue reverts. The application keeps a mirrored list and refuses to send what the router would reject. |
| Router validation | The Pump factory holds an allow-list of swap routers a launch may graduate to; the graduation venue is checked at creation. The application verifies every DEX against the router contract before enabling it. |
| minOut | Measured on the recipient’s balance delta on the leg that pays the user, so the check covers what the user actually gains, fee included. Token-to-token routes have no intermediate minimum; the single final minimum is what protects the trader. |
| Slippage | The interface derives tolerance from the price impact of a fresh quote and passes it as minOut; the contract enforces it, the interface only proposes it. |
| Allowances | Traders approve our router, never the DEX. The router approves the DEX for the exact amount of each swap and does not hold standing allowances on user tokens. |
| Reentrancy | Every swap, claim and owner setter is nonReentrant. Owner setters share the guard so an owner contract cannot rewrite the registry from inside the receive() the fee push invokes mid-swap. |
| Protocol fee handling | Fee rates are capped at 3% by a constant. Fees accrue in a separate balance; sweeps of "unaccounted" funds reserve both protocol and creator books. |
| Admin restrictions | All configuration is onlyOwner. There is no pause, no upgrade proxy and no arbitrary-call entry point on the router. |
| Ownership | Single owner, transferable with transferOwnership. The factory and router each have their own owner. There is no timelock; this is a known limitation listed in section 12. |
| Pre-graduation token | The curve is the only venue. Contract counterparties are rejected unless exempted; the supply is fixed at creation and there is no mint. |
| Graduation conditions | Only a READY curve (real reserve grown by exactly 50,000 USDC) can graduate. ACTIVE and RECOVERY phases revert. The call is permissionless. |
| Liquidity | LP tokens are minted to the burn address in the graduation transaction. Nobody, the owner included, can remove that liquidity. |
| Failed transactions | A reverted swap moves nothing: the fee is taken in the same transaction as the trade, so there is no fee without a fill. A graduate() that fails downstream records the error selector and leaves the curve READY for a retry. |

## 11. Admin powers and limitations

ApexiSwap is operated, not governed by token vote. These are the exact powers the contract owners hold, and the actions no owner can take. Administrative pages are gated by a wallet signature from the configured operator address and every write is a transaction signed by that wallet.

| The owner CAN | Bound |
| --- | --- |
| Register a DEX on the router (setDex), enable or disable it | Routing only; cannot touch user funds or DEX pools |
| Set the standard fee (setFeeBps) | 0 to 3%; the cap is a constant |
| Set the graduated fee (setGraduatedFeeBps) and its creator split | 0 to 3%; split 0 to 100% to the creator |
| Waive the standard fee for a venue (setDexFeeExempt) | Standard fee only; the graduated fee is never waived |
| Point the router at the Pump factory (setPumpFactory) | Only that factory may register graduations |
| Withdraw accrued protocol fees (withdrawFees) | Only the protocol’s own accrued balance; creator balances are reserved |
| Set the launch creation fee, add or remove allowed graduation routers (factory) | Applies to future launches only |
| Transfer ownership of the router or the factory | To any address, immediately |
| Exempt a contract from the token lock (lock manager) | Per token. The lock manager is a protocol address, not the creator. Exempting the pair would let other routers trade it fee-free; the contract does not forbid this, so it is a trust assumption on the lock manager. |

| The owner CANNOT | Why |
| --- | --- |
| Mint additional tokens of any launched token | The token has no mint function; supply is fixed in the constructor |
| Withdraw or move a user’s funds | The router holds no user balances between transactions and has no arbitrary transfer or call |
| Withdraw creator earnings | The creator book is reserved from every withdrawal and sweep |
| Recover or move graduated liquidity | The LP tokens were burned |
| Change a live curve’s fee split or target | Terms are copied into the curve at creation; the factory has no setter for existing curves |
| Raise any router fee above the cap | MAX_FEE_BPS = 300 is a compile-time constant |
| Pause a curve or block a graduation | There is no pause; graduate() is permissionless |
| Route a swap through an unregistered DEX | The registry is the only path; there is no raw calldata entry point |

## 12. Deployment registry

Official addresses on Arc (chain id 5042), read live from the deployed configuration when this document was generated. Verify any address on https://explorer.arc.io before interacting. Anything not listed here is not an ApexiSwap contract.

| Contract | Address |
| --- | --- |
| ApexisRouter | 0xed32e78cdcd587c90fa104e38209b4512d6d5fd5 |
| ApexisPumpFactory | 0x8c04a52cb2da3ee3bd8ae059c17921bfe06b8073 |
| ApexisPumpCurve implementation (cloned per launch) | 0xC3084D1c7eBB03B261aA4763dD98F35d97d03F87 |
| WUSDC (canonical wrapped native) | 0x1CCA7CA62bcBFdAB086765f451648d8C7591AECb |
| DEX router: APEXISWAP | 0x1229377adE15278818cD50214456db4b469f6f2b |
| DEX router: Uniswap | 0x1f7d7550b1b028f7571e69a784071f0205fd2efa |

> Each launched token and its curve have their own addresses, shown on the token’s page and verifiable through the factory’s events. ApexisRouter has no address here because it is not deployed.

## 13. Protocol risks

ApexiSwap is not risk-free and this document does not present it as such. Users should understand at least the following before trading or launching.

- Smart contract risk: a defect in our contracts or in a venue’s contracts can lose funds. Mitigations reduce this risk; nothing eliminates it.
- Liquidity risk: thin pools mean large price impact and, for graduated tokens, a pool that can only be exited at whatever price remains. Burned LP means liquidity cannot be withdrawn by the project either.
- Slippage: the executed price can differ from the quote. minOut bounds the loss but a transaction can still fail or fill worse than shown.
- MEV and arbitrage: swaps and graduations are public before they are mined. Bots may front-run, back-run or arbitrage a curve’s opening pool price.
- Malicious or low-quality tokens: anyone can launch. The content notice is an acknowledgement, not a vetting. ApexiSwap does not endorse any token.
- External DEX dependency: routing and graduation rely on third-party DEX contracts the protocol does not control. A venue can be misconfigured, paused or drained.
- RPC and network failure: the public RPC rate-limits under bursts and some failures surface as false reverts. A launch or graduation can require a second attempt.
- Price volatility: curve and pool prices can move sharply in either direction, including to near zero.
- Concentrated-liquidity venues: on Uniswap V3 pools, liquidity outside the active range does not support the price; a quote can be valid one block and unfillable the next.
- Administrative keys: a single owner key controls router and factory configuration with no timelock. Compromise of that key could redirect fees or register a hostile venue for future swaps; it could not touch burned liquidity or user balances.

## 14. Audits and testing

This section records what has been reviewed and how. An audit reduces risk; it does not guarantee safety, and this document never claims otherwise.

| Item | Status |
| --- | --- |
| External audit | None published yet. When one is, this table will list the firm, the exact contract revision and commit hash, findings, fixes and accepted risks. |
| Internal review of the router | Three iterative reviews (V2 to V4). Findings addressed include minOut measured on the recipient’s delta, reentrant owner setters, and the creator-book sweep hole. Each is documented in the contract source. |
| Internal review of Apexis Pump | One delivered revision was rejected for a 6-decimal regression before deployment; the deployed revision fixed a clone-initialisation failure and the graduation seeding order. Both are documented in the repository. |
| Local EVM tests | Scripts in the repository run the contracts against a local EVM with mocked DEXes: a 29-check suite for the V5 router (standard, graduated, exempt and cross-DEX fee paths), a Pump suite covering buy, sell, final-buy trim, refund and the full graduation sequence, and a factory guard suite. They are run before every deployment, not on a schedule. |
| Stress testing | A 31-wallet swarm exercising concurrent buys, the exact-target final buy and graduation under RPC throttling. |
| Bytecode match | The deployed Pump factory bytecode was matched against the sources this document describes. |

## 15. Markets, data and the interface

- Market: every curve and graduated token with price, 24-hour change, holders and volume, with a per-token page showing the chart, trades, holders, a project tab maintained by the creator and a chat gated to wallet holders.
- Rankings and analytics: a trader leaderboard and protocol-wide volume, fees and activity, computed from indexed on-chain events.
- Volume events: time-boxed trading competitions with rules generated from the event definition, verified against on-chain activity.
- Pool: add and remove liquidity on the registered DEXes directly. ApexiSwap takes no fee on liquidity operations.
- Indexer and public API: a background indexer reads curve events chain-wide every minute; a subgraph-style API exposes pairs, tokens, swaps and liquidity for aggregators, scoped to ApexiSwap’s own venues.

A bridge to and from other networks exists for USDC, capped between 10 and 100 USDC per transaction with a 10% fee; it is an operator-run convenience and not part of the protocol.

## 16. Known limits

- Uniswap V3 routes are quoted and executed but not charged; the router does not yet build concentrated-liquidity calls.
- ApexisRouter (per-venue fee exemption) exists in source and is tested locally but is not deployed. Nothing in the interface depends on it yet.
- Ownership has no timelock. Configuration changes take effect in the block they are mined.
- The deployment described here is on Arc mainnet and handles real funds. Nothing in this document is an offer, a forecast or a promise of value.
- The application, not the contracts, decides which DEXes are quoted. A venue can be live on chain and absent from ApexiSwap until an operator enables it.
- This whitepaper must be revised whenever a contract or an economic parameter changes. The version table at the top is the record of that.