Trade

Instantly swap tokens: no registration or account needed.

Low fees

Why pay more? Trading Post runs on CAMP, a blockchain with much lower transaction costs than Ethereum or Bitcoin.

Trading fees are lower than other top decentralized exchanges too, so that's a double win for you!

Decentralized

Trade directly from your wallet.

Unlike centralized exchanges like Binance or Coinbase. Trading Post doesn't hold your funds when you trade: you have 100% ownership of your own crypto. Your keys your crypto.

Earn

Earn TP and other tokens for free by participating in the protocol

Earn tokens with Staking TP

Stake TP, earn free tokens. It's really that simple.

Earn TP with Yield Farms

Stake LP tokens, earn TP.

Earn Trading Fees

You can earn trading fees when you stake your tokens in Liquidity Pools (LPs).

Trading Post is a native social-first DEX built on Camp. Trading Post is the home for the teams and tokens built on Camp to provide them with a venue to trade their tokens. Allowing both users and the builders to leverage our trading venue for the best trading experience. Liquidity provider tools are also essential for Trading Post and allow for better yield capture for LPs.

Why Camp?

Camp Network is the user identity layer across blockchains. Camp aggregates online user data, enabling users to own and monetize their identity while helping teams like us Trading Post better understand user behavior.

This allows us to bring in social aspects to the trading experience that had previously been an isolated experience.

In Exchange V3, on default, Trading Post Smart Router will utilize liquidity from V3, V2, StableSwap, and the AMM or market makers, to execute trades and find the best price for traders.

However, users are always able to customize their trade by choosing which liquidity sources the router shall utilize, and enable or disable multihops and split routing.

Multihops allow tokens to swap through multiple hops between several liquidity pools to achieve the best deal. Turning it off will restrict trades to direct swaps, which may cause higher slippage or even fund loss.

Split routing enables tokens swaps to be broken into multiple routes to achieve the best deal. Turning it off will restrict trades from being executed with a single route, which may result in low efficiency or higher slippage.

StableSwap on Trading Post is a feature to trade stable pairs with a lower slippage based on an invariant curve slippage function. It is designed to swap specific assets that are usually priced closely - such as stablecoins or liquidity-staking tokens.

The StableSwap is an implementation of Curve Finance's AMM on Trading Post. It adds a linear invariant constant sum curve (x+y=K) on top of the constant product formula (x*y=k) to keep prices more equal as long as the liquidity pool is not extremely unbalanced. As a result, since StableSwaps are restricted to similarly priced assets, the impermanent loss is not as much of a concern (except in extreme depeg cases) and the slippage is lower than normal AMM which just uses the constant product formula.

When you conduct a Swap (trade) on the StableSwap you will pay lower trading fees, than the usual 0.25% on Exchange V2 AMM.

StableSwap Fees

Fees for each pair are broken down per trading pair.

The team will gradually roll out StableSwap pairs and revise the fees to test and improve the experience further.

Why should I use the StableSwap instead of the normal AMM?

• Swap your stablecoins or other pairs with similar asset prices more efficiently with the same trade steps

• With the StableSwap function, the trading pair slippage is lower than normal AMM

• The StableSwap trading fees are lower compared to the normal AMM

Trading Post Smart Router is a routing algorithm that links the AMM and stableswap, and the AMM to market makers, to provide better liquidity and pricing. It uses a smart order routing algorithm that executes trades across multiple pools to find the best price for traders.

Why should I use the Smart Router for my AMM swaps?

• Swap your stablecoins or other pairs with similar asset prices more efficiently with the same trade steps.

• Swap against market makers, who may provide better execution on trades than the normal Trading Post AMM.

• With the StableSwap function, the trading slippage is lower than normal AMM

• The StableSwap trading fees are lower compared to the normal AMM

Yield Farms allow users to earn TP while supporting Trading Post by staking LP Tokens.

Reward Calculations

Yield Farm APR calculations include both:

• LP rewards APR earned through providing liquidity and;

• Farm base rewards APR earned through staking LP tokens in the Farm.

Why? Because when you stake your LP tokens in a farm to earn TP, you're still providing liquidity to the liquidity pool, so you earn LP rewards as well!

Calculating Farm Base Reward APR

The Farm Base APR is calculated according to the farm multiplier and the total amount of liquidity in the farm - this is the amount of TP distributed to the farm.

Calculating LP Reward APR

On top of that, farmers receive LP Rewards for providing liquidity. Here's an example of calculating LP Rewards:

To calculate the yearly fees

• Use the 24H volume to calculate the fee share of liquidity providers in the pool

• Use the Fee share to estimate the projected yearly fees earned by the pool (based on the current 24h volume)

• We can now use the yearly fees to calculate the LP rewards APR: That's yearly fees divided by liquidity equals LP reward APR.

veTP stands for vote-escrowed TP. veTP tokens serve a crucial role in Trading Post's governance, enabling you to actively participate in Trading Post's governance proposals and Gauges voting system. This allows you to vote on broader governance proposals and influence the allocation of TP emissions within liquidity pools.

Gauges Voting empowers veTP holders to shape the distribution of TP emissions across essential products like Farms. By leveraging veTP, users directly influence how TP emissions are allocated within each pool, impacting specific liquidity pools and projects. The more veTP a pool accumulates through Gauge Voting, the higher the TP emissions allocated, leading to increased rewards for liquidity providers (LPs) during the subsequent 14-day epochs.

Lock TP for any duration from 1 week to 4 years to get veTP. Your veTP amount is based on the number of your locked TP and the duration you locked them for.

Here are the guides for how to get veTP, by creating a new position.

When you make a token swap (trade) on Trading Post, you will pay trading fees according to the type of liquidity pool your trade is being routed through. You may check the route details by clicking the magnifier icon on the "Route" section.

For Exchange V3 liquidity pools, there are currently four different fee tiers: 0.01%, 0.05%, 0.25%, and 1%.

For StableSwap liquidity pools, the fee rate depends on the individual pool configurations. Please check the "Fee" section for more details.

For Exchange V2 liquidity pools, a fixed 0.25% trading fee is applied

Please refer to Github repo for the latest version

Code:

1. Blocks: Tracks all blocks on CAMP

2. Exchange V2: Tracks all Trading Post V2 Exchange data with price, volume, liquidity,...

3. Pairs: Tracks all Trading Post Pairs and Tokens

Main contracts

The following links will take you to the explorer page for Trading Post's main smart contracts

• Trading Post: Main Staking Contract / MasterChef v3

Exchange V3

In the Exchange V3, liquidity will be managed in the form of a non-fungible position. You will still earn a share in the fees while providing liquidity.

When you add your token to a Liquidity Pool you will receive a Liquidity Provider NFT token and share in the fees.

Token Whitelist

If you want to get your token whitelisted on the Trading Post front-end, please go through this link and follow the instructions there:

Token Hyperlink

Overview

Trading Post is an Automated Market Maker (AMM), and the Exchange is at the heart of TradingPost. Trading Post is the designated home AMM on the CAMP network!

The Trading Post offers several features that support decentralized trading:

Limit Orders

Allow you to get your swaps at desired prices by leaving instructions how to fill buy or sell orders at specific prices. The trade will only be executed if the price on Trading Post reaches your limit price (or better).

TWAP (Time-weighted Average Price)

What is veTP?

veTP stands for vote-escrowed TP. It is not transferable, and the only way to acquire veTP is by staking TP. The maximum lock time is 4 years; the longer you lock your TP, the more veTP you'll receive.

What is the purpose of veTP?

What is a gauge?

To understand gauges voting, you may think of any products that require TP emissions as a series of gauges. This includes farms, TP weekly reward pool, position manager vaults, etc.

veTP holders can now use their veTP as votes to decide how much % of TP goes to which product. The more veTP a gauge accumulates through Gaguges Voting, the more TP emissions will be allocated to the underlying liquidity pool / position manager vault.

Gauge Types

There are two types of gauges - 'core' and 'non-core'. TP emissions to the former are controlled by the Team, while the community influences emissions to 'non-core' pools by voting with veTP.

1. 'Core' gauges include pairs with major tokens and stablecoins - the Team will make sure these pairs receive sufficient TP rewards as they contribute significantly to the protocol's revenue.

2. 'Non-core' gauges represent all other gauges not classified as 'core' gauges

How to Vote?

1 - Understand the voting schedule

Gauges weight voting is conducted every two weeks. The beginning of an epoch, just like revenue sharing, is at 00:00 UTC every even Thursdays.

In the above example:

• Epoch 1 is starting at 00:00 UTC, 1st, Thursday on Week 1.

• Epoch 1 is ending 2 weeks later, at 00:00 UTC, 15th, Thursday on Week 3.

• Users can vote during 00:00 UTC from 1st to 14th.

• NO votes can be cast during 00:00 UTC from 14th to 15th as votes are being adjusted and tallied.

2 - Become eligible

Since veTP is gradually decreasing according to the remaining lock time, voting results will be taken via a snapshot at the end of every epoch. This incldues the number of total veTP, and the veTP each user has.

In the above example:

• Results for Epoch 1, will be based on the veTP balances at 00:00 UTC, 15th.

• Users whose veTP position is unlocking before or equal to the 15th, will have 0 veTP balance at the snapshot time. Therefore they have no voting power for Epoch 1.

Therefore, to become eligible, you must obtain an active veTP position, which unlocks AFTER the end/ snapshot time of the current epoch.

In the above eample:

• If you want to vote in epoch 1, you must have veTP position which unlocks on the 21st or later than the 21st, or Thursday on week 3.

3 - Check the current voting results

Head to "TP staking", scroll down and look for the "Gauges Voting" section, then click "Check Gauges".

At the top-left section. You may find:

• Your veTP

• Snapshot time and voting end time for the current epoch.

• The total number of TP rewards to be distributed in the next epoch based on the voting results from the current epoch.

• The total amount of veTP votes casted.

At the top-right, you may find a pie chart representing the % of each gauge received.

At the bottom, there is a complete list of every voting gauges. With the number of votes they received and the expected % weight, they are gaining in the current epoch. There is also a "boost" and "caps" field, detailing two important gauge characteristics. Continue reading for more details.

Gauge Boost and Emission Caps

To ensure TP rewards go to the most productive gauges. Each gauge can be applied with a boost and/or an emission cap. Two of the characteristics can both exist at the same time.

Gauge Boost is a multiplier applied to the number of votes a gauge receives, ranging from 1x to 2.5x (gauges for V3 pools are capped at 2x). This is to encourage votes and liquidity for important trading pairs.

Emission cap is a maximum cap on the % weight a gauge can receive, ranging from 2% to 20%. This is to promote fairness in allocation and prevent abuse of the gauge system.

For example:

• A gauge has 10 votes, 2x boost and 15% cap. The total vote is 100.

• After applying the boost, this gauge will have 20 votes, 20% weight against the total (100).

• However, since it has a 15% cap, the final % of TP rewards this gauge receives in the next epoch will be adjusted to 15%.

How are Gauge Boost and Emission Caps determined?

During the process of a gauge application, we ask applicants to propose the value of the boost multiplier and emissions cap % they wish to assign to the gauge. These have to be voted on by veTP holders, along with the entire gauge application.

The default option for all gauges is 1.00x multiplier and 5% emission cap. They can be changed with future proposals.

4 - Add gauges to vote

To vote on a gauge, scroll down and look for "My Votes" section. Click "Add Gauge".

In the pop-up window, you may add gauges to your list of votes by clicking the blue "+" icon. You may find the current voting results in the list, along with boost and caps.

To quickly locate a gauge, you can use filtering to filter gauges by blockchains, fee tiers and liquidity types. Or type in the token ticker into the search field.

5 - Select how much % veTP to vote on each gauge

Once you have added the gauges, you may select how much % of your veTP goes to each of the gauges.

This is because:

• veTP gradually decreases with the remaining lock time. It is impractical to estimate and calculate how many exact veTP to vote.

• It is troublesome to re-vote in every upcoming epoch. Therefore, gauge voting is designed to carry your voting decisions throughout the upcoming epoch until you cast a new one.

6 - Update your votes

Once your vote is submitted, you may see your votes being updated to "Current Votes". And the remaining veTP gets updated.

Please note that the voting decision for each gauge can only be updated every 10 days. Once you submit a vote request, all voted gauges will be applied a 10-day cooldown period before you can submit another request for updates.

To update your vote decision, change the % percentage and submit again.

Core

Mainnet

Testnet

Periphery

Mainnet

Testnet

Smart Router

Able to route to v3, v2, and stable pool

Mainnet

Testnet

MastchefV3

Mainnet

Testnet

Simply lock TP for a period of time!

Go to the TP staking page

Choose the lock amount and duration

• Input the amount of TP you wish to lock

• Select the amount of time you wish to lock

There is no minimum amount to lock and the minimum duration to lock is 1 week with a maximum of 4 years.

Approve TP spend and start locking

Once confirmed, click "Lock TP" to proceed. A loading modal will appear and your wallet should prompt you to confirm TP spending. Confirm the transaction in the wallet to continue.

After the TP spend approval transaction is executed. Another wallet pop-up should appear. Confirm that transaction to lock TP and receive veTP.

Congratulations!

Once confirmed, you should see your veTP staking position details on the left, with the amount of TP locked and the unlock time. Then most importantly - your veTP number.

Scroll down to check on all the veTP benefits!

V3SwapRouter

Solidity API

Contract Info

Contract name: NonfungiblePositionManager

Contract address

Solidity API

Position

constructor

positions

Returns the position information associated with a given token ID.

Throws if the token ID is not valid.

Parameters

Return Values

mint

Creates a new position wrapped in a NFT

Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized a method does not exist, i.e. the pool is assumed to be initialized.

Parameters

Return Values

isAuthorizedForToken

tokenURI

baseURI

_Returns the base URI set via {setBaseURI}. This will be automatically added as a prefix in {tokenURI} to each token's URI, or to the token ID if no specific URI is set for that token ID.

increaseLiquidity

Increases the amount of liquidity in a position, with tokens paid by the msg.sender

Parameters

Return Values

decreaseLiquidity

Decreases the amount of liquidity in a position and accounts it to the position

Parameters

Return Values

collect

Collects up to a maximum amount of fees owed to a specific position to the recipient

Parameters

Return Values

burn

Burns a token ID, which deletes it from the NFT contract. The token must have 0 liquidity and all tokens must be collected first.

Parameters

_getAndIncrementNonce

Gets the current nonce for a token ID and then increments it, returning the original value

getApproved

_Returns the account approved for tokenId token.

Requirements:

• tokenId must exist._

_approve

_Overrides approve to use the operator in the position, which is packed with the position permit nonce

Integrating Trading Post's routers and swaps remains very similar to integrating Uniswap or PancakeSwap's routers and swaps. Developers familiar with this should have relative ease with integrations, though users should reference Uniswap's or PancakeSwap's documentation if you're seeking more information please contact Trading Post's contributors in our Discord if you have specific questions.

Solidity API

factory

The contract that deployed the pool, which must adhere to the ITradingPostV3Factory interface

Return Values

token0

The first of the two tokens of the pool, sorted by address

Return Values

token1

The second of the two tokens of the pool, sorted by address

Return Values

fee

The pool's fee in hundredths of a bip, i.e. 1e-6

Return Values

tickSpacing

The pool tick spacing

Ticks can only be used at multiples of this value, minimum of 1 and always positive e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ... This value is an int24 to avoid casting even though it is always positive.

Return Values

maxLiquidityPerTick

The maximum amount of position liquidity that can use any tick in the range

This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool

Return Values

PROTOCOL_FEE_SP

PROTOCOL_FEE_DENOMINATOR

Slot0

slot0

The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas when accessed externally.

Return Values

feeGrowthGlobal0X128

The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool

This value can overflow the uint256

feeGrowthGlobal1X128

The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool

This value can overflow the uint256

ProtocolFees

protocolFees

The amounts of token0 and token1 that are owed to the protocol

Protocol fees will never exceed uint128 max in either token

liquidity

The currently in range liquidity available to the pool

This value has no relationship to the total liquidity across all ticks

ticks

Look up information about a specific tick in the pool

ParametersReturn Values

tickBitmap

Returns 256 packed tick initialized boolean values. See TickBitmap for more information

positions

Returns the information about a position by the position's key

ParametersReturn Values

observations

Returns data about a specific observation index

You most likely want to use #observe() instead of this method to get an observation as of some amount of time ago, rather than at a specific index in the array.

ParametersReturn Values

lmPool

SetLmPoolEvent

lock

Mutually exclusive reentrancy protection into the pool to/from a method. This method also prevents entrance to a function before the pool is initialized. The reentrancy guard is required throughout the contract because we use balance checks to determine the payment status of interactions such as mint, swap and flash.

onlyFactoryOwner

Prevents calling a function from anyone except the address returned by ITradingPostV3Factory#owner()

constructor

_blockTimestamp

Returns the block timestamp truncated to 32 bits, i.e. mod 2**32. This method is overridden in tests.

snapshotCumulativesInside

Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range

Snapshots must only be compared to other snapshots, taken over a period for which a position existed. I.e., snapshots cannot be compared if a position is not held for the entire period between when the first snapshot is taken and the second snapshot is taken.

Parameters

Return Values

observe

Returns the cumulative tick and liquidity as of each timestamp secondsAgo from the current block timestamp

To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick, you must call it with secondsAgos = [3600, 0]. The time weighted average tick represents the geometric time weighted average price of the pool, in log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.

Parameters

Return Values

increaseObservationCardinalityNext

Increase the maximum number of price and liquidity observations that this pool will store

This method is no-op if the pool already has an observationCardinalityNext greater than or equal to the input observationCardinalityNext.

Parameters

initialize

Sets the initial price for the pool

not locked because it initializes unlocked

Parameters

ModifyPositionParams

mint

Adds liquidity for the given recipient/tickLower/tickUpper position

_noDelegateCall is applied indirectly via modifyPosition

Parameters

Return Values

collect

Collects tokens owed to a position

Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity. Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.

Parameters

Return Values

burn

Burn liquidity from the sender and account tokens owed for the liquidity to the position

_noDelegateCall is applied indirectly via modifyPosition

Parameters

Return Values

SwapCache

SwapState

StepComputations

swap

Swap token0 for token1, or token1 for token0

The caller of this method receives a callback in the form of ITradingPostV3SwapCallback#tradingPostV3SwapCallback

Parameters

Return Values

flash

Receive token0 and/or token1 and pay it back, plus a fee, in the callback

The caller of this method receives a callback in the form of ITradingPostV3FlashCallback#tradingpostV3FlashCallback Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling with 0 amount{0,1} and sending the donation amount(s) from the callback

Parameters

setFeeProtocol

Set the denominator of the protocol's % share of the fees

Parameters

collectProtocol

Collect the protocol fee accrued to the pool

Parameters

Return Values

setLmPool

Contract info

Contract name: TradingPostFactory

View TradingPostFactory on Github

Contract address

Read functions

getPair

function getPair(address tokenA, address tokenB) external view returns (address pair);

Address for tokenA and address for tokenB return address of pair contract (where one exists).

tokenA and tokenB order is interchangeable.

Returns 0x0000000000000000000000000000000000000000 as address where no pair exists.

allPairs

function allPairs(uint) external view returns (address pair);

Returns the address of the nth pair (0-indexed) created through the Factory contract.

Returns 0x0000000000000000000000000000000000000000 where pair has not yet been created.

Begins at 0 for first created pair.

allPairsLength

function allPairsLength() external view returns (uint);

Displays the current number of pairs created through the Factory contract as an integer.

feeTo

function feeTo() external view returns (address);

The address to where non-LP-holder fees are sent.

feeToSetter

function feeToSetter() external view returns (address);

The address with permission to set the feeTo address.

Write functions

createPair

function createPair(address tokenA, address tokenB) external returns (address pair);

Creates a pair for tokenA and tokenB where a pair doesn't already exist.

tokenA and tokenB order is interchangeable.

Emits PairCreated (see Events).

setFeeTo

Sets address for feeTo.

setFeeToSetter

Sets address for permission to adjust feeTo.

Events

PairCreated

event PairCreated(address indexed token0, address indexed token1, address pair, uint);

Emitted whenever a createPair creates a new pair.

token0 will appear before token1 in sort order.

The final uint log value will be 1 for the first pair created, 2 for the second, etc.

Interface

Contract name: TradingPostFactory

Contract address

Solidity API

Deploys TradingPost V3 pools and manages ownership and control over pool protocol fees

owner

Returns the current owner of the factory

Can be changed by the current owner via setOwner

poolDeployer

Returns the current pool deployer

feeAmountTickSpacing

Returns the tick spacing for a given fee amount, if enabled, or 0 if not enabled

A fee amount can never be removed, so this value should be hard coded or cached in the calling context

getPool

Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist

tokenA and tokenB may be passed in either token0/token1 or token1/token0 order

feeAmountTickSpacingExtraInfo

Returns the tick spacing extra info

A fee amount can never be removed, so this value should be hard coded or cached in the calling context

constructor

createPool

Creates a pool for the given two tokens and fee

tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. tickSpacing is retrieved from the fee. The call will revert if the pool already exists, the fee is invalid, or the token arguments are invalid.

Parameters

Return Values

setOwner

Updates the owner of the factory

Must be called by the current owner

Parameters

enableFeeAmount

Enables a fee amount with the given tickSpacing

Fee amounts may never be removed once enabled

Parameters

setWhiteListAddress

Set an address into white list

Address can be updated by owner with boolean value false

Parameters

setFeeAmountExtraInfo

Set a fee amount extra info

Fee amounts can be updated by owner with extra info

Parameters

Contract info

Contract name: TradingPostRouter

View on Github

Contract Address

Read functions

WETH

function WETH() external pure returns (address);

Returns the canonical address for CAMP: WETH (WETH being a vestige from Ethereum network origins).

factory

function factory() external pure returns (address);

Returns the canonical address for TradingPostFactory

getAmountOut

function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut);

getAmountIn

function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn);

getAmountsOut

function getAmountsOut(uint amountIn, address[] memory path) internal view returns (uint[] memory amounts);

getAmountsIn

function getAmountsIn(uint amountOut, address[] memory path) internal view returns (uint[] memory amounts);

quote

function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB);

Write functions

addLiquidity

Adds liquidity to a BEP20⇄BEP20 pool.

addLiquidityETH

removeLiquidity

removeLiquidityETH

removeLiquidityETHSupportingFeeOnTransferTokens

removeLiquidityETHWithPermit

removeLiquidityETHWithPermitSupportingFeeOnTransferTokens

removeLiquidityWithPermit

swapETHForExactTokens

swapExactETHForTokens

swapExactETHForTokensSupportingFeeOnTransferTokens

swapExactTokensForETH

swapExactTokensForETHSupportingFeeOnTransferTokens

swapExactTokensForTokens

Receive as many output tokens as possible for an exact amount of input tokens.

swapExactTokensForTokensSupportingFeeOnTransferTokens

Receive as many output tokens as possible for an exact amount of input tokens. Supports tokens that take a fee on transfer.

swapTokensForExactETH

Receive an exact amount of ETH for as few input tokens as possible.

swapTokensForExactTokens

Receive an exact amount of output tokens for as few input tokens as possible.

Interface