| Velora Delta API | Access an intent-based protocol that enables gas-less swaps where multiple agents compete to execute the trade at the best price possible. By using Velora Delta, users don’t need to make a transaction themselves but only to sign a Delta Order. | /pages/aBd8lttzMYzfqKkbfpqV |
| Velora Market API | Access a decentralized exchange aggregator that allows developers to access hundreds of DEXs and tens of thousands of liquidity pools in real-time. | /pages/mDSZg3LZM1suGYkjbwk9 |
| Overview | /pages/IdjtT8L3IE44n1W7vDUW |
| Contracts | |
| Retrieve delta Price with fallback to market | |
| Build a Delta Order to Sign | |
| Submit a Delta Order | |
| Track a Delta Order auction status | |
| Example: Quote With Fallback |
srcToken amount (in case of SELL) or destToken amount (in case of BUY).
The amount should be in WEI/Raw units (eg. 1WBTC -> 100000000)
Partner string.
If no partner is passed, it defaults to anon which charges a flat 1bps fee for all swaps. partner should be different from the existing ones that may charge indepent fees.
Preferred mode for the trade. In case of "all", Delta pricing is returned, with Market as a fallback.
Default: ALL.MARKET mode is not supported for cross-chain orders
| Name | Type | Description |
|---|---|---|
| price* | DeltaPrice | The delta object retrieved from /quote endpoint. |
| chainId* | number | Chain ID. (Mainnet - 1, Optimism - 10, BSC - 56, Polygon - 137, Fantom - 250, zkEVM - 1101, Base - 8453, Arbitrum - 42161, Avalanche - 43114, Gnosis - 100). |
| owner* | string | Order owner address. |
| bridge | DeltaBridge | Required only for cross-chain orders. See below for details |
| beneficiary | string | Order beneficiary. Default: zero address, meaning owner address. |
| slippage | number | Slippage in base points (100 is 1%). Default: 100. |
| deadline | number | Order expiry time as UNIX timestamp. Default: 1 hour from order creation. |
| nonce | string | Arbitrary uint256 value to be used as order nonce. Default: value generated with internal algos. It is recommended to omit this param. |
| permit | string | Encoded permit to be used in order settlement. Supported permit types are described here. Default: 0x. |
| partiallyFillable | boolean | If true, order will be generated as partially fillable. Default: false. |
| partnerAddress | string | Address of the partner. Used to collect fees from the order. Default: zero address. |
| partnerFeeBps | number | Partner fee percent in base points (100 is 1%). Max value is 200. Default: 0. |
| partnerTakesSurplus | boolean | If true, partner will collect 50% of the order surplus instead of flat percent fee. Default: false. |
| Name | Type | Description |
|---|---|---|
| order* | Order | The built order to be submitted. |
| signature* | string | Signature of the order from order.owner address. EOA signatures must be submitted in ERC-2098 Compact Representation. |
| chainId* | string | Chain ID. (Mainnet - 1, Optimism - 10, BSC - 56, Polygon - 137, Fantom - 250, zkEVM - 1101, Base - 8453, Arbitrum - 42161, Avalanche - 43114, Gnosis - 100). |
| type | MARKET | LIMIT | Indicates order type. Defaults to MARKET. Used for filtering only |
| partiallyFillable | boolean | Allow the order to be filled in parts. Default: false |
| partner | string | Partner string. |
| includeAgents | string[] | List of agent names to include. If not provided, all the agents are included |
| excludeAgents | string[] | List of agent names to exclude. If not provided, none of the agents are excluded |
| referrerAddress | string | Referrer address |
| domain | |
| type | |
| value | |
| Name | Type | Description |
|---|---|---|
| userAddress* | string | User Address. |
| chainId | string[] | Comma-separated list of chain ids (e.g. chainId=1,8453 |
| page | integer | Default: 1. |
| limit | integer | Default: 100. |
| type | LIMIT | MARKET | Filters orders by types. |
| status | OrderStatus[] | Comma-separated list of statuses described above. Other possible values are: - ACTIVE - any non-terminal status from the list above- INACTIVE - any terminal status from the list above - SUSPENDED - orders that are suspended, but might be executed in future (INSUFFICIENT_BALANCE/INSUFFICIENT_ALLOWANCE statuses) |
| API v6.2 | /pages/SW7QAU7hmhQzOX7Or5J6 |
| API v5 | /pages/-MhY5V6Vze2tY1WuQ9dp |
srcToken amount (in case of SELL) or destToken amount (in case of BUY).
The amount should be in WEI/Raw units (eg. 1WBTC -> 100000000)
SELL or BUY.
Default: SELL.
Network ID. (Mainnet - 1, Optimism - 10, BSC - 56, Polygon - 137, Base - 8453, Arbitrum - 42161, Avalanche - 43114, Gnosis - 100, Sonic - 146, Unichain - 130, Plasma - 9745).
Default: 1.
If provided, others object is filled in the response with price quotes from other exchanges (if available for comparison).
Default: false
Comma Separated List of DEXs to include.
All supported DEXs by chain can be found here
eg: UniswapV3, CurveV1
Comma Separated List of DEXs to exclude.
All supported DEXs by chain can be found here
eg: UniswapV3, CurveV1
Exclude all RFQs from pricing
eg: AugustusRFQ, Hashflow
Default: false
Dash (-) separated list of tokens (addresses or symbols from /tokens) to comprise the price route. Max 4 tokens.
\*Note: If route is specified, the response will only comprise of the route specified which might not be the optimal route.
Partner string.
If no partner is passed, it defaults to anon which charges a flat 1bps fee for all swaps. partner should be different from the existing ones that may charge indepent fees.
If the source token is a tax token, you should specify the tax amount in BPS.
\*For example: for a token with a 5% tax, you should set it to 500 as\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
| | destTokenTransferFee | string |If the destination token is a tax token, you should specify the tax amount in BPS.
\*For example: for a token with a 5% tax, you should set it to 500 as\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
| | srcTokenDexTransferFee | string |If the source token is a tax token, you should specify the tax amount in BPS.
Some tokens only charge tax when swapped in/out DEXs and not on ordinary transfers.
\*For example: for a token with a 5% tax, you should set it to 500 as\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
| | destTokenDexTransferFee | string |If the destination token is a tax token, you should specify the tax amount in BPS.
Some tokens only charge tax when swapped in/out DEXs, not on ordinary transfers.
\*For example: for a token with a 5% tax, you should set it to 500 as\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
| | version | number |To specify the protocol version. Values: 5 or 6.2
Default: 5
Allows the API to skip performing on-chain checks such as balances, allowances, as well as possible transaction failures.
\*Note: The response does not contain gas parameter when ignoreChecks is set to true.
Default: false
Allows the API to skip gas checks
\*Note: The response does not contain gas parameter when ignoreGasEstimate is set to true.
Default: false
Allows the API to return the contract parameters only.
Default: false
Allows the API to return EIP-1559 styled transaction with maxFeePerGas and maxPriorityFeePerGas paramters.
\*Note: We currently support EIP1559 transactions in the following chains:
Mainnet, Ropsten, and Avalanche.
Default: false
Allowed slippage percentage represented in basis points.
Eg: for 2.5% slippage, set the value to 2.5 \* 100 = 250; for 10% = 1000. Slippage could be passed instead of destAmount when side=SELL or srcAmount when side=BUY. Min: 0; Max: 10000
Address that will be entitled to claim fees or surplus.
\*Note: Fees have to be claimed from the Fee Claimer contract unless isSurplusToUser or isDirectFeeTransfer are used
If provided it is used together with partnerAddress. Should be in basis points percentage. Look at slippage parameter description for understanding better.
Eg: 200 (for 2% fee percent)
\*Note: Fees have to be claimed from the Fee Claimer contract unless isSurplusToUser or isDirectFeeTransfer are used
Your project name.
Used for providing analytics on your project swaps.
| | permit | string | Hex string for the signature used for Permit. This can be used to avoid giving approval. *Helps in saving gas.* | | deadline | integer |Timestamp (10 digit/seconds precision) till when the given transaction is valid. For a deadline of 5 minute, deadline: Math.floor(Date.now()/1000) + 300
E.g.: 1629214486
Allows for capping the surplus at 1% maximum.
Default: true
Allows to collect surplus. Works with partnerAddress
Default: false
Specify if user should receive surplus instead of partner.
Default: false
Specify if fees should be sent directly to the partner instead of registering them on FeeClaimer.
Default: false
` - something went wrong during the transaction build
* `It is not allowed to have limit-orders Dex or paraswappool Dex in route and 'ignoreChecks=true' together. Consider requesting the price with excluded limit-orders if you want to use 'ignoreChecks': &excludeDEXS=ParaSwapPool,ParaSwapLimitOrders`
* `It seems like the rate has changed, please re-query the latest Price`
* `The rate has changed, please re-query the latest Price`
* `This transaction has some errors and may fail. Please contact support for more details`
* `Not enough balance`
* `Not enough allowance given to TokenTransferProxy()`
* `Unable to check price impact` - src or dest tokens don’t have valid usd price
# Get Price & Calldata: /swap
The /swap endpoint allows you to make one API call to get both the priceRoute object as well as the Transaction Object.
It is designed to simplify the trading process by combining price estimation and transaction calldata generation into a single API call. This makes it a convenient option for users who want a quick and streamlined way to execute trades without handling multiple requests. However, while it offers ease of use, it also comes with certain limitations.
## Limitations
* Lower rate limits
* It doesn't check sufficient allowances and balances
* It doesn't return the gas field in txParams, thus the transaction should be simulated locally
* It automatically excludes RFQ-based DEXs such as AugustusRFQ & ParaSwapLimitOrders.
## Get Price Route & Transaction Building
`GET` `https://api.paraswap.io/swap`
This endpoint gets the optimal price and price route required to swap from one token to another.
Additionally the swap endpoint also generates the parameters required for the transaction.
#### Query Parameters
| Name | Type | Description |
| ---------------------------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| srcToken\* | string | Source Token Address. Instead **Token Symbol** could be used for tokens listed in the `/tokens` endpoint. |
| srcDecimals\* | integer | Source Token Decimals. (Can be omitted if Token Symbol is used in `srcToken`). |
| destToken\* | string | Destination Token Address. Instead **Token Symbol** could be used for tokens listed in the `/tokens` endpoint. |
| amount\* | string | srcToken amount (in case of SELL) or destToken amount (in case of BUY).
The amount should be in WEI/Raw units (eg. 1WBTC -> 100000000)
|
| side | string | SELL or BUY.
Default: SELL.
|
| network | string | Network ID. (Mainnet - 1, Optimism - 10, BSC - 56, Polygon - 137, Base - 8453, Arbitrum - 42161, Avalanche - 43114, Gnosis - 100, Sonic - 146, Unichain - 130, Plasma - 9745).
Default: 1.
|
| otherExchangePrices | boolean | If provided, others object is filled in the response with price quotes from other exchanges (if available for comparison).
Default: false
|
| includeDEXS | string | Comma Separated List of DEXs to include.
Supported DEXs:
Uniswap, Kyber, Bancor, AugustusRFQ, Oasis, Compound, Fulcrum, 0x, MakerDAO, Chai, Aave, Aave2, MultiPath, MegaPath, Curve, Curve3, Saddle, IronV2, BDai, idle, Weth, Beth, UniswapV2, Balancer, 0xRFQt, SushiSwap, LINKSWAP, Synthetix, DefiSwap, Swerve, CoFiX, Shell, DODOV1, DODOV2, OnChainPricing, PancakeSwap, PancakeSwapV2, ApeSwap, Wbnb, acryptos, streetswap, bakeryswap, julswap, vswap, vpegswap, beltfi, ellipsis, QuickSwap, COMETH, Wmatic, Nerve, Dfyn, UniswapV3, Smoothy, PantherSwap, OMM1, OneInchLP, CurveV2, mStable, WaultFinance, MDEX, ShibaSwap, CoinSwap, SakeSwap, JetSwap, Biswap, BProtocol
eg: UniswapV3,0x
|
| excludeDEXS | string | Comma Separated List of DEXs to exclude. (from the list of DEXs mentioned above). |
| includeContractMethods | string | Comma Separated List of Contract Methods to include without spaces. Available values: swapOnUniswap, buyOnUniswap, swapOnUniswapFork, buyOnUniswapFork, swapOnUniswapV2Fork, buyOnUniswapV2Fork, simpleBuy, simpleSwap, multiSwap, megaSwap, protectedMultiSwap, protectedMegaSwap, protectedSimpleSwap, protectedSimpleBuy, swapOnZeroXv2, swapOnZeroXv4, buy.
eg: simpleSwap,multiSwap
|
| excludeContractMethods | string | Comma Separated List of Contract Methods to exclude without spaces. (from the list of contract methods mentioned above). |
| userAddress | string | User's Wallet Address. |
| route | string | Dash (-) separated list of tokens (addresses or symbols from /tokens) to comprise the price route. Max 4 tokens.
\*Note: If route is specified, the response will only comprise of the route specified which might not be the optimal route.
|
| partner | string | Partner string. |
| partnerFeeBps | string | If provided it is used together with partnerAddress. Should be in basis points percentage. Look at slippage parameter description for understanding better. Eg: 200 (for 2% fee percent)
\*Note: Fees have to be claimed from the Fee Claimer contract unless isSurplusToUser or isDirectFeeTransfer are used
|
| partnerAddress | string | Address that will be entitled to claim fees or surplus.
\*Note: Fees have to be claimed from the Fee Claimer contract unless isSurplusToUser or isDirectFeeTransfer are used
|
| slippage | integer | Allowed slippage percentage represented in basis points.
Eg: for 2.5% slippage, set the value to 2.5 \* 100 = 250; for 10% = 1000. Slippage could be passed instead of destAmount when side=SELL or srcAmount when side=BUY.
Min: 0; Max: 10000
|
| destDecimals\* | integer | Destination Token Decimals. (Can be omitted if Token Symbol is used in `destToken`). |
| maxImpact | number | In %. It's a way to bypass the API price impact check (default = 15%). |
| receiver | String | Receiver's Wallet address. (Can be omitted if swapping tokens from and to same account) |
| srcTokenTransferFee | string | If the source token is a tax token, you should specify the tax amount in BPS.
\*For example: for a token with a 5% tax, you should set it to 500 as
\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
|
| destTokenTransferFee | string | If the destination token is a tax token, you should specify the tax amount in BPS.
\*For example: for a token with a 5% tax, you should set it to 500 as
\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
|
| srcTokenDexTransferFee | string | If the source token is a tax token, you should specify the tax amount in BPS.
Some tokens only charge tax when swapped in/out DEXs and not on ordinary transfers.
\*For example: for a token with a 5% tax, you should set it to 500 as
\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
|
| destTokenDexTransferFee | string | If the destination token is a tax token, you should specify the tax amount in BPS.
Some tokens only charge tax when swapped in/out DEXs, not on ordinary transfers.
\*For example: for a token with a 5% tax, you should set it to 500 as
\[(500/10000)\*100=5%]
\*\*Note: not all DEXs and contract methods support trading tax tokens, so we will filter those that don't.
|
| version | number | To specify the protocol version. **Values:** 5 or 6.2 **Default**: 5 |
| ignoreBadUsdPrice | boolean | If tokens USD prices are not available, `Bad USD Price` error will be thrown. Use this param to skip this check. Default: `false` |
| isSurplusToUser | boolean | Specify if user should receive surplus instead of partner.
Default: false
|
| isDirectFeeTransfer | boolean | Specify if fees should be sent directly to the partner instead of registering them on FeeClaimer.
Default: false
|
| isCapSurplus | boolean | Allows for capping the surplus at 1% maximum.
Default: true
|
| takeSurplus | boolean | Allows to collect surplus. Works with partnerAddress
Default: false
|
**Example:**
Here’s an example of an integrator that used the swap function to request a price and generate a transaction.
{% tabs %}
{% tab title="200 Successful Price Response." %}
```
{
"priceRoute": {
"blockNumber": 20184108,
"network": 1,
"srcToken": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
"srcDecimals": 6,
"srcAmount": "1000000",
"destToken": "0x6b175474e89094c44da98b954eedeac495271d0f",
"destDecimals": 18,
"destAmount": "997620341641628401",
"bestRoute": [
{
"percent": 100,
"swaps": [
{
"srcToken": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
"srcDecimals": 6,
"destToken": "0x6b175474e89094c44da98b954eedeac495271d0f",
"destDecimals": 18,
"swapExchanges": [
{
"exchange": "ShibaSwap",
"srcAmount": "1000000",
"destAmount": "997620341641628401",
"percent": 100,
"poolAddresses": [
"0x4610bA8d5D10FBa8C048A2051a0883CE04eaBAcE"
],
"data": {
"router": "0xF9234CB08edb93c0d4a4d4c70cC3FfD070e78e07",
"path": [
"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
"0x6b175474e89094c44da98b954eedeac495271d0f"
],
"factory": "0x115934131916C8b277DD010Ee02de363c09d037c",
"initCode": "0x65d1a3b1e46c6e4f1be1ad5f99ef14dc488ae0549dc97db9b30afe2241ce1c7a",
"feeFactor": 10000,
"pools": [
{
"address": "0x4610bA8d5D10FBa8C048A2051a0883CE04eaBAcE",
"fee": 30,
"direction": false
}
],
"gasUSD": "5.515040"
}
}
]
}
]
}
],
"gasCostUSD": "5.932529",
"gasCost": "107570",
"side": "SELL",
"version": "6.2",
"contractAddress": "0x6a000f20005980200259b80c5102003040001068",
"tokenTransferProxy": "0x6a000f20005980200259b80c5102003040001068",
"contractMethod": "swapExactAmountIn",
"partnerFee": 0,
"srcUSD": "1.0000000000",
"destUSD": "0.9973641328",
"partner": "anon",
"maxImpactReached": false,
"hmac": "39d19445379b69c115149340c5caaa05c898e840"
},
"txParams": {
"from": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
"to": "0x6a000f20005980200259b80c5102003040001068",
"value": "0",
"data": "0xe3ead59e0000000000000000000000005f0000d4780a00d2dce0a00004000800cb0e5041000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000006b175474e89094c44da98b954eedeac495271d0f00000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000db4d11c67691ad50000000000000000000000000000000000000000000000000dd8426a4440caf10a8104c26c244959a1d46f205acc49520000000000000000000000000133fc2c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000160a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000006000240000ff00000300000000000000000000000000000000000000000000000000000000a9059cbb0000000000000000000000004610ba8d5d10fba8c048a2051a0883ce04eabace00000000000000000000000000000000000000000000000000000000000f42406a000f20005980200259b80c51020030400010680000008000240000ff0600030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000f4240000000000000000000004de54610ba8d5d10fba8c048a2051a0883ce04eabace",
"gasPrice": "16000000000",
"chainId": 1
}
}
```
{% endtab %}
{% tab title="400 Price Error" %}
```
{
"error": "computePrice Error
```
{% endtab %}
{% endtabs %}
{% hint style="info" %}
🧙Though **srcDecimals** and **destDecimals** are optional parameters it is highly recommended to add them while doing the pricing. This will allow you to get prices for all the tokens, including the ones which are also not listed by Velora.
{% endhint %}
{% hint style="warning" %}
Swaps fees and Swap\&Transfer (where the receiver is not the same as the sender) don't work when `swapOnUniswap`, `swapOnUniswapFork`, `swapOnZeroXv2`, and `swapOnZeroXv4` etc. contract methods are used.
If you would like to disable these methods you can do so by setting a whitelist for methods where Swap\&Transfer is supported`includeContractMethods=simpleSwap,multiSwap,megaSwap`
{% endhint %}
#### Most common error messages
The following is a list of the most common error messages of the `/swap` endpoint. Most are self-explanatory and can be self-solved, but feel free to contact Velora Support using the chat in the bottom right corner of this page.
* `Missing response from pricing API` - failed to get a response from pricing API
* `Can not receive price route` - failed to receive price route from the pricing API response
# Example: Fetch Price & Build Transaction
Here’s an example of an implementation for Velora's Market API. It utilizes Velora's endpoints to fetch pricing information and build transactions for token swaps.
{% tabs %}
{% tab title="API" %}
{% embed url="" %}
{% endtab %}
{% tab title="SDK" %}
{% embed url="" %}
{% endtab %}
{% endtabs %}
{% embed url="" %}
# Get Tokens List
## Get tokens list for a network
`GET` `https://api.paraswap.io/tokens/:network`
This endpoint allows you to obtain a list of tokens curated by Velora.
#### Path Parameters
| Name | Type | Description |
| ------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| network | number | Network ID. (Mainnet - 1, Optimism - 10, BSC - 56, Polygon - 137, Base - 8453, Arbitrum - 42161, Avalanche - 43114, Gnosis - 100, Sonic - 146, Unichain - 130, Plasma - 9745).
Default: 1.
|
{% tabs %}
{% tab title="200 List of available tokens" %}
```
{
"tokens": [
{
"symbol": "ETH",
"address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"decimals": 18,
"img": "https://img.paraswap.network/ETH.png",
"network": 1
},
{
"symbol": "USDT",
"address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
"decimals": 6,
"img": "https://img.paraswap.network/USDT.png",
"network": 1
}
]
}
```
{% endtab %}
{% endtabs %}
{% hint style="danger" %}
Velora's API is not limited to the tokens that are listed on the tokens endpoint. Tokens endpoint is merely a list of tokens curated by Velora. This list is not actively maintained and will soon be deprecated. To use a more up-to-date list of tokens it is suggested to use [token-lists](https://tokenlists.org/).
{% endhint %}
# AugustusRFQ
## **What is** Velora's AugustusRFQ**?**
Velora AugustusRFQ Protocol is a set of smart contracts developed by Velora and available in Ethereum, Polygon, Binance Smart Chain, Avalanche, Arbitrum, and Optimism.
The goal of Velora's Multichain RFQ Protocol is to become a public good with which anyone can interact and build dApp use cases in a completely decentralized way.
# Introduction
## Key Features
The protocol goes beyond ERC-20 token PMM RFQ and enables, among others, ERC721 NFT peer-to-peer, RFQ, and OTC trading.
* **Top gas efficiency:** Velora's AugustusRFQ offer the most gas-efficient transactions in the market.
* **Greater flexibility for users:** the protocol allows not only token-to-token trade but also token-to-NFT, multiple token-to-NFT trading, and NFT-to-NFT swap. Moreover, it allows users to buy & sell ERC721 in the token of their choosing, independently of the other party’s token choice.
### Supported chains and tokens
**Chains**
* Ethereum
* Arbitrum
* Avalanche
* BSC
* Optimism
* Polygon
**Tokens**
* ERC-20
* ERC721
* ERC1155
# Contracts
### AugustusRFQ
AugustusRFQ is Velora's contracts
### Addresses of AugustusRFQ contract
');`\
`hmac.update('');`\
`console.log(hmac.digest('hex'));`
4. Attach the following headers to the request:
* `X-AUTH-DOMAIN` - the Domain as described earlier
* `X-AUTH-ACCESS-KEY` - the Access Key specified for the Domain
* `X-AUTH-TIMESTAMP` - the timestamp used to create the signature
* `X-AUTH-SIGNATURE` - the HMAC-SHA256 computed in the previous step
It is mandatory for the market maker to verify all these headers are correct/matching and the timestamp is sufficiently close to the current time (e.g. +/- 30 seconds). Otherwise, the request should be rejected with an appropriate error message to describe the issue.
### Tokens endpoint
Path: `/tokens`
Method: `GET`
This endpoint provides details of all tokens used by the market maker. The response should be a JSON object with the key `"tokens"`, which in turn contains an object containing a number of entries, the key of which is a Token ID (recommended to use the token's symbol if it is unique), and the value is an object with the following fields (most are just for informational purposes):
* `"symbol"` (string) - the token's symbol as determined by the market maker (should probably be the same as the one provided by the token's contract)
* `"name"` (string) - a full name for the token as determined by the market maker (should probably be the same as the one provided by the token's contract)
* `"description"` (string) - a description of the token, noting any important details where appropriate e.g. if it has been deprecated in favour of another token
* `"address"` (string) - the address of the token (case is ignored and normalized to lowercase on our side)
* `"decimals"` (number) - the number of decimals this token has i.e. which power of 10 value represents one whole token when it is processed on chain, normally the value returned by the `decimals()` method of the token's contract
* `"type"` (string) - type of token, for now we only support `"ERC20"` for market making (but we may also support `"ERC1155"` or `"ERC721"` in future since they are implemented in the smart contract)
This is an example of what to return from this endpoint (but without the newlines, indentation, spacing etc. that are not required, and given here to improve readability):
```json
{
"tokens": {
"WETH": {
"symbol": "WETH",
"name": "Wrapped Ether",
"description": "Canonical wrapped Ether on Ethereum mainnet",
"address": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"decimals": 18,
"type": "ERC20"
},
"USDC": {
"symbol": "USDC",
"name": "USD Coin",
"description": "Popular US dollar stablecoin, provided by Circle",
"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"decimals": 6,
"type": "ERC20"
}
}
}
```
### Pairs endpoint
Path: `/pairs`
Method: `GET`
This endpoint provides a list of trading pairs supported by this market maker (or recently disabled), mapping Pair IDs to base and quote Token IDs, and also giving an estimated indication of liquidity in USD terms associated with this pair (this is used to assist with finding routes between tokens). Pairs should normally only be given in one direction of base vs. quote since the pricing of the other direction can be easily derived.
The response should be a JSON object containing the key `"pairs"`, which in turn contains a JSON object containing a number of entries, the key of which is the Pair ID, and the value being a JSON object with the following:
* `"base"` (string) - Token ID representing the base token of this pair (the token which the bids/asks are for)
* `"quote"` (string) - Token ID representing the quote token of this pair (the token in which prices are given)
* `"liquidityUSD"` (number) - an estimate of the liquidity the market maker has backing this pair, in US dollar terms (could be the maximum the market maker is willing to sell in both tokens, converted to USD and added together)
The Pair ID is recommended to be base token ID/symbol followed by `/` then the quote token ID/symbol. Here is an example payload returned from this endpoint (again ignoring newlines/indentation/spacing):
```json
{
"pairs": {
"WETH/USDC": {
"base": "WETH",
"quote": "USDC",
"liquidityUSD": 468000
},
"WETH/USDT": {
"base": "WETH",
"quote": "USDT",
"liquidityUSD": 512500
},
"WBTC/WETH": {
"base": "WBTC",
"quote": "WETH",
"liquidityUSD": 129800
}
}
}
```
### Prices endpoint
Path: `/prices`
Method: `GET`
This endpoint provides the full grid of price curves for all the supported pairs, which Velora will store in its cache, and can also specify pairs to remove from the cache, or even restrict trading to a single direction.
The response should be a JSON object containing the key `"prices"`, which in turn contains a JSON object with a number of entries, with the key being a Pair ID, and the value being an object which may contain the keys `"bids"` and `"asks"` (omitting either key means that trading in that direction is disabled and the corresponding cache entry will be cleared; to disable the pair entirely, both can be omitted so the object is empty `{}`).
Both `"bids"` and `"asks"` if present, should consist of an array of `[price, amount]` tuples defining the price curve as an order book, where `price` is a string representing the price of one base token in terms of the quote token, and `amount` is a string representing the amount of base token for this entry. We use `bignumber.js` library to parse these strings as decimal numbers with high precision. When computing a price the "orders" (tuples) are filled in sequential order, until the desired amount is reached. As such it is expected that the entries start with the best price and get progressively worse (however this is not enforced, so any price curve can be used). It is also expected that the best ask price is above the best bid price (this is not enforced neither, so market makers can risk arbitrage to deliver market beating prices and/or accelerate trading volume if they so wish).
Here is an example payload (newlines/indentation/spacing may be removed in the real thing):
```json
{
"prices": {
"WETH/USDC": {
"bids": [
["1540", "0.5"],
["1500", "1.5"],
["1480", "3"]
],
"asks": [
["1560", "1"],
["1580", "1.5"],
["1600", "2"],
["1650", "9"]
]
},
"WETH/USDT": {}
}
}
```
In this example, trading for WETH/USDT is disabled (the cached prices for it will be cleared). A user selling 1.5 WETH to this market maker should receive 1540 \* 0.5 + 1500 \* 1 = 2270 USDC (average price 1513.333 USDC), whereas buying 10 WETH from the market maker, they would spend 1560 \* 1 + 1580 \* 1.5 + 1600 \* 2 + 1650 \* 5.5 = 16205 USDC (average price 1620.5 USDC). For computing prices based on a quote token amount (USDC in this case) we invert the order book (bids become asks and vice versa, new price is computed as 1 / price, and new amount is price \* amount), then use the same process.
Note that if you wish to remove a pair from trading, it should not be removed from `/pairs` endpoint straight away. Instead, it must be retained there and given prices of `{}` as shown above for WETH/USDT for a period of time, after which it can finally be removed.
Failing to respond to this endpoint or responding with an error will cause market making to be temporarily disabled for this market maker, which may be done intentionally if you wish to cease trading entirely for a period of time.
### Firm quotes endpoint
Path: `/firm`
Method: `POST`
This endpoint is used to obtain a firm rate from the market maker, which is represented as a signed order for the AugustusRFQ smart contract.
For use in the Velora system the taker is set as a Velora contract (depending on execution context it can be Augustus V5, Augustus V6 or another contract) and the user of Velora (the `msg.sender` to AugustusSwapper) is encoded as metadata in the `nonceAndMeta` field; AugustusSwapper or other contracts are programmed to always check the user and metadata are matching when interacting with AugustusRFQ, so that no one can steal the order from the user and importantly to avoid users spamming requests for firm quotes, since they have to use a real user address and this address can be blacklisted by the market maker if they do so.
The body of the `POST` request will contain the following in a JSON object:
* `"makerAsset"` (string) - address of the token the maker is selling
* `"takerAsset"` (string) - address of the token the taker is selling
* `"makerAmount"` or `"takerAmount"` (string) - amount of the maker or taker asset respectively that is to be traded (only one may be specified and the other is calculated by the market maker based on current prices), this is specified as an integer by scaling up by 10^decimals
* `"userAddress"` (string) - address of the user as described above
* `"takerAddress"` (string) - address of the Velora contract that fills the order passed by Velora on calling POST /firm (either Augustus or another contract depending on the execution context. For V5 it's always [AugustusV5](https://developers.paraswap.network/smart-contracts#augustusswapper), for V6 it's either AugustusV6 or Executors). These addresses can be verified in the documentation [here](https://developers.paraswap.network/smart-contracts#augustusswapper) or by the API endpoint [here](https://api.paraswap.io/adapters/contract-takers?network=137).
Here is an example payload sent to market maker (will be sent without newlines/indentation/spacing, the case of alphabetic characters in addresses is not specified, it may be all lowercase/uppercase or checksum encoded, the market maker should normalize it to the desired format):
```json
{
"makerAsset": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"takerAsset": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"takerAmount": "1500000000000000000",
"userAddress": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"takerAddress": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57"
}
```
This request represents a user selling 1.5 WETH for USDC.
Note that the specified amount specified in taker or maker asset may be slightly larger than the amount the user is able to swap, so that there is some flexibility if e.g. it is part of a multihop and the user receives less/more of the taker asset from a previous swap.
The response to this request should be a JSON object containing the key `"order"`, which in turn contains a JSON object with the following fields:
* `"nonceAndMeta"` (string) - a number (`uint256`) which encodes the user's address in the lower 160 bits and is otherwise filled with random/unpredictable data i.e. to calculate this, convert the address to an integer, and add it to a random integer shifted left by 160 bits (the random integer must be less than 2^96), e.g. in Python `(random.randint(0, 2**96 - 1) << 160) + int(address, 16)`
* `"expiry"` (number) - the time in seconds past UNIX epoch at which this order becomes no longer executable, this should be at least 2 minutes in the future
* `"makerAsset"` (string) - same as one passed in
* `"takerAsset"` (string) - same as one passed in
* `"maker"` (string) - this is the address containing the market maker's funds and it must have approved the AugustusRFQ contract to spend them, it is also the signer of the order if it is an EOA, otherwise it is a smart contract implementing EIP-1271
* `"taker"` (string) - the address of the contract that fills the order which can be picked from the request payload (either Augustus or another contract depending on the execution context. Augustus addresses can be verified [here](https://developers.paraswap.network/smart-contracts#augustusswapper))
* `"makerAmount"` (string) - same as that passed in or calculated from the taker amount
* `"takerAmount"` (string) - same as that passed in or calculated from the maker amount
* `"signature"` (string) - `0x` followed by any number of bytes encoded in hexadecimal (lowercased) representing the `bytes` signature in the AugustusRFQ smart contract (the order hash of all other fields listed here is computed using EIP-712, and this must be signed using either an EOA or a smart contract EIP-1271 signature)
For creating the signature using an EOA maker address, please refer to the Velora SDKs (TypeScript or Python) for sample code or even consider using them directly. For example in the Python SDK you can use the function `create_managed_p2p_order` to create a suitable order and `OrderHelper.sign_order` to sign it using `web3`. If you use a EIP-1271 signature it depends on your smart contract how the signing will work, so you may need custom code.
Here is an example response payload (yet again ignore newlines/indentation/spacing):
```json
{
"order": {
"nonceAndMeta": "77194726158210796949047323338180021686013833221005105572687668833110133598159",
"expiry": 1667344557,
"makerAsset": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"takerAsset": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"maker": "0x7777777777777777777777777777777777777777",
"taker": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
"makerAmount": "2270000000",
"takerAmount": "1500000000000000000",
"signature": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcc"
}
}
```
This payload corresponds to previously given examples regarding assets and prices etc.
If the request cannot be processed because the user address is blacklisted, and only in this case, you can return a successful response without any `"order"` key. Optionally, this can contain a `"message"` field explaining that the user was blacklisted and even having a reason why. When a user is detected blacklisted in this way it is added to the cache just as if it was received in the `/blacklist` endpoint described below.
You could also use our [SDK](/api/augustusrfq/sdk) for order signing. Please note, that you should pass `takerAddress` from the payload (whitelisted Velora contract) as `contractTaker`, and `userAddress` (actual user address) as `taker`, as described in the example [here](/api/augustusrfq/sdk/typescript#to-sign-a-limit-order).
### Blacklist endpoint
Path: `/blacklist`
Method: `GET`
This endpoint is used to list any user addresses which are currently blacklisted. The payload is simply a JSON object with a key `"blacklist"` containing an array of blacklisted user addresses. This should not contain duplicate entries! Here is an example:
```json
{
"blacklist": [
"0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"0x0000000000000000000000000000000000000000"
]
}
```
### WebSocket connection (optional)
Market makers may optionally provide a WebSocket interface, in addition to the other endpoints. This is a one way channel from market maker to Velora, intended to serve pricing updates more efficiently. Each message is a JSON object, and it can be used to send any information from other endpoints at any time, except for `"order"`, however instead of sending the complete data each time (except for the very first message), it sends updates (creating or updating entries only, not deleting them). Here are specific details for each possible key:
* `"tokens"` should contain details of any newly supported tokens or corrections to existing ones
* `"pairs"` should contain any newly added pairs or corrections to existing ones, it is not recommended to update `"liquidityUSD"` by WebSockets since it is not used from this source and it is anyhow constantly changing
* `"prices"` should contain any pairs which need their prices updated, refreshed in the cache (after not being updated for too long), or that should be removed from the cache (bids, asks or both)
* `"blacklist"` should contain only newly added user addresses
* `"message"` can be used at any time to cause information to be logged on Velora servers
When the WebSocket is connected the first message should contain the complete responses to `/tokens`, `/pairs`, `/prices` and `/blacklist` endpoints in one JSON object (so that they don't need to be requested separately and potentially introduce synchronization issue). Once the connection is established the `/blacklist` endpoint will still be queried periodically in order to refresh the blacklisted status of all blacklisted users, which is only stored in cache temporarily.
Should the market maker wish to stop trading entirely, the websocket connection can simply be disconnected and refuse to reconnect until they wish to start trading again.
# Data structure in our centralized system
This page explains the data structure of Velora's centralized service handling limit orders. It's adding some features like:
* tracking **maker** `balance` and `allowance` for ERC20 tokens.
* tracking state of orders
* Fulfillment.
* Cancellation.
* Expiration.
* Partially fulfillment.
For more information, please refer to the following document:
{% content-ref url="/pages/UVaMjvQgfQmLLPmINxSg" %}
[On chain Data Structure](/api/augustusrfq/on-chain-data-structure)
{% endcontent-ref %}
## ERC20: Order structure
```json
{
"expiry": 0,
"createdAt": 1661165141,
"updatedAt": 1661165141,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "10000000000000000",
"fillableBalance": "10000000000000000",
"swappableBalance": "10000000000000000",
"makerBalance": "10000000000000000",
"takerAmount": "7775870000000000",
"signature": "0x43dd8dbc8228594171d0ed3e633ca0eb5c24f46bf0575100623ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b",
"orderHash": "0xdef400fd95d028d8caaba2c4887d2694563e0bc7f73c17d747feac2e24ed411d",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
}
```
### Difference with on-chain limit order
* `nonceAndMeta`: In our centralized system we force nonce and meta to be constructed from an address plus a random integer between `0` and `2 ^ 53 - 1` shifted 160 bits. The address that we pack is the actual taker address. (The address that swap `takerAsset` to `maketAsset`)
```
nonceAndMeta = address + (randInt(0, 2 ^ 53 - 1) << 160)
```
* `takerFromMeta`: is the decoded taker from `nonceAndMeta`. In Augustus contract we check the actual `takerAddress` (The address who swap `takerAsset` to `makerAsset`) by extracting its value from `nonceAndMeta`.
* `fillableBalance`: is the amount that remains to be filled and can be used to check if the amount is partially filled. (`fillableBalance` ≠ `makeAmount`)
* `swappableBalance`: is the actual amount that can be filled at this time.
* `makerBalance`: max amount `makerAddress` can fill the limit order.
* `orderHash`: hash of the on-chain Data structure.
* permitMakerAsset: always null for now will be used to store permit.
* `type`: `P2P` / `LIMIT` differentiate `p2p` from normal orders
* `P2P`: has `takerFromMeta` set to some specific address.
* `LIMIT`: has `takerFromMeta` set to `0x....0`.
* `state`: `PENDING` / `FULFILLED` / `EXPIRED` / `CANCELLED`.
* `PENDING`: order is still usable.
* `FULFILLED`: order is fully fulfilled.
* `EXPIRED`: order is expired.
* `CANCELLED`: order is canceled.
## NFT ERC 20/721/1155 Order structure
```
{
"expiry": 1664716033,
"createdAt": 1663853026,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "6696393496368457207383969069655254624825140823245405670718046208",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0xcd494673999194365033d7a287af9f0a3b163874",
"makerAssetId": "1027",
"makerAssetType": 2,
"takerAsset": "0xad6d458402f60fd3bd25163575031acdce07538d",
"takerAssetId": "0",
"takerAssetType": 0,
"makerAmount": "1",
"fillableBalance": "1",
"takerAmount": "50",
"signature": "0x762dd1eb9447d10a24adff2c16dd2a6a4f6abdeff2e51fc1df0428129e4b7c1a00100a35f936e591956a5c86d3d502ecb591134bc8c0f32f12fd7533c199975e1c",
"orderHash": "0xe40182a75563c4c84e2ff4f2b4b44045fc94f66c929780ee82560d30cbadeb83",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
}
```
#### Difference with on-chain NFT order
* `makerAsset`: is the decoded address of the `makerAsset` from our limit order contract.
* `makerAssetId`: is the decoded token type from the `makerAsset` from our limit order contract.
* `takerAsset`: is the decoded address of the `makerAsset` from our limit order contract.
* `takerAssetId`: is the decoded token type from the `takerAsset` from our limit order contract.
* `takerFromMeta`: is the decoded taker from `nonceAndMeta`. In Augustus contract we check the actual `takerAddress` (The address who swap `takerAsset` to `makerAsset`) by extracting its value from `nonceAndMeta`.
* `fillableBalance`: is the amount that remains to be filled and can be used to check if the amount is partially filled. (`fillableBalance` ≠ `makeAmount`)
* `orderHash`: hash of the on-chain Data structure.
* permitMakerAsset: always null for now will be used to store permit.
* `type`: `P2P` / `LIMIT` differentiate `p2p` from normal orders
* `P2P`: has `takerFromMeta` set to some specific address.
* `LIMIT`: has `takerFromMeta` set to `0x....0`.
* `state`: `PENDING` / `FULFILLED` / `EXPIRED` / `CANCELLED`.
* `PENDING`: order is still usable.
* `FULFILLED`: order is fully fulfilled.
* `EXPIRED`: order is expired.
* `CANCELLED`: order is canceled.
# API References
### API Architecture
API is separated in two different endpoints:
* `/ft/` for fungible token: this endpoints is to interact with limit orders from one ERC20 to another ERC20.
* `/ft/orders/`: to interact with limit orders fillable by anybody.
* `/ft/p2p/`: to interact with p2p orders.
* `/nft/` for non fungible token: this endpoints is used to interact with limit orders from any supported token to any supported token.
* `/nft/p2p/` to interact with limit orders fillable by anybody.
* `/nft/orders/`to interact with p2p orders.
# Fungible tokens
/ft/ fungible api
{% content-ref url="/pages/qGt3Hd1HEqRAQjC8sRGt" %}
[Create a p2p limit order](/api/augustusrfq/api-references/fungible-tokens/create-a-p2p-limit-order)
{% endcontent-ref %}
{% content-ref url="/pages/OUNzlbdmoImc8tFGorM5" %}
[Get limit orders by maker](/api/augustusrfq/api-references/fungible-tokens/get-limit-orders-by-maker)
{% endcontent-ref %}
{% content-ref url="/pages/b9aUNrXEiJTsNqOd7JN4" %}
[Get limit orders by taker](/api/augustusrfq/api-references/fungible-tokens/get-limit-orders-by-taker)
{% endcontent-ref %}
{% content-ref url="/pages/vA5SQhs5BFyCeR8wMY2h" %}
[Get Pairs](/api/augustusrfq/api-references/fungible-tokens/get-pairs)
{% endcontent-ref %}
{% content-ref url="/pages/JDbbaFpC5Xf0qusbydgO" %}
[Get Orderbook](/api/augustusrfq/api-references/fungible-tokens/get-orderbook)
{% endcontent-ref %}
{% content-ref url="/pages/8b4fYlGu8jezS90LU4zb" %}
[Fill a limit order](/api/augustusrfq/api-references/fungible-tokens/fill-a-limit-order)
{% endcontent-ref %}
{% content-ref url="/pages/6mKNVlw1ciYGUqEEanhs" %}
[Cancel a limit order](/api/augustusrfq/api-references/fungible-tokens/cancel-a-limit-order)
{% endcontent-ref %}
{% content-ref url="/pages/44nzdhvpEl5n7qR7QxAB" %}
[Create a limit order](/api/augustusrfq/api-references/fungible-tokens/create-a-limit-order)
{% endcontent-ref %}
# Create a limit order
### POST /ft/orders/:chainId/
#### Examples
{% tabs %}
{% tab title="curl" %}
The data to be sent to the endpoint consists of limit order parameters and a signature of those parameters produced by order maker.\
\
Generating this data consists of these steps:\
1\. compose [order parameters](https://github.com/paraswap/paraswap-sdk/blob/b56d23fab8bd9d849fef3a037839c005e5dde9ef/src/methods/limitOrders/helpers/buildOrderData.ts#L43-L52)\
2\. [sign an object with these parameters](https://github.com/paraswap/paraswap-sdk/blob/b56d23fab8bd9d849fef3a037839c005e5dde9ef/src/methods/limitOrders/helpers/buildOrderData.ts#L37) with `eth_signTypedData`\
3\. combine order parameters with the signature.
\
The resulting data will be validated and accepted by the POST endpoint and will have the [specified shape](/api/augustusrfq/on-chain-data-structure).
```bash
curl -X POST \
'https://api.paraswap.io/ft/orders/137' \
--header 'Content-Type: application/json' \
--data-raw '{
"maker": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"expiry": 0,
"makerAsset": "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
"takerAsset": "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
"makerAmount": "10000000000000000",
"takerAmount": "7775870000000000",
"signature": "0x43de8dbc8228594171d0ed3e623ca0ab5c24f46bf0575800624ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b"
}'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import { ethers } from 'ethers';
import {
// swap methods
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
// limitOrders methods
constructBuildLimitOrder,
constructSignLimitOrder,
constructPostLimitOrder,
// extra types
SignableOrderData,
LimitOrderToSend,
} from '..';
const account = '0x1234...';
const fetcher = constructAxiosFetcher(axios);
// provider must have write access to account
// this would usually be wallet provider (Metamask)
const provider = ethers.getDefaultProvider(1);
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
account
);
// type BuildLimitOrderFunctions
// & SignLimitOrderFunctions
// & PostLimitOrderFunctions
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
contractCaller,
},
constructBuildLimitOrder,
constructSignLimitOrder,
constructPostLimitOrder
);
const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
const orderInput = {
nonce: 1,
expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
makerAsset: DAI,
takerAsset: HEX,
makerAmount: (1e18).toString(10),
takerAmount: (8e18).toString(10),
maker: account,
};
async function run() {
const signableOrderData: SignableOrderData =
await paraSwapLimitOrderSDK.buildLimitOrder(orderInput);
const signature: string = await paraSwapLimitOrderSDK.signLimitOrder(
signableOrderData
);
const orderToPostToApi: LimitOrderToSend = {
...signableOrderData.data,
signature,
};
const newOrder = await paraSwapLimitOrderSDK.postLimitOrder(orderToPostToApi);
console.log(newOrder);
}
run();
```
{% endtab %}
{% tab title="Python" %}
```python
MAKER_ASSET = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270"
TAKER_ASSET = "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063"
network = Network.Polygon
# initialize http rpc provider
provider = HTTPProvider("YOUR RPC PROVIDER")
# initialize web3
web3 = Web3(provider)
# create web3 account with pk1
account1 = web3.eth.account.from_key("your pk")
# hack to make PoA work (for example polygon)
web3.middleware_onion.inject(geth_poa_middleware, layer=0)
# create order helper object, TODO: maybe rename it to augustusRFQ helper
# orderHelper is an helper for the augustusRFQ contract
orderHelper = OrderHelper(
network,
web3,
)
# get ftApi object instance
# fungible api is a wrapper to our limit orders api
ftApi = create_fungible_api(network, api_url)
# create_managed_order is used to createa a limit order that our backend track fillability
# and also using for pricing inside paraswap protocol
order = create_managed_order(
expiry=0, # 0 means the order never expire
maker=account1.address, # account1 is the maker of the order
maker_asset=MAKER_ASSET, # account1 is selling maker_asset
taker_asset=TAKER_ASSET, # account1 is buying taker_asset
maker_amount=1000000000000, # amount of maker_asset that account1 is selling
taker_amount=845718000000, # amount of taker_asset that account1 is buying
)
# The created order needs to be sign with an account to be valid
orderWithSignature = orderHelper.sign_order(account1, order)
# send this signed order to our centralised api.
# It means that the order will be use in pricing
print("Order created")
print(res
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1)
#### Body parameters
```json
{
"maker": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"expiry": 0,
"makerAsset": "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
"takerAsset": "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
"makerAmount": "10000000000000000",
"takerAmount": "7775870000000000",
"signature": "0x43de8dbc8228594171d0ed3e623ca0ab5c24f46bf0575800624ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b"
}
```
Important notice:
* `nonceAndMeta`: needs to be encoded as described in:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"order": {
"expiry": 0,
"createdAt": 1661165141,
"updatedAt": 1661165141,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "10000000000000000",
"fillableBalance": "10000000000000000",
"swappableBalance": "10000000000000000",
"makerBalance": "10000000000000000",
"takerAmount": "7775870000000000",
"signature": "0x43dd8dbc8228594171d0ed3e633ca0eb5c24f46bf0575100623ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b",
"orderHash": "0xdef400fd95d028d8caaba2c4887d2694563e0bc7f73c17d747feac2e24ed411d",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
}
}
```
# Create a p2p limit order
You can notice the difference between p2p and normal limit orders by looking at the path.
### **POST /ft/p2p/:chainId/**
#### Examples
{% tabs %}
{% tab title="curl" %}
The process of composing the order and the payload to POST to API endpoint is pretty much the [same as with usual non-p2p orders](/api/augustusrfq/api-references/fungible-tokens/create-a-limit-order).
The only differences are:
* slightly different route (`/ft/p2p/...` instead of `/ft/orders/...` )
* taker should contain [Augustus Swapper](/augustus-swapper/smart-contracts) address
* the intended order taker is [encoded in the nonceAndMeta](/api/augustusrfq/data-structure-in-our-centralized-system) field
```bash
curl -X POST \
'https://api.paraswap.io/ft/p2p/1' \
--header 'Content-Type: application/json' \
--data-raw '{
"nonceAndMeta": "1490585846052014974250870934243084527261268076495",
"expiry": 1665493373,
"makerAsset": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
"takerAsset": "0x2b591e99afe9f32eaa6214f7b7629768c40eeb39",
"maker": "0xB4E6f1c1f9Ba3aD97e09603966b4ac773303a8d1",
"taker": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
"makerAmount": "1000000000000000000",
"takerAmount": "8000000000000000000",
"signature": "0x1647ae642db6e02c39ac80f40b73df032ca43648c2d11c44d5c7437e0c3a151739e54b7d3ea22067226b723ac84ac577a487579b04e7197bc3b13abee5d3952a1c"
}'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import { ethers } from 'ethers';
import {
// swap methods
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
// limitOrders methods
constructBuildLimitOrder,
constructSignLimitOrder,
constructPostLimitOrder,
// extra types
SignableOrderData,
LimitOrderToSend,
} from '..';
const wallet = ethers.Wallet.createRandom();
const fetcher = constructAxiosFetcher(axios);
const provider = wallet.connect(ethers.getDefaultProvider(1));
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
wallet.address
);
// type BuildLimitOrderFunctions
// & SignLimitOrderFunctions
// & PostLimitOrderFunctions
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
contractCaller,
},
constructBuildLimitOrder,
constructSignLimitOrder,
constructPostLimitOrder
);
const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
const orderInput = {
nonce: 1,
expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
makerAsset: DAI,
takerAsset: HEX,
makerAmount: (1e18).toString(10),
takerAmount: (8e18).toString(10),
maker: wallet.address,
taker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
};
async function run() {
const signableOrderData: SignableOrderData =
await paraSwapLimitOrderSDK.buildLimitOrder(orderInput);
const signature: string = await paraSwapLimitOrderSDK.signLimitOrder(
signableOrderData
);
const orderToPostToApi: LimitOrderToSend = {
...signableOrderData.data,
signature,
};
const newOrder = await paraSwapLimitOrderSDK.postP2POrder(orderToPostToApi);
console.log(newOrder);
}
run();
```
{% endtab %}
{% tab title="Python" %}
```python
MAKER_ASSET = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270"
TAKER_ASSET = "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063"
network = Network.Polygon
api_url = "https://api.paraswap.io/"
# initialize http rpc provider
provider = HTTPProvider("YOUR RPC PROVIDER")
# initialize web3
web3 = Web3(provider)
# create web3 account with pk1
account1 = web3.eth.account.from_key("your pk")
# hack to make PoA work (for example polygon)
web3.middleware_onion.inject(geth_poa_middleware, layer=0)
# create order helper object, TODO: maybe rename it to augustusRFQ helper
# orderHelper is an helper for the augustusRFQ contract
orderHelper = OrderHelper(
network,
web3,
)
# get ftApi object instance
# fungible api is a wrapper to our limit orders api
ftApi = create_fungible_api(network, api_url)
# create_managed_order is used to createa a limit order that our backend track fillability
# and also using for pricing inside paraswap protocol
order = create_managed_p2p_order(
network, # to get the correct augustus address
expiry=0, # 0 means the order never expire
maker=account1.address, # account1 is the maker of the order
maker_asset=MAKER_ASSET, # account1 is selling maker_asset
taker_asset=TAKER_ASSET, # account1 is buying taker_asset
maker_amount=1000000000000, # amount of maker_asset that account1 is selling
taker_amount=845718000000, # amount of taker_asset that account1 is buying
"actual taker address",
)
# The created order needs to be sign with an account to be valid
orderWithSignature = orderHelper.sign_order(account1, order)
# send this signed order to our centralised api.
# It means that the order will be use in pricing
print("Order created")
print(res)
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1)
#### Body parameters
```json
{
"maker": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"taker": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"expiry": 0,
"makerAsset": "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
"takerAsset": "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
"makerAmount": "10000000000000000",
"takerAmount": "7775870000000000",
"signature": "0x43de8dbc8228594171d0ed3e623ca0ab5c24f46bf0575800624ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b"
}
```
Important notice:
* `nonceAndMeta`: needs to be encoded as described in (here we are in the p2p case so we should add the address of the person you want to execute a trade in `nonceAndMeta`):
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"order": {
"expiry": 0,
"createdAt": 1661165141,
"updatedAt": 1661165141,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "10000000000000000",
"fillableBalance": "10000000000000000",
"swappableBalance": "10000000000000000",
"makerBalance": "10000000000000000",
"takerAmount": "7775870000000000",
"signature": "0x43dd8dbc8228594171d0ed3e633ca0eb5c24f46bf0575100623ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b",
"orderHash": "0xdef400fd95d028d8caaba2c4887d2694563e0bc7f73c17d747feac2e24ed411d",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
}
}
```
# Get limit orders by maker
### GET /ft/orders/:chainId/maker/:address
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/ft/orders/1/maker/0x7BA594DF3161729BF2E68A9d0A11dceB57A2e306'
```
{% endtab %}
{% tab title="Typescript" %}
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
// swap methods
constructPartialSDK,
constructAxiosFetcher,
// limitOrders methods
constructGetLimitOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
},
constructGetLimitOrders
);
async function run() {
const orders = await paraSwapLimitOrderSDK.getLimitOrders({
maker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'LIMIT',
});
console.log('orders', orders);
}
run();
{% endtab %}
{% tab title="Python" %}
```python
network = Network.Polygon
api_url = "https://api.paraswap.io/"
# get ftApi object instance
# fungible api is a wrapper to our limit orders api
ftApi = create_fungible_api(network, api_url)
ordersResponse = ftApi.get_orders_by_maker("maker address")
```
{% endtab %}
{% endtabs %}
### GET /ft/p2p/:chainId/maker/:address (for p2p)
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/ft/p2p/1/maker/0x7BA594DF3161729BF2E68A9d0A11dceB57A2e306'
```
{% endtab %}
{% tab title="Typescript" %}
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
// swap methods
constructPartialSDK,
constructAxiosFetcher,
// limitOrders methods
constructGetLimitOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
},
constructGetLimitOrders
);
async function run() {
const p2pOrders = await paraSwapLimitOrderSDK.getLimitOrders({
maker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'P2P',
});
console.log('p2pOrders', p2pOrders);
}
run();
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1).
* `address`: will return you the orders in which `maker == address`.
* `limit` (Optional): max count of orders.
* `offset` (Optional): pagination offset.
* `hideSmallBalances` (Optional, default: false): boolean if true will hide all orders in which 99.99% of the value has already been swapped.
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"limit": 2,
"offset": 0,
"orders": [
{
"expiry": 0,
"createdAt": 1661162877,
"updatedAt": 1661162877,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "10000000000000000",
"fillableBalance": "10000000000000000",
"swappableBalance": "0",
"makerBalance": "10000000000000000",
"isFillOrKill": false,
"takerAmount": "7775870000000000",
"signature": "0x43dd8dbc8228594171d0ed3e633ca0eb5c24f46bf0575100623ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b",
"orderHash": "0xdef400fd95d028d8caaba2c4887d2694563e0bc7f73c17d747feac2e24ed411d",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
},
{
"expiry": 0,
"createdAt": 1661102635,
"updatedAt": 1661162851,
"transactionHash": "0x235aaa8472de0a724ea09daee5f2ed57d4365753d521008bcd9550d83a4461c7",
"chainId": 137,
"nonceAndMeta": "5138925241883764339325856218512467102197816820790096695352360960",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "1000000",
"fillableBalance": "27806",
"swappableBalance": "27806",
"makerBalance": "27806",
"isFillOrKill": false,
"takerAmount": "999800000000000000",
"signature": "0x98e2cbd4e56290665c8301b7fd8b2590ce4d1e46fa674be601efef48f07599bf7f5cd7b1dc95653a3736bf06da0a41f251f85546ebe72491cd21a240b70ef66f1c",
"orderHash": "0xef9fdf84be98cc70c05dbfe62af88412c1231f3025d3c829cf93b29f578a66fd",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "CANCELLED"
}
]
}
```
# Get limit orders by taker
### GET /ft/orders/:chainId/taker/:address
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/ft/orders/137/taker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
constructPartialSDK,
constructAxiosFetcher,
constructGetLimitOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
},
constructGetLimitOrders
);
async function run() {
const orders = await paraSwapLimitOrderSDK.getLimitOrders({
taker: 'curl -X GET \
'https://api.paraswap.io/ft/orders/137/maker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'curl -X GET \
'https://api.paraswap.io/ft/orders/137/maker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'az',
type: 'LIMIT',
});
console.log('orders', orders);
}
run();
```
{% endtab %}
{% tab title="Python" %}
```python
network = Network.Polygon
api_url = "https://api.paraswap.io/"
# get ftApi object instance
# fungible api is a wrapper to our limit orders api
ftApi = create_fungible_api(network, api_url)
ordersResponse = ftApi.get_orders_by_taker("taker address")
```
{% endtab %}
{% endtabs %}
### GET /ft/p2p/:chainId/taker/:address (for p2p)
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/ft/p2p/137/taker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
constructPartialSDK,
constructAxiosFetcher,
constructGetLimitOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
},
constructGetLimitOrders
);
async function run() {
const p2pOrders = await paraSwapLimitOrderSDK.getLimitOrders({
taker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'P2P',
});
console.log('p2pOrders', p2pOrders);
}
run();
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1).
* address: will return you the orders in which `taker == address`.
* `limit` (Optional): max count of orders.
* `offset` (Optional): pagination offset.
* `hideSmallBalances` (Optional, default: false): boolean if true will hide all orders in which 99.99% of the value has already been swapped.
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"limit": 2,
"offset": 0,
"orders": [
{
"expiry": 0,
"createdAt": 1661162877,
"updatedAt": 1661162877,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "10000000000000000",
"fillableBalance": "10000000000000000",
"swappableBalance": "0",
"makerBalance": "10000000000000000",
"isFillOrKill": false,
"takerAmount": "7775870000000000",
"signature": "0x43dd8dbc8228594171d0ed3e633ca0eb5c24f46bf0575100623ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b",
"orderHash": "0xdef400fd95d028d8caaba2c4887d2694563e0bc7f73c17d747feac2e24ed411d",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
},
{
"expiry": 0,
"createdAt": 1661102635,
"updatedAt": 1661162851,
"transactionHash": "0x235aaa8472de0a724ea09daee5f2ed57d4365753d521008bcd9550d83a4461c7",
"chainId": 137,
"nonceAndMeta": "5138925241883764339325856218512467102197816820790096695352360960",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "1000000",
"fillableBalance": "27806",
"swappableBalance": "27806",
"makerBalance": "27806",
"isFillOrKill": false,
"takerAmount": "999800000000000000",
"signature": "0x98e2cbd4e56290665c8301b7fd8b2590ce4d1e46fa674be601efef48f07599bf7f5cd7b1dc95653a3736bf06da0a41f251f85546ebe72491cd21a240b70ef66f1c",
"orderHash": "0xef9fdf84be98cc70c05dbfe62af88412c1231f3025d3c829cf93b29f578a66fd",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "CANCELLED"
}
]
}
```
# Get Pairs
### GET /ft/orders/:chainId/pairs
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/ft/orders/137/pairs'
```
{% endtab %}
{% tab title="Python" %}
```python
network = Network.Polygon
api_url = "https://api.paraswap.io/"
# get ftApi object instance
# fungible api is a wrapper to our limit orders api
ftApi = create_fungible_api(network, api_url)
pairs = ftApi.get_orderbook_pairs()
print(pairs)
```
{% endtab %}
{% endtabs %}
#### Query parameters
* `chainId:`network id (Ethereum Mainnet = 1).
#### Response
Example:
```
GET https://api.paraswap.io/ft/orders/137/pairs
```
```json
{
"success": true,
"pairs": [
{
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063"
}
]
}
```
# Get Orderbook
### GET /ft/orders/:chainId/orderbook/
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/ft/orders/137/orderbook/?makerAsset=0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270&takerAsset=0x42d61d766b85431666b39b89c43011f24451bff6'
```
{% endtab %}
{% tab title="Python" %}
```python
MAKER_ASSET = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270"
TAKER_ASSET = "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063"
network = Network.Polygon
api_url = "https://api.paraswap.io/"
# get ftApi object instance
# fungible api is a wrapper to our limit orders api
ftApi = create_fungible_api(network, api_url)
orderbook = ftApi.get_orderbook(MAKER_ASSET, TAKER_ASSET)
print(orderbook)
```
{% endtab %}
{% endtabs %}
#### Query parameters:
`makerAsset`: address of an ERC20 token
`takerAsset`: address of an ERC20 token
#### Response
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
This is returning you all the orders which respect `makerAsset == makerAsset` and `takerAsset == takerAsset`.
```json
{
"success": true,
"orders": [
{
"expiry": 0,
"createdAt": 1663770783,
"updatedAt": 1663770840,
"transactionHash": "0xb0ec72d4b061a16e2bedad7153c6252f1d5ec21f1f88027f9cd465fa4cb19740",
"chainId": 137,
"nonceAndMeta": "1371981144015609647766132190312392568087326926048459362461024256",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x42d61d766b85431666b39b89c43011f24451bff6",
"makerAmount": "1000000000000000",
"fillableBalance": "116228613935036",
"swappableBalance": "116228613935036",
"makerBalance": "116228613935036",
"isFillOrKill": false,
"takerAmount": "25811200000000000",
"signature": "0x4738ef41c95b11ae409eb605399b747357061478ebcc6eefb92ae50976135ac41fce9d04dfaa2ba4e0fdd37ca407ca0f3dc68acad736588d3af8f885492c9f0c1b",
"orderHash": "0x9b52dd896e283acef9033f7a3079f2c656d109941f22d8be2144ae21857b30e6",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
}
]
}
```
# Fill a limit order
{% tabs %}
{% tab title="Typescript" %}
In order to fill an order, a [SwappableOrder](https://github.com/paraswap/paraswap-sdk/blob/b56d23fab8bd9d849fef3a037839c005e5dde9ef/src/methods/swap/transaction.ts#L28) data is required as an input.
It can be [retrieved from API web](/api/augustusrfq/api-references/fungible-tokens/get-limit-orders-by-maker) service or [composed by maker](/api/augustusrfq/api-references/fungible-tokens/create-a-limit-order).
**Parameters**
```typescript
const orderWithSignature: SwappableOrder {
nonceAndMeta: '1461501637330902918203684832716283019655932542976',
expiry: 1665587100,
makerAsset: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
takerAsset: '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39',
maker: '0x2bb45fa7c25071ff37a49877A02b5b3986113A3A',
taker: '0x0000000000000000000000000000000000000000',
makerAmount: '1000000000000000000',
takerAmount: '2800000000',
signature: '0x97166e35e63ecab23a0c4e7ec4ec6863193b48ddcee4f9f8291ac95a05e9545c46037cdcf01445d7a2b5dd0fdce66bc9f8b49cac75be03a3ba07dc0d467387351c'
}
```
This data can then be supplemented by additional required params and sent to ParaSwap web API to generate [Augustus Swapper route](/augustus-swapper) for the fulfilment transaction:
```typescript
const txData = await sdk.buildLimitOrderTx(
{
srcDecimals: 18,
destDecimals: 8,
userAddress: taker.address,
orders: [orderWithSignature],
})
```
The returned transaction params can be used to send a transaction.
**Example**
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import BigNumber from 'bignumber.js';
import { ethers } from 'ethers';
import {
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
constructBuildLimitOrderTx,
SwappableOrder,
} from '..';
const taker = ethers.Wallet.createRandom().connect(
ethers.getDefaultProvider(1)
);
const fetcher = constructAxiosFetcher(axios);
const provider = taker;
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
taker.address
);
const takerSDK = constructPartialSDK(
{
chainId: 1,
contractCaller,
fetcher,
},
constructBuildLimitOrderTx
);
const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
const orderWithSignature: SwappableOrder = {
nonceAndMeta: '1461501637330902918203684832716283019655932542976',
expiry: 1665584787,
makerAsset: DAI,
takerAsset: HEX,
maker: '0x5ad4346504d1DF55f22091058Ae9Db960E09a6E2',
taker: '0x0000000000000000000000000000000000000000',
makerAmount: (1e18).toString(10),
takerAmount: (28e8).toString(10), // hex has 8 decimals
signature:
'0x7a554a9fcd423a2d3110366f8e265c8001049e86f03d9b4e84276496b7713dbb1d394adc38290a7ef231f7f7cc7908f11953cebb5650709e4558271b3203a5c41c',
};
async function run() {
// build calldata for order fulfilling transaction
const txData = await takerSDK.buildLimitOrderTx(
{
srcDecimals: 18,
destDecimals: 18,
userAddress: taker.address,
orders: [orderWithSignature],
},
{ ignoreChecks: true }
);
const { gas: payloadGas, ...LOPayloadTxParams } = txData;
// compose ethers transaction out of provided params
const transaction: ethers.providers.TransactionRequest = {
...LOPayloadTxParams,
gasPrice: '0x' + new BigNumber(LOPayloadTxParams.gasPrice).toString(16),
gasLimit: '0x' + new BigNumber(payloadGas || 5000000).toString(16),
value: '0x' + new BigNumber(LOPayloadTxParams.value).toString(16),
};
// send
const takerFillsOrderTx: ethers.providers.TransactionResponse =
await taker.sendTransaction(transaction);
console.log('takerFillsOrderTx', takerFillsOrderTx);
}
run();
{% endtab %}
{% endtabs %}
# Cancel a limit order
To cancel an earlier placed order(s), a transaction [AugustusRFQ](/api/augustusrfq/contracts).[cancelOrder](https://etherscan.io/address/0xe92b586627cca7a83dc919cc7127196d70f55a06/advanced#writeContract#F3) (or [CancelOrders](https://etherscan.io/address/0xe92b586627cca7a83dc919cc7127196d70f55a06/advanced#writeContract#F4)) needs to be sent on behalf of the order's maker.
#### Transaction parameters:
`orderHash`: limit order unique id
#### Example
{% tabs %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import * as dotenv from 'dotenv';
import { ethers } from 'ethers';
import {
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
constructCancelLimitOrder,
constructGetLimitOrders,
} from '..';
dotenv.config();
const maker = new ethers.Wallet(process.env.PK).connect(ethers.getDefaultProvider(1));
const fetcher = constructAxiosFetcher(axios);
// provider must have write access to account
// this would usually be wallet provider (Metamask)
const provider = ethers.getDefaultProvider(1);
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
maker.address
);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 1,
fetcher,
contractCaller,
},
constructGetLimitOrders,
constructCancelLimitOrder
);
async function run() {
const { orders: currentOrders } = await paraSwapLimitOrderSDK.getLimitOrders({
maker: maker.address,
type: 'LIMIT',
});
if (!currentOrders[0]?.orderHash) throw new Error('No orders found');
const deleteTx: ethers.ContractTransaction =
await paraSwapLimitOrderSDK.cancelLimitOrder(currentOrders[0].orderHash);
console.log('deleteTx', deleteTx);
}
```
{% endtab %}
{% endtabs %}
# NFT
/nft/ non-fungible api
{% content-ref url="/pages/j3TglElMxBJHSVLS9w5G" %}
[Create an order](/api/augustusrfq/api-references/nft/create-an-order)
{% endcontent-ref %}
{% content-ref url="/pages/0mHY4ScDKmpENoyQ7Lsf" %}
[Create a p2p order](/api/augustusrfq/api-references/nft/create-a-p2p-order)
{% endcontent-ref %}
{% content-ref url="/pages/PqGaSjrP4MdTO50WXHm8" %}
[Get NFT orders by maker](/api/augustusrfq/api-references/nft/get-nft-orders-by-maker)
{% endcontent-ref %}
{% content-ref url="/pages/QdrwoWOnQU7iLpTgDA1I" %}
[Get NFT orders by taker](/api/augustusrfq/api-references/nft/get-nft-orders-by-taker)
{% endcontent-ref %}
{% content-ref url="/pages/XvvYHSEb9u6daKgmImOH" %}
[Get Pairs](/api/augustusrfq/api-references/nft/get-pairs)
{% endcontent-ref %}
{% content-ref url="/pages/HdDuLymgg7sWNQosudkp" %}
[Get orderbook](/api/augustusrfq/api-references/nft/get-orderbook)
{% endcontent-ref %}
{% content-ref url="/pages/mlftg70Ah1bNcwwUYtDa" %}
[Fill a limit order](/api/augustusrfq/api-references/nft/fill-a-limit-order)
{% endcontent-ref %}
{% content-ref url="/pages/7MDF1QfwrzxARXuswmfS" %}
[Cancel a limit order](/api/augustusrfq/api-references/nft/cancel-a-limit-order)
{% endcontent-ref %}
# Create an order
### **POST /nft/orders/:chainId/**
#### **Examples**
{% tabs %}
{% tab title="curl" %}
The process of composing an NFT order and the payload to POST to API endpoint is pretty much the [same as with usual "fungible to fungible token" orders](/api/augustusrfq/api-references/fungible-tokens/create-a-limit-order).
The only differences are:
* slightly different endpoint route (`/nft/orders/...` instead of `/ft/orders/...` )
* `makerAssetType` and `takerAssetType` fields are required
* `makerAsset` and `takerAsset` contain not plain token addresses, but token address and token type encoded as described in [#body-parameters](#body-parameters "mention")
* `takerAssetId` and `makerAssetId` will contain NFT `tokenId` . If it's "NFT to fungible" order, `takerAssetId` = 0 and `makerAssetId` = tokenID. If it's "fungible to NFT", then the opposite.
```bash
curl -X POST \
'https://api.paraswap.io/nft/orders/137' \
--header 'Content-Type: application/json' \
--data-raw '{
"nonceAndMeta": "6696393496368457207383969069655254624825140823245405670718046208",
"expiry": 1664716033,
"makerAsset": "4094980474276800865989028098863468306593436022900",
"makerAssetId": "1027",
"takerAsset": "990092240248101882666250324982272499898038834061",
"takerAssetId": "0",
"maker": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"makerAmount": "1",
"takerAmount": "50",
"signature": "0x762dd1eb9447d10a24adff2c16dd2a6a4f6abdeff2e51fc1df0428129e4b7c1a00100a35f936e591956a5c86d3d502ecb591134bc8c0f32f12fd7533c199975e1c"
}'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import * as dotenv from 'dotenv';
import axios from 'axios';
import { ethers } from 'ethers';
import {
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
constructBuildNFTOrder,
constructSignNFTOrder,
constructPostNFTOrder,
BuildNFTOrderInput,
SignableNFTOrderData,
NFTOrderToSend,
AssetType,
} from '..';
dotenv.config();
const randomPK = ethers.Wallet.createRandom().privateKey;
const wallet = new ethers.Wallet(process.env.PK || randomPK);
const fetcher = constructAxiosFetcher(axios);
const provider = wallet.connect(ethers.getDefaultProvider(137));
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
wallet.address
);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
contractCaller,
},
constructBuildNFTOrder,
constructSignNFTOrder,
constructPostNFTOrder
);
const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const NFT = '0x2953399124f0cbb46d2cbacd8a89cf0599974963';
const NFT_ID =
'7772759950848685723459796247330971791008072228632493699501910275462086524929';
const orderInput: BuildNFTOrderInput = {
nonce: 1,
expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
makerAsset: NFT,
makerAssetType: AssetType.ERC1155,
makerAssetId: NFT_ID,
takerAssetType: AssetType.ERC20,
takerAsset: DAI,
makerAmount: (1).toString(10),
takerAmount: (8e18).toString(10),
maker: wallet.address,
};
async function run() {
const signableOrderData: SignableNFTOrderData =
await paraSwapLimitOrderSDK.buildNFTOrder(orderInput);
const signature: string = await paraSwapLimitOrderSDK.signNFTOrder(
signableOrderData
);
const orderToPostToApi: NFTOrderToSend = {
...signableOrderData.data,
signature,
};
const newOrder = await paraSwapLimitOrderSDK.postNFTLimitOrder(
orderToPostToApi
);
console.log(newOrder);
}
run();
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1)
#### Body parameters
```json
{
"nonceAndMeta": "6696393496368457207383969069655254624825140823245405670718046208",
"expiry": 1664716033,
"makerAsset": "4094980474276800865989028098863468306593436022900",
"makerAssetId": "1027",
"takerAsset": "990092240248101882666250324982272499898038834061",
"takerAssetId": "0",
"maker": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"makerAmount": "1",
"takerAmount": "50",
"signature": "0x762dd1eb9447d10a24adff2c16dd2a6a4f6abdeff2e51fc1df0428129e4b7c1a00100a35f936e591956a5c86d3d502ecb591134bc8c0f32f12fd7533c199975e1c"
}
```
* `nonceAndMeta`: needs to be encoded as described in:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
* `makerAsset` and `takerAsset` needs to be encode as packed field containing address of an ERC20/721/1155 token that maker want to sell to the taker (between `0-19 bits`). Token type encoded as show above on `20-21 bits`.
Example encoding in JavaScript:
```javascript
const ERC20 = 0;
const ERC721 = 2;
const ERC1155 = 1;
const encodeAddress = (address, assetType) => BigInt(address) | (BigInt(assetType) << BigInt(160));
encodedAddress = encodeAddress('0xcd494673999194365033d7a287af9f0a3b163874', ERC721);
```
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"order": {
"expiry": 1664716033,
"createdAt": 1663852073,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "6696393496368457207383969069655254624825140823245405670718046208",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0x0000000000000000000000000000000000000000",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0xcd494673999194365033d7a287af9f0a3b163874",
"makerAssetId": "1027",
"makerAssetType": 2,
"takerAsset": "0xad6d458402f60fd3bd25163575031acdce07538d",
"takerAssetId": "0",
"takerAssetType": 0,
"makerAmount": "1",
"fillableBalance": "1",
"takerAmount": "50",
"signature": "0x762dd1eb9447d10a24adff2c16dd2a6a4f6abdeff2e51fc1df0428129e4b7c1a00100a35f936e591956a5c86d3d502ecb591134bc8c0f32f12fd7533c199975e1c",
"orderHash": "0xe40182a75563c4c84e2ff4f2b4b44045fc94f66c929780ee82560d30cbadeb83",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
}
}
```
# Create a p2p order
You can notice the difference between p2p and normal limit orders by looking at the path.
### **POST /nft/p2p/:chainId/**
#### **Examples**
{% tabs %}
{% tab title="curl" %}
The process of composing the order and the payload to POST to API endpoint is pretty much the [same as with usual non-p2p orders](/api/augustusrfq/api-references/nft/create-an-order).
The only differences are:
* slightly different route (`/nft/p2p/...` instead of `/nft/orders/...` )
* taker should contain [Augustus Swapper](/augustus-swapper/smart-contracts) address
* the intended order taker is [encoded in the nonceAndMeta](/api/augustusrfq/data-structure-in-our-centralized-system) field\`\`\`\`
```bash
curl -X POST \
'https://api.paraswap.io/nft/p2p/137' \
--header 'Content-Type: application/json' \
--data-raw '{
"nonceAndMeta": "1490585846052014974250870934243084527261268076495",
"expiry": 1665643036,
"makerAsset": "1697426235576502185006439320944601702126017005923",
"takerAsset": "611382286831621467233887798921843936019654057231",
"maker": "0x7BA594DF3161729BF2E68A9d0A11dceB57A2e306",
"taker": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
"makerAmount": "1",
"takerAmount": "8000000000000000000",
"makerAssetId": "7772759950848685723459796247330971791008072228632493699501910275462086524929",
"takerAssetId": "0",
"signature": "0x292e484328f98ea5e59b0d57b8d0fc41ac67fc275146f43c0d005c1422d639014bd69dcd447eb583315dc578f7b087f0ad60711237b9fc4b518f22a0d09fc9341c"
}'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import * as dotenv from 'dotenv';
import axios from 'axios';
import { ethers } from 'ethers';
import {
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
constructBuildNFTOrder,
constructSignNFTOrder,
constructPostNFTOrder,
BuildNFTOrderInput,
SignableNFTOrderData,
NFTOrderToSend,
AssetType,
} from '..';
dotenv.config();
const randomPK = ethers.Wallet.createRandom().privateKey;
const wallet = new ethers.Wallet(process.env.PK || randomPK);
const fetcher = constructAxiosFetcher(axios);
const provider = wallet.connect(ethers.getDefaultProvider(137));
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
wallet.address
);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
contractCaller,
},
constructBuildNFTOrder,
constructSignNFTOrder,
constructPostNFTOrder
);
const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const NFT = '0x2953399124f0cbb46d2cbacd8a89cf0599974963';
const NFT_ID =
'7772759950848685723459796247330971791008072228632493699501910275462086524929';
const orderInput: BuildNFTOrderInput = {
nonce: 1,
expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
makerAsset: NFT,
makerAssetType: AssetType.ERC1155,
makerAssetId: NFT_ID,
takerAssetType: AssetType.ERC20,
takerAsset: DAI,
makerAmount: (1).toString(10),
takerAmount: (8e18).toString(10),
maker: wallet.address,
taker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
};
async function run() {
const signableOrderData: SignableNFTOrderData =
await paraSwapLimitOrderSDK.buildNFTOrder(orderInput);
const signature: string = await paraSwapLimitOrderSDK.signNFTOrder(
signableOrderData
);
const orderToPostToApi: NFTOrderToSend = {
...signableOrderData.data,
signature,
};
const newOrder = await paraSwapLimitOrderSDK.postNFTP2POrder(
orderToPostToApi
);
console.log(newOrder);
}
run();
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1)
#### Body parameters
```json
{
"nonceAndMeta": "6696393496368457207383969069655254624825140823245405670718046208",
"expiry": 1664716033,
"makerAsset": "4094980474276800865989028098863468306593436022900",
"makerAssetId": "1027",
"takerAsset": "990092240248101882666250324982272499898038834061",
"takerAssetId": "0",
"maker": "0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf",
"taker": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
"makerAmount": "1",
"takerAmount": "50",
"signature": "0x762dd1eb9447d10a24adff2c16dd2a6a4f6abdeff2e51fc1df0428129e4b7c1a00100a35f936e591956a5c86d3d502ecb591134bc8c0f32f12fd7533c199975e1c"
}
```
* `nonceAndMeta`: needs to include the actual taker as described here:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
* `makerAsset` and `takerAsset` needs to be encode as packed field containing address of an ERC20/721/1155 token that maker want to sell to the taker (between `0-19 bits`). Token type encoded as show above on `20-21 bits`.
Example encoding in JavaScript:
```javascript
const ERC20 = 0;
const ERC721 = 2;
const ERC1155 = 1;
const encodeAddress = (address, assetType) => BigInt(address) | (BigInt(assetType) << BigInt(160));
encodedAddress = encodeAddress('0xcd494673999194365033d7a287af9f0a3b163874', ERC721);
```
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"order": {
"expiry": 1664717831,
"createdAt": 1663853865,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "5849534550391847890058685755479665482115680361250527628888286063",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x6dac5cac7bbcce4db3c1cc5c8fe39dcdde52a36f",
"makerAsset": "0xcd494673999194365033d7a287af9f0a3b163874",
"makerAssetId": "1027",
"makerAssetType": 2,
"takerAsset": "0xad6d458402f60fd3bd25163575031acdce07538d",
"takerAssetId": "0",
"takerAssetType": 0,
"makerAmount": "1",
"fillableBalance": "1",
"takerAmount": "50",
"signature": "0xdb265004d19c79b2284ae327c586725c7f3535eeb1693d166a727d62efd521304874b658d106ca552f09352effa34be72826e2abdf6c6b09591318199eeb16081b",
"orderHash": "0x33c5ca652106ef8340673b01e2ab8a713837bf42c2b3bef67143b65f9b89934c",
"permitMakerAsset": null,
"type": "P2P",
"state": "PENDING"
}
}
```
# Get NFT orders by maker
### GET /nft/orders/:chainId/maker/:address
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/orders/137/maker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
constructPartialSDK,
constructAxiosFetcher,
constructGetNFTOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
},
constructGetNFTOrders
);
async function run() {
const orders = await paraSwapLimitOrderSDK.getNFTOrders({
maker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'LIMIT',
});
console.log('limit orders', orders);
}
run();
```
{% endtab %}
{% endtabs %}
### GET /nft/p2p/:chainId/maker/:address (for p2p)
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/p2p/137/maker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'
```
{% endtab %}
{% tab title="Second Tab" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
constructPartialSDK,
constructAxiosFetcher,
constructGetNFTOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
},
constructGetNFTOrders
);
async function run() {
const p2pOrders = await paraSwapLimitOrderSDK.getNFTOrders({
maker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'P2P',
});
console.log('p2pOrders', p2pOrders);
}
run();
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1).
* `address`: will return you the orders in which `maker == address`.
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"orders": [
{
"expiry": 1664717831,
"createdAt": 1663853865,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "5849534550391847890058685755479665482115680361250527628888286063",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x6dac5cac7bbcce4db3c1cc5c8fe39dcdde52a36f",
"makerAsset": "0xcd494673999194365033d7a287af9f0a3b163874",
"makerAssetId": "1027",
"makerAssetType": 2,
"takerAsset": "0xad6d458402f60fd3bd25163575031acdce07538d",
"takerAssetId": "0",
"takerAssetType": 0,
"makerAmount": "1",
"fillableBalance": "1",
"takerAmount": "50",
"signature": "0xdb265004d19c79b2284ae327c586725c7f3535eeb1693d166a727d62efd521304874b658d106ca552f09352effa34be72826e2abdf6c6b09591318199eeb16081b",
"orderHash": "0x33c5ca652106ef8340673b01e2ab8a713837bf42c2b3bef67143b65f9b89934c",
"permitMakerAsset": null,
"type": "P2P",
"state": "PENDING"
}
]
}
```
# Get NFT orders by taker
### GET /ft/orders/:chainId/taker/:address
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/orders/137/taker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
constructPartialSDK,
constructAxiosFetcher,
constructGetNFTOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
},
constructGetNFTOrders
);
async function run() {
const orders = await paraSwapLimitOrderSDK.getNFTOrders({
taker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'LIMIT',
});
console.log('orders', orders);
}
run();
```
{% endtab %}
{% endtabs %}
### GET /ft/p2p/:chainId/taker/:address (for p2p)
#### Examples
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/p2p/137/taker/0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf'
```
{% endtab %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import axios from 'axios';
import {
constructPartialSDK,
constructAxiosFetcher,
constructGetNFTOrders,
} from '..';
const fetcher = constructAxiosFetcher(axios);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
},
constructGetNFTOrders
);
async function run() {
const orders = await paraSwapLimitOrderSDK.getNFTOrders({
taker: '0x05182E579FDfCf69E4390c3411D8FeA1fb6467cf',
type: 'P2P',
});
console.log('orders', orders);
}
run();
```
{% endtab %}
{% endtabs %}
#### Query parameters:
* `chainId:`network id (Ethereum Mainnet = 1).
* address: will return you the orders in which `taker == address`.
#### Response
Understand the response by checking our dedicated page:
{% content-ref url="/pages/7EU4hKrvjbDV4PuKGPpS" %}
[Data structure in our centralized system](/api/augustusrfq/data-structure-in-our-centralized-system)
{% endcontent-ref %}
```json
{
"orders": [
{
"expiry": 1664717831,
"createdAt": 1663853865,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "5849534550391847890058685755479665482115680361250527628888286063",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x6dac5cac7bbcce4db3c1cc5c8fe39dcdde52a36f",
"makerAsset": "0xcd494673999194365033d7a287af9f0a3b163874",
"makerAssetId": "1027",
"makerAssetType": 2,
"takerAsset": "0xad6d458402f60fd3bd25163575031acdce07538d",
"takerAssetId": "0",
"takerAssetType": 0,
"makerAmount": "1",
"fillableBalance": "1",
"takerAmount": "50",
"signature": "0xdb265004d19c79b2284ae327c586725c7f3535eeb1693d166a727d62efd521304874b658d106ca552f09352effa34be72826e2abdf6c6b09591318199eeb16081b",
"orderHash": "0x33c5ca652106ef8340673b01e2ab8a713837bf42c2b3bef67143b65f9b89934c",
"permitMakerAsset": null,
"type": "P2P",
"state": "PENDING"
}
]
}{
"limit": 2,
"offset": 0,
"orders": [
{
"expiry": 0,
"createdAt": 1661162877,
"updatedAt": 1661162877,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "7433034152904838547212883274543254857465784035140417181410394112",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "10000000000000000",
"fillableBalance": "10000000000000000",
"swappableBalance": "0",
"makerBalance": "10000000000000000",
"isFillOrKill": false,
"takerAmount": "7775870000000000",
"signature": "0x43dd8dbc8228594171d0ed3e633ca0eb5c24f46bf0575100623ae56723712f807ecaf7dc8edfcf0d4517f80f11bf016bde0a9a20e243eea2bb32e55eadbb6b0d1b",
"orderHash": "0xdef400fd95d028d8caaba2c4887d2694563e0bc7f73c17d747feac2e24ed411d",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "PENDING"
},
{
"expiry": 0,
"createdAt": 1661102635,
"updatedAt": 1661162851,
"transactionHash": "0x235aaa8472de0a724ea09daee5f2ed57d4365753d521008bcd9550d83a4461c7",
"chainId": 137,
"nonceAndMeta": "5138925241883764339325856218512467102197816820790096695352360960",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x0000000000000000000000000000000000000000",
"makerAsset": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
"takerAsset": "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063",
"makerAmount": "1000000",
"fillableBalance": "27806",
"swappableBalance": "27806",
"makerBalance": "27806",
"isFillOrKill": false,
"takerAmount": "999800000000000000",
"signature": "0x98e2cbd4e56290665c8301b7fd8b2590ce4d1e46fa674be601efef48f07599bf7f5cd7b1dc95653a3736bf06da0a41f251f85546ebe72491cd21a240b70ef66f1c",
"orderHash": "0xef9fdf84be98cc70c05dbfe62af88412c1231f3025d3c829cf93b29f578a66fd",
"permitMakerAsset": null,
"type": "LIMIT",
"state": "CANCELLED"
}
]
}
```
# Get Pairs
### GET /nft/orders/:chainId/pairs
#### Example
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/orders/137/pairs'
```
{% endtab %}
{% endtabs %}
#### Response
```
{
"success": true,
"pairs": [
{
"makerAsset": {
"type": 2,
"address": "0xcd494673999194365033d7a287af9f0a3b163874"
},
"takerAsset": {
"type": 0,
"address": "0xad6d458402f60fd3bd25163575031acdce07538d"
}
}
]
}
```
# Get orderbook
### GET /nft/orders/:chainId/orderbook/
#### Query parameters:
`makerAsset (optional)`: address of an ERC20/721/1155 token
`makerAssetType (optional)`: encoded token type ERC20/721/1155 (0: ERC20, 1: ERC1155, 2: ERC721)
`takerAsset (optional)`: address of an ERC20/721/1155 token
`takerAssetType (optional)`: encoded token type ERC20/721/1155 (0: ERC20, 1: ERC1155, 2: ERC721)
#### Example:
* Get the whole orderbook
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/orders/137/orderbook/'
```
{% endtab %}
{% endtabs %}
* Get orderbook where `makerAsset` equal `0x2953399124f0cbb46d2cbacd8a89cf0599974963`
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/orders/137/orderbook/?makerAsset=0x2953399124f0cbb46d2cbacd8a89cf0599974963'
```
{% endtab %}
{% endtabs %}
* Get orderbook where `makerAsset` type is `ERC1155` and `takerAsset` is `ERC20`:
{% tabs %}
{% tab title="curl" %}
```bash
curl -X GET \
'https://api.paraswap.io/nft/orders/137/orderbook/?makerAssetType=1&takerAssetType=0'
```
{% endtab %}
{% endtabs %}
#### Response
```json
{
"success": true,
"orders": [
{
"expiry": 1664717831,
"createdAt": 1663853865,
"transactionHash": null,
"chainId": 137,
"nonceAndMeta": "5849534550391847890058685755479665482115680361250527628888286063",
"maker": "0x05182e579fdfcf69e4390c3411d8fea1fb6467cf",
"taker": "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
"takerFromMeta": "0x6dac5cac7bbcce4db3c1cc5c8fe39dcdde52a36f",
"makerAsset": "0xcd494673999194365033d7a287af9f0a3b163874",
"makerAssetId": "1027",
"makerAssetType": 2,
"takerAsset": "0xad6d458402f60fd3bd25163575031acdce07538d",
"takerAssetId": "0",
"takerAssetType": 0,
"makerAmount": "1",
"fillableBalance": "1",
"takerAmount": "50",
"signature": "0xdb265004d19c79b2284ae327c586725c7f3535eeb1693d166a727d62efd521304874b658d106ca552f09352effa34be72826e2abdf6c6b09591318199eeb16081b",
"orderHash": "0x33c5ca652106ef8340673b01e2ab8a713837bf42c2b3bef67143b65f9b89934c",
"permitMakerAsset": null,
"type": "P2P",
"state": "PENDING"
}
]
}
```
# Fill a limit order
{% tabs %}
{% tab title="Typescript" %}
In order to fill an order, a [SwappableNFTOrder](https://github.com/paraswap/paraswap-sdk/blob/b56d23fab8bd9d849fef3a037839c005e5dde9ef/src/methods/swap/transaction.ts#L33-L38) data is required as an input.
It can be [retrieved from API](/api/augustusrfq/api-references/nft/get-nft-orders-by-maker) web service or [composed by maker](/api/augustusrfq/api-references/nft/create-an-order).
**Parameters**
```typescript
const orderWithSignature: SwappableNFTOrder = {
expiry: 1665645962,
nonceAndMeta: '1490585846052014974250870934243084527261268076495',
maker: '0x7ba594df3161729bf2e68a9d0a11dceb57a2e306',
taker: '0xdef171fe48cf0115b1d80b88dc8eab59176fee57',
makerAsset: '0x2953399124f0cbb46d2cbacd8a89cf0599974963',
makerAssetId:
'7772759950848685723459796247330971791008072228632493699501910275462086524929',
makerAssetType: 1,
takerAsset: '0x6b175474e89094c44da98b954eedeac495271d0f',
takerAssetId: '0',
takerAssetType: 0,
makerAmount: '1',
takerAmount: '8000000000000000000',
signature:
'0x9247734939b4354ce6f99178ad95cbc19635e2ba86395370e29a8ac6a95cf5054203df0ba607717af1541a30d9df00962f16ada5273ef39633f304cc88faac0d1c',
};
```
This data can then be supplemented by additional required params and sent to ParaSwap web API to generate [Augustus Swapper route](/augustus-swapper) for the fulfilment transaction:
```typescript
const txData = await sdk.buildLimitOrderTx(
{
srcDecimals: 18,
userAddress: taker.address,
orders: [orderWithSignature],
})
```
The returned transaction params can be used to send a transaction.
**Example**
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import * as dotenv from 'dotenv';
import axios from 'axios';
import { ethers } from 'ethers';
import BigNumber from 'bignumber.js';
import {
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
constructBuildNFTOrderTx,
SwappableNFTOrder,
} from '..';
dotenv.config();
const pk = ethers.Wallet.createRandom().privateKey;
const taker = new ethers.Wallet(process.env.PK || pk).connect(
ethers.getDefaultProvider(137)
);
const fetcher = constructAxiosFetcher(axios);
// provider must have write access to account
// this would usually be wallet provider (Metamask)
const provider = taker;
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
taker.address
);
const takerSDK = constructPartialSDK(
{
chainId: 137,
contractCaller,
fetcher,
},
constructBuildNFTOrderTx
);
const orderWithSignature: SwappableNFTOrder = {
expiry: 1665645962,
nonceAndMeta: '1490585846052014974250870934243084527261268076495',
maker: '0x7ba594df3161729bf2e68a9d0a11dceb57a2e306',
taker: '0xdef171fe48cf0115b1d80b88dc8eab59176fee57',
makerAsset: '0x2953399124f0cbb46d2cbacd8a89cf0599974963',
makerAssetId:
'7772759950848685723459796247330971791008072228632493699501910275462086524929',
makerAssetType: 1,
takerAsset: '0x6b175474e89094c44da98b954eedeac495271d0f',
takerAssetId: '0',
takerAssetType: 0,
makerAmount: '1',
takerAmount: '8000000000000000000',
signature:
'0x9247734939b4354ce6f99178ad95cbc19635e2ba86395370e29a8ac6a95cf5054203df0ba607717af1541a30d9df00962f16ada5273ef39633f304cc88faac0d1c',
};
async function run() {
// build calldata for order fulfilling transaction
const txData = await takerSDK.buildNFTOrderTx(
{
srcDecimals: 18,
userAddress: taker.address,
orders: [orderWithSignature],
},
{ ignoreChecks: true }
);
const { gas: payloadGas, ...LOPayloadTxParams } = txData;
// compose ethers transaction out of provided params
const transaction: ethers.providers.TransactionRequest = {
...LOPayloadTxParams,
gasPrice: '0x' + new BigNumber(LOPayloadTxParams.gasPrice).toString(16),
gasLimit: '0x' + new BigNumber(payloadGas || 5000000).toString(16),
value: '0x' + new BigNumber(LOPayloadTxParams.value).toString(16),
};
// send
const takerFillsNFTOrderTx: ethers.providers.TransactionResponse =
await taker.sendTransaction(transaction);
console.log('takerFillsNFTOrderTx', takerFillsNFTOrderTx);
}
run();
```
{% endtab %}
{% endtabs %}
# Cancel a limit order
The cancellation of an NFT order works in the same way as the [cancelation of "fungible tokens" order](/api/augustusrfq/api-references/fungible-tokens/cancel-a-limit-order)
#### Transaction parameters:
`orderHash`: limit order unique id
#### Example
{% tabs %}
{% tab title="Typescript" %}
```typescript
/* eslint-disable @typescript-eslint/no-unused-vars */
import * as dotenv from 'dotenv';
import axios from 'axios';
import { ethers } from 'ethers';
import {
constructPartialSDK,
constructEthersContractCaller,
constructAxiosFetcher,
constructCancelLimitOrder,
constructGetLimitOrders,
} from '..';
dotenv.config();
const maker = new ethers.Wallet(process.env.PK).connect(
ethers.getDefaultProvider(137)
);
const fetcher = constructAxiosFetcher(axios);
// provider must have write access to account
// this would usually be wallet provider (Metamask)
const provider = maker;
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: provider,
EthersContract: ethers.Contract,
},
maker.address
);
const paraSwapLimitOrderSDK = constructPartialSDK(
{
chainId: 137,
fetcher,
contractCaller,
},
constructGetLimitOrders,
constructCancelLimitOrder
);
async function run() {
const deleteTx: ethers.ContractTransaction =
await paraSwapLimitOrderSDK.cancelLimitOrder(
'0x045cf1a02e39cc59d2027d3cb9ea6d832d6e0f2904cc1f1afab39061eb589d05'
);
console.log('deleteTx', deleteTx);
}
run();
s
```
{% endtab %}
{% endtabs %}
# SDK
{% content-ref url="/pages/oczsViCJv3UEKrAZuAgQ" %}
[Typescript](/api/augustusrfq/sdk/typescript)
{% endcontent-ref %}
{% content-ref url="/pages/hU258DEEGhRHTuXMfvsc" %}
[Python](/api/augustusrfq/sdk/python)
{% endcontent-ref %}
# Typescript
[](https://paraswap.io)
## SDK for the ParaSwap API
Refer to the documentation of the ParaSwap API:
### Features
**Versatility**: works with both [web3](https://www.npmjs.com/package/web3) and [ethers](https://www.npmjs.com/package/ethers) without direct dependency
**Canonical**: bring only the functions you actually need
**Lightweight**: 400B Gzipped for the minimal variant
### Installing ParaSwap SDK
```bash
yarn add @paraswap/sdk
```
### Using ParaSwap SDK
There are multiple ways to use ParaSwap SDK, ranging from a simple construct-and-use approach to a fully composable *bring what you need* approach which allows for advanced tree-shaking and minimizes bundle size.
#### Simple SDK
Can be created by providing `chainId` and either `axios` or `window.fetch` (or alternative `fetch` implementation). The resulting SDK will be able to use all methods that query the API.
```ts
import { constructSimpleSDK } from '@paraswap/sdk';
import axios from 'axios';
// construct minimal SDK with fetcher only
const paraSwapMin = constructSimpleSDK({chainId: 1, axios});
// or
const paraSwapMin = constructSimpleSDK({chainId: 1, fetch: window.fetch});
const ETH = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
async function swapExample() {
// or any other signer/provider
const signer: JsonRpcSigner = ethers.Wallet.fromMnmemonic('__your_mnemonic__');
const senderAddress = signer.address;
const priceRoute = await paraSwapMin.swap.getRate({
srcToken: ETH,
destToken: DAI,
amount: srcAmount,
userAddress: senderAddress,
side: SwapSide.SELL,
});
const txParams = await paraSwapMin.swap.buildTx(
{
srcToken,
destToken,
srcAmount,
destAmount,
priceRoute,
userAddress: senderAddress,
partner: referrer,
}
);
const transaction = {
...txParams,
gasPrice: '0x' + new BigNumber(txParams.gasPrice).toString(16),
gasLimit: '0x' + new BigNumber(5000000).toString(16),
value: '0x' + new BigNumber(txParams.value).toString(16),
};
const txr = await signer.sendTransaction(transaction);
}
async function approveTokenYourselfExample() {
const TransferProxy = await paraSwapMin.swap.getSpender();
const DAI_CONTRACT = new ethers.Contract(DAI, ERC20_ABI, ethersSignerOrProvider);
const tx = await DAI_CONTRACT.approve(TransferProxy, amountInWei);
const txReceipt = await tx.wait(1);
}
```
If optional `providerOptions` is provided as the second parameter, then the resulting SDK will also be able to approve Tokens for swap.
```ts
//
// with ethers.js
const providerOptionsEther = {
ethersProviderOrSigner: provider, // JsonRpcProvider
EthersContract: ethers.Contract,
account: senderAddress,
};
// or with web3.js
const providerOptionsWeb3 = {
web3, // new Web3(...) instance
account: senderAddress,
};
const paraSwap = constructSimpleSDK({chainId: 1, axios}, providerOptionsEther);
async function approveTokenExample() {
const txHash = await paraSwap.approveToken(amountInWei, DAI);
// await tx somehow
await provider.waitForTransaction(txHash);
}
```
#### Composed SDK
Import the necessary functions
```typescript
import { constructSDK, constructAxiosFetcher, constructEthersContractCaller } from '@paraswap/sdk';
```
#### Construct the ParaSwap object
```typescript
const signer = ethers.Wallet.fromMnmemonic('__your_mnemonic__'); // or any other signer/provider
const account = '__signer_address__';
const contractCaller = constructEthersContractCaller({
ethersProviderOrSigner: signer,
EthersContract: ethers.Contract,
}, account); // alternatively constructWeb3ContractCaller
const fetcher = constructAxiosFetcher(axios); // alternatively constructFetchFetcher
const paraswap = constructSDK({
chainId: 1,
fetcher,
contractCaller,
});
```
#### To approve ParaSwap contracts to swap an ERC20 token
```typescript
// if created with constructEthersContractCaller
const contractTx: ContractTransaction = await paraSwap.approveToken(amount, tokenAddress);
const txReceipt = await contractTx.wait();
// if created with constructWeb3ContractCaller
const unpromiEvent: Web3UnpromiEvent = await paraSwap.approveToken(amount, tokenAddress);
const txReceipt = await new Promise((resolve, reject) => {
unpromiEvent.once('receipt', resolve);
unpromiEvent.once('error', reject);
})
```
#### To get the rate of a token pair
```typescript
const srcToken = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'; // ETH
const destToken = '0xcAfE001067cDEF266AfB7Eb5A286dCFD277f3dE5'; // PSP
const srcAmount = '1000000000000000000'; //The source amount multiplied by its decimals: 10 ** 18 here
const srcDecimals = 18;
const destDecimals = 18;
const priceRoute = await paraSwap.getRate(
{
srcToken,
destToken,
amount,
srcDecimals,
destDecimals,
}
);
```
Where priceRoute contains the rate and the distribution among exchanges, checkout the OptimalRates type for more details.
#### To build a transaction
```typescript
const srcToken = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
const srcDecimals = 18;
const srcAmount = '1000000000000000000'; // The source amount multiplied by its decimals
const destToken = '0xcAfE001067cDEF266AfB7Eb5A286dCFD277f3dE5';
const destDecimals = 18;
const destAmount = priceRoute.destAmount; // price route being output of paraSwap.getRate()
const senderAddress = '__sender_address__'; // mandatory
const receiver = '__receiver_address__'; // optional: for swap and transfer
const partnerAddress = '__fee_receiver_address__'; // optional: for permission-less monetization
const partnerFeeBps = 50; // optional: fee in base point, for permission-less monetization
const txParams = await paraSwap.buildTx(
{
srcAmount,
srcToken,
srcDecimals,
destAmount,
destToken,
destDecimals,
priceRoute,
senderAddress,
receiver,
partnerAddress,
partnerFeeBps,
}
);
const transactionResponse = await signer.sendTransaction(txParams);
const transactionReceipt = await transactionResponse.wait();
```
#### To sign a Limit Order
```typescript
import {
constructAxiosFetcher,
constructBuildLimitOrder,
constructEthersContractCaller,
constructPartialSDK,
constructSignLimitOrder,
constructSimpleSDK
} from '@paraswap/sdk'
import axios from 'axios'
import { ethers } from 'ethers'
const signer = ethers.Wallet.fromMnemonic('__your_mnemonic__') // or any other signer/provider
const account = signer.address
const fetcher = constructAxiosFetcher(axios)
const contractCaller = constructEthersContractCaller(
{
ethersProviderOrSigner: signer,
EthersContract: ethers.Contract
},
account
)
const paraSwapLimitOrderSDK = constructPartialSDK(
{ chainId: 1, fetcher, contractCaller },
constructBuildLimitOrder,
constructSignLimitOrder
)
const order = {
maker: account,
/** actual user taker which will go into nonceAndMeta */
taker: '0x6b175474e89094c44da98b954eedeac495271d0f',
expiry: 0,
makerAsset: '0xcafe001067cdef266afb7eb5a286dcfd277f3de5',
takerAsset: '0xcafe001067cdef266afb7eb5a286dcfd277f3de5',
makerAmount: '1000000000000',
takerAmount: '1000000000000',
/** (optional) contract executor (Augustus or similar) that is allowed to execute the order as Order.taker */
contractTaker: '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599'
}
const signableOrderData = await paraSwapLimitOrderSDK.buildLimitOrder(order)
const signature = await paraSwapLimitOrderSDK.signLimitOrder(signableOrderData
```
### Playground
Interact with the ParaSwap SDK in a CodeSandbox playground [here](https://codesandbox.io/s/gallant-flower-7yuker)
### Bundle Optimization
For bundle-size savvy developers, you can construct a lightweight version of the SDK and bring only the functions you need.
e.g. for only getting rates and allowances:
```typescript
import { constructPartialSDK, constructFetchFetcher, constructGetRate, constructGetBalances } from '@paraswap/sdk';
const fetcher = constructFetchFetcher(window.fetch);
const minParaSwap = constructPartialSDK({
chainId: 1,
fetcher,
}, constructGetRate, constructGetBalances);
const priceRoute = await minParaSwap.getRate(params);
const allowance = await minParaSwap.getAllowance(userAddress, tokenAddress);
```
### Legacy
The `ParaSwap` class is exposed for backwards compatibility with previous versions of the SDK.
```typescript
import { ParaSwap } from '@paraswap/sdk';
import axios from 'axios';
import Web3 from 'web3';
const web3Provider = new Web3(window.ethereum);
const account = '__user_address__';
const paraswap = new ParaSwap({chainId: 1, web3Provider, account, axios});
```
Or you can use `ethers` in place of `web3`
```typescript
import { ParaSwap } from '@paraswap/sdk';
import { ethers } from "ethers";
const ethersProvider = new ethers.providers.Web3Provider(window.ethereum)
const account = '__user_address__';
const paraswap = new ParaSwap({
chainId: 1,
account,
ethersDeps: {
ethersProviderOrSigner: ethersProvider;
EthersContract: ethers.Contract;
},
fetch: window.fetch,
});
```
By analogy to `constructPartialSDK`, you can leverage a lightweight version of the sdk for fetching only.
```typescript
import { ParaSwap } from '@paraswap/sdk';
const paraswap = new ParaSwap({chainId: 1, fetch: window.fetch});
```
Refer to [this README for depecreated documentation](https://github.com/paraswap/paraswap-sdk/blob/c4c70c674fb2be4ec528064649d992d4b38c654b/README.md) for functions usage.
Refer to SDK API documentation for detailed documentation on the methods provided in this SDK.
### Tests
To run `yarn test` it is necessary to provide `PROVIDER_URL=` environment variable. If it is necessary to run tests against a different API endpoint, provide `API_URL=url_to_API` environment variable.
# Python
https\://github.com/paraswap/paraswap-python-sdk
ParaSwap's Python SDK V1 currently handles ParaSwap limit orders.
## Install
```
python3 setup.py build
python3 setup.py install # may need privilege authorization
```
## Run examples
You need to add the previous variables inside a .env file to run our examples.
PK1 and PK2 are two EVM-compatible secret keys that will be used to sign orders.
```
PK1=
PK2=
RPC_HTTP_1=
RPC_HTTP_3=
RPC_HTTP_10=
RPC_HTTP_56=
RPC_HTTP_137=
RPC_HTTP_250=
RPC_HTTP_42161=
RPC_HTTP_43114=
```
## Examples:
```
everything in ./examples/
```
# Augustus Swapper
Augustus is the exchange proxy that enables swaps to happen in ParaSwap.
## Introduction
In this section, we'll describe the architecture of Augustus Swapper and its different internal mechanisms.
## Simple-Path Swaps (Simple Swap)
Simple Swap is the simplest way for swapping tokens where there is no need to use any intermediary token.
Eg: Swapping 50 ETH --> MKR through one or more DEXs.
## Multi-Path Swaps
A multi-path swap corresponds to using one or multiple intermediary tokens in a single swap in order to maximize the gain of the destination Token.
An example would be **100 ETH** **--> USDT**, where the best route could be:
* First, swapping 100 ETH to DAI,
* Then, swapping the corresponding DAI to USDT.
Here each step would use one or multiple DEXs.
## Mega-path Swaps
Mega Path is a generalized case for Multi Swap. Here, a swap can be broken down into ***multiple Multi-Swaps***. It's generally useful with larger amounts.
## Fee Structure
Partners integrating with ParaSwap using the ParaSwap API can control the fee structure of their integration, deciding whether to charge a swap fee or participate in surplus sharing.
For more information on how Partner Fees are implemented, please refer to the API Partners - Revenue Share Overview Section.
{% embed url="" %}
## Architecture
The primary AugustusSwapper contract acts as a proxy contract. It passes on the calls to respective routers as per the function signature. Each function call has its own specific router which needs to be registered by the admin.
## Routers
For each specific trade type, we have built a separate router. Currently, we have routers for:
* SimpleSwap,
* Multipath (with Megapath included),
* direct swaps on Uniswap V2 (and forks)
* direct swaps on 0x V2 and V4 (used to execute RFQ orders from ParaSwapPools)
* Additional helper functions (used by simple swap for example)
Multipath routers delegate calls to adapters.
## Adapters
Adapters are a collection of different exchange handlers. The number of exchange handlers is limited by the quantity of code allowed in one contract, so multiple adapters may be in use to cover all possible exchanges.
## Exchange Routers
These are not part of the Augustus architecture per se but independent contracts. These are for use with simple swap where normally we'd use the official router contract of a DEX, but instead we may use a customized router (optimized to save gas). Currently this is only done for Uniswap V2 and similar forks.
# Augustus v6.2 smart contracts
Augustus is the exchange middleware that enables on-chain swaps
## AugustusSwapper
The contract router is responsible for making swaps.
* Mainnet : [0x6a000f20005980200259b80c5102003040001068](https://etherscan.io/address/0x6a000f20005980200259b80c5102003040001068)
* Arbitrum: [0x6a000f20005980200259b80c5102003040001068](https://arbiscan.io/address/0x6A000F20005980200259B80c5102003040001068)
* Avalanche: [0x6a000f20005980200259b80c5102003040001068](https://snowscan.xyz/address/0x6A000F20005980200259B80c5102003040001068)
* Base: [0x6a000f20005980200259b80c5102003040001068](https://basescan.org/address/0x6A000F20005980200259B80c5102003040001068)
* BSC: [0x6a000f20005980200259b80c5102003040001068](https://bscscan.com/address/0x6A000F20005980200259B80c5102003040001068)
* Gnosis: [0x6A000F20005980200259B80c5102003040001068](https://gnosisscan.io/address/0x6A000F20005980200259B80c5102003040001068)
* Optimism: [0x6a000f20005980200259b80c5102003040001068](https://optimistic.etherscan.io/address/0x6A000F20005980200259B80c5102003040001068)
* Polygon: [0x6a000f20005980200259b80c5102003040001068](https://polygonscan.com/address/https://optimistic.etherscan.io/address/0x6A000F20005980200259B80c5102003040001068)
* Sonic: [0x6a000f20005980200259b80c5102003040001068](https://sonicscan.org/address/0x6a000f20005980200259b80c5102003040001068)
* Unichain: [0x6a000f20005980200259b80c5102003040001068](https://unichain.blockscout.com/address/0x6A000F20005980200259B80c5102003040001068)
* Plasma: [0x6a000f20005980200259b80c5102003040001068](https://plasmascan.to/address/0x6a000f20005980200259b80c5102003040001068)
{% file src="/files/ZVrxBCDarEU5taX6pdM9" %}
```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.22;
// Interfaces
import { IERC20 } from "@openzeppelin/token/ERC20/IERC20.sol";
/*//////////////////////////////////////////////////////////////
GENERIC SWAP DATA
//////////////////////////////////////////////////////////////*/
/// @notice Struct containg data for generic swapExactAmountIn/swapExactAmountOut
/// @param srcToken The token to swap from
/// @param destToken The token to swap to
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount of destToken to receive
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param quotedAmount The quoted expected amount of destToken/srcToken
/// = quotedAmountOut for swapExactAmountIn and quotedAmountIn for swapExactAmountOut
/// @param metadata Packed uuid and additional metadata
/// @param beneficiary The address to send the swapped tokens to
struct GenericData {
IERC20 srcToken;
IERC20 destToken;
uint256 fromAmount;
uint256 toAmount;
uint256 quotedAmount;
bytes32 metadata;
address payable beneficiary;
}
/*//////////////////////////////////////////////////////////////
UNISWAPV2
//////////////////////////////////////////////////////////////*/
/// @notice Struct for UniswapV2 swapExactAmountIn/swapExactAmountOut data
/// @param srcToken The token to swap from
/// @param destToken The token to swap to
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param quotedAmount The quoted expected amount of destToken/srcToken
/// = quotedAmountOut for swapExactAmountIn and quotedAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount of destToken to receive
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param metadata Packed uuid and additional metadata
/// @param beneficiary The address to send the swapped tokens to
/// @param pools data consisting of concatenated token0 and token1 address for each pool with the direction flag being
/// the right most bit of the packed token0-token1 pair bytes used in the path
struct UniswapV2Data {
IERC20 srcToken;
IERC20 destToken;
uint256 fromAmount;
uint256 toAmount;
uint256 quotedAmount;
bytes32 metadata;
address payable beneficiary;
bytes pools;
}
/*//////////////////////////////////////////////////////////////
UNISWAPV3
//////////////////////////////////////////////////////////////*/
/// @notice Struct for UniswapV3 swapExactAmountIn/swapExactAmountOut data
/// @param srcToken The token to swap from
/// @param destToken The token to swap to
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param quotedAmount The quoted expected amount of destToken/srcToken
/// = quotedAmountOut for swapExactAmountIn and quotedAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount of destToken to receive
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param metadata Packed uuid and additional metadata
/// @param beneficiary The address to send the swapped tokens to
/// @param pools data consisting of concatenated token0-
/// token1-fee bytes for each pool used in the path, with the direction flag being the left most bit of token0 in the
/// concatenated bytes
struct UniswapV3Data {
IERC20 srcToken;
IERC20 destToken;
uint256 fromAmount;
uint256 toAmount;
uint256 quotedAmount;
bytes32 metadata;
address payable beneficiary;
bytes pools;
}
/*//////////////////////////////////////////////////////////////
CURVE V1
//////////////////////////////////////////////////////////////*/
/// @notice Struct for CurveV1 swapExactAmountIn data
/// @param curveData Packed data for the Curve pool, first 160 bits is the target exchange address,
/// the 161st bit is the approve flag, bits from (162 - 163) are used for the wrap flag,
//// bits from (164 - 165) are used for the swapType flag and the last 91 bits are unused:
/// Approve Flag - a) 0 -> do not approve b) 1 -> approve
/// Wrap Flag - a) 0 -> do not wrap b) 1 -> wrap native & srcToken == eth
/// c) 2 -> unwrap and destToken == eth d) 3 - >srcToken == eth && do not wrap
/// Swap Type Flag - a) 0 -> EXCHANGE b) 1 -> EXCHANGE_UNDERLYING
/// @param curveAssets Packed uint128 index i and uint128 index j of the pool
/// The first 128 bits is the index i and the second 128 bits is the index j
/// @param srcToken The token to swap from
/// @param destToken The token to swap to
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount that must be recieved
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param quotedAmount The expected amount of destToken to be recieved
/// = quotedAmountOut for swapExactAmountIn and quotedAmountIn for swapExactAmountOut
/// @param metadata Packed uuid and additional metadata
/// @param beneficiary The address to send the swapped tokens to
struct CurveV1Data {
uint256 curveData;
uint256 curveAssets;
IERC20 srcToken;
IERC20 destToken;
uint256 fromAmount;
uint256 toAmount;
uint256 quotedAmount;
bytes32 metadata;
address payable beneficiary;
}
/*//////////////////////////////////////////////////////////////
CURVE V2
//////////////////////////////////////////////////////////////*/
/// @notice Struct for CurveV2 swapExactAmountIn data
/// @param curveData Packed data for the Curve pool, first 160 bits is the target exchange address,
/// the 161st bit is the approve flag, bits from (162 - 163) are used for the wrap flag,
//// bits from (164 - 165) are used for the swapType flag and the last 91 bits are unused
/// Approve Flag - a) 0 -> do not approve b) 1 -> approve
/// Approve Flag - a) 0 -> do not approve b) 1 -> approve
/// Wrap Flag - a) 0 -> do not wrap b) 1 -> wrap native & srcToken == eth
/// c) 2 -> unwrap and destToken == eth d) 3 - >srcToken == eth && do not wrap
/// Swap Type Flag - a) 0 -> EXCHANGE b) 1 -> EXCHANGE_UNDERLYING c) 2 -> EXCHANGE_UNDERLYING_FACTORY_ZAP
/// @param i The index of the srcToken
/// @param j The index of the destToken
/// The first 128 bits is the index i and the second 128 bits is the index j
/// @param poolAddress The address of the CurveV2 pool (only used for EXCHANGE_UNDERLYING_FACTORY_ZAP)
/// @param srcToken The token to swap from
/// @param destToken The token to swap to
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount that must be recieved
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param quotedAmount The expected amount of destToken to be recieved
/// = quotedAmountOut for swapExactAmountIn and quotedAmountIn for swapExactAmountOut
/// @param metadata Packed uuid and additional metadata
/// @param beneficiary The address to send the swapped tokens to
struct CurveV2Data {
uint256 curveData;
uint256 i;
uint256 j;
address poolAddress;
IERC20 srcToken;
IERC20 destToken;
uint256 fromAmount;
uint256 toAmount;
uint256 quotedAmount;
bytes32 metadata;
address payable beneficiary;
}
/*//////////////////////////////////////////////////////////////
BALANCER V2
//////////////////////////////////////////////////////////////*/
/// @notice Struct for BalancerV2 swapExactAmountIn data
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount of destToken to receive
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param quotedAmount The quoted expected amount of destToken/srcToken
/// = quotedAmountOut for swapExactAmountIn and quotedAmountIn for swapExactAmountOut
/// @param metadata Packed uuid and additional metadata
/// @param beneficiaryAndApproveFlag The beneficiary address and approve flag packed into one uint256,
/// the first 20 bytes are the beneficiary address and the left most bit is the approve flag
struct BalancerV2Data {
uint256 fromAmount;
uint256 toAmount;
uint256 quotedAmount;
bytes32 metadata;
uint256 beneficiaryAndApproveFlag;
}
/*//////////////////////////////////////////////////////////////
MAKERPSM
//////////////////////////////////////////////////////////////*/
/// @notice Struct for Maker PSM swapExactAmountIn data
/// @param srcToken The token to swap from
/// @param destToken The token to swap to
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount of destToken to receive
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param toll Used to calculate gem amount for the swapExactAmountIn
/// @param to18ConversionFactor Used to calculate gem amount for the swapExactAmountIn
/// @param gemJoinAddress The address of the gemJoin contract
/// @param exchange The address of the exchange contract
/// @param metadata Packed uuid and additional metadata
/// @param beneficiaryDirectionApproveFlag The beneficiary address, swap direction and approve flag packed
/// into one uint256, the first 20 bytes are the beneficiary address, the left most bit is the approve flag and the
/// second left most bit is the swap direction flag, 0 for swapExactAmountIn and 1 for swapExactAmountOut
struct MakerPSMData {
IERC20 srcToken;
IERC20 destToken;
uint256 fromAmount;
uint256 toAmount;
uint256 toll;
uint256 to18ConversionFactor;
address exchange;
address gemJoinAddress;
bytes32 metadata;
uint256 beneficiaryDirectionApproveFlag;
}
/*//////////////////////////////////////////////////////////////
AUGUSTUS RFQ
//////////////////////////////////////////////////////////////*/
/// @notice Order struct for Augustus RFQ
/// @param nonceAndMeta The nonce and meta data packed into one uint256,
/// the first 160 bits is the user address and the last 96 bits is the nonce
/// @param expiry The expiry of the order
/// @param makerAsset The address of the maker asset
/// @param takerAsset The address of the taker asset
/// @param maker The address of the maker
/// @param taker The address of the taker, if the taker is address(0) anyone can take the order
/// @param makerAmount The amount of makerAsset
/// @param takerAmount The amount of takerAsset
struct Order {
uint256 nonceAndMeta;
uint128 expiry;
address makerAsset;
address takerAsset;
address maker;
address taker;
uint256 makerAmount;
uint256 takerAmount;
}
/// @notice Struct containing order info for Augustus RFQ
/// @param order The order struct
/// @param signature The signature for the order
/// @param takerTokenFillAmount The amount of takerToken to fill
/// @param permitTakerAsset The permit data for the taker asset
/// @param permitMakerAsset The permit data for the maker asset
struct OrderInfo {
Order order;
bytes signature;
uint256 takerTokenFillAmount;
bytes permitTakerAsset;
bytes permitMakerAsset;
}
/// @notice Struct containing common data for executing swaps on Augustus RFQ
/// @param fromAmount The amount of srcToken to swap
/// = amountIn for swapExactAmountIn and maxAmountIn for swapExactAmountOut
/// @param toAmount The minimum amount of destToken to receive
/// = minAmountOut for swapExactAmountIn and amountOut for swapExactAmountOut
/// @param wrapApproveDirection The wrap, approve and direction flag packed into one uint8,
/// the first 2 bits is wrap flag (10 for wrap dest, 01 for wrap src, 00 for no wrap), the next bit is the approve flag
/// (1 for approve, 0 for no approve) and the last bit is the direction flag (0 for swapExactAmountIn and 1 for
/// swapExactAmountOut)
/// @param metadata Packed uuid and additional metadata
struct AugustusRFQData {
uint256 fromAmount;
uint256 toAmount;
uint8 wrapApproveDirection;
bytes32 metadata;
address payable beneficiary;
}
```
### Interfaces
#### GenericSwapExactAmountIn
```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.22;
// Interfaces
import { IErrors } from "./IErrors.sol";
// Types
import { GenericData } from "../AugustusV6Types.sol";
/// @title IGenericSwapExactAmountIn
/// @notice Interface for executing a generic swapExactAmountIn through an Augustus executor
interface IGenericSwapExactAmountIn is IErrors {
/*//////////////////////////////////////////////////////////////
SWAP EXACT AMOUNT IN
//////////////////////////////////////////////////////////////*/
/// @notice Executes a generic swapExactAmountIn using the given executorData on the given executor
/// @param executor The address of the executor contract to use
/// @param swapData Generic data containing the swap information
/// @param partnerAndFee packed partner address and fee percentage, the first 12 bytes is the feeData and the last
/// 20 bytes is the partner address
/// @param permit The permit data
/// @param executorData The data to execute on the executor
/// @return receivedAmount The amount of destToken received after fees
/// @return paraswapShare The share of the fees for Paraswap
/// @return partnerShare The share of the fees for the partner
function swapExactAmountIn(
address executor,
GenericData calldata swapData,
uint256 partnerAndFee,
bytes calldata permit,
bytes calldata executorData
)
external
payable
returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
}
```
#### GenericSwapExactAmountOut
```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.22;
// Interfaces
import { IErrors } from "./IErrors.sol";
// Types
import { GenericData } from "../AugustusV6Types.sol";
/// @title IGenericSwapExactAmountOut
/// @notice Interface for executing a generic swapExactAmountOut through an Augustus executor
interface IGenericSwapExactAmountOut is IErrors {
/*//////////////////////////////////////////////////////////////
SWAP EXACT AMOUNT OUT
//////////////////////////////////////////////////////////////*/
/// @notice Executes a generic swapExactAmountOut using the given executorData on the given executor
/// @param executor The address of the executor contract to use
/// @param swapData Generic data containing the swap information
/// @param partnerAndFee packed partner address and fee percentage, the first 12 bytes is the feeData and the last
/// 20 bytes is the partner address
/// @param permit The permit data
/// @param executorData The data to execute on the executor
/// @return spentAmount The actual amount of tokens used to swap
/// @return receivedAmount The amount of tokens received from the swap
/// @return paraswapShare The share of the fees for Paraswap
/// @return partnerShare The share of the fees for the partner
function swapExactAmountOut(
address executor,
GenericData calldata swapData,
uint256 partnerAndFee,
bytes calldata permit,
bytes calldata executorData
)
external
payable
returns (uint256 spentAmount, uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
}
```
### **Fee Vault**
* Ethereum: [0x00700052c0608f670705380a4900e0a8080010cc](https://etherscan.io/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Arbitrum: [0x00700052c0608f670705380a4900e0a8080010cc](https://arbiscan.io/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Avalanche: [0x00700052c0608f670705380a4900e0a8080010cc](https://snowtrace.io/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Base: [0x00700052c0608f670705380a4900e0a8080010cc](https://basescan.org/address/0x00700052c0608f670705380a4900e0a8080010cc)
* BSC: [0x00700052c0608f670705380a4900e0a8080010cc](https://bscscan.com/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Fantom: [0x00700052c0608f670705380a4900e0a8080010cc](https://ftmscan.com/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Gnosis: [0x00700052c0608F670705380a4900e0a8080010CC](https://gnosisscan.io/address/0x00700052c0608F670705380a4900e0a8080010CC)
* Optimism: [0x00700052c0608f670705380a4900e0a8080010cc](https://optimistic.etherscan.io/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Polygon [0x00700052c0608f670705380a4900e0a8080010cc](https://polygonscan.com/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Sonic: [0x00700052c0608f670705380a4900e0a8080010cc](https://sonicscan.org/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Unichain: [0x00700052c0608f670705380a4900e0a8080010cc](https://unichain.blockscout.com/address/0x00700052c0608f670705380a4900e0a8080010cc)
* Plasma: [0x00700052c0608f670705380a4900e0a8080010cc](https://plasmascan.to/address/0x00700052c0608f670705380a4900e0a8080010cc)
{% file src="/files/bGhtLjTi2tCIwJMcyc8O" %}
```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.22;
// Interfaces
import { IERC20 } from "@openzeppelin/token/ERC20/IERC20.sol";
/// @title IAugustusFeeVault
/// @notice Interface for the AugustusFeeVault contract
interface IAugustusFeeVault {
/*//////////////////////////////////////////////////////////////
ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Error emitted when withdraw amount is zero or exceeds the stored amount
error InvalidWithdrawAmount();
/// @notice Error emmitted when caller is not an approved augustus contract
error UnauthorizedCaller();
/// @notice Error emitted when an invalid parameter length is passed
error InvalidParameterLength();
/// @notice Error emitted when batch withdraw fails
error BatchCollectFailed();
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
/// @notice Emitted when an augustus contract approval status is set
/// @param augustus The augustus contract address
/// @param approved The approval status
event AugustusApprovalSet(address indexed augustus, bool approved);
/*//////////////////////////////////////////////////////////////
STRUCTS
//////////////////////////////////////////////////////////////*/
/// @notice Struct to register fees
/// @param addresses The addresses to register fees for
/// @param token The token to register fees for
/// @param fees The fees to register
struct FeeRegistration {
address[] addresses;
IERC20 token;
uint256[] fees;
}
/*//////////////////////////////////////////////////////////////
COLLECT
//////////////////////////////////////////////////////////////*/
/// @notice Allows partners to withdraw fees allocated to them and stored in the vault
/// @param token The token to withdraw fees in
/// @param amount The amount of fees to withdraw
/// @param recipient The address to send the fees to
/// @return success Whether the transfer was successful or not
function withdrawSomeERC20(IERC20 token, uint256 amount, address recipient) external returns (bool success);
/// @notice Allows partners to withdraw all fees allocated to them and stored in the vault for a given token
/// @param token The token to withdraw fees in
/// @param recipient The address to send the fees to
/// @return success Whether the transfer was successful or not
function withdrawAllERC20(IERC20 token, address recipient) external returns (bool success);
/// @notice Allows partners to withdraw all fees allocated to them and stored in the vault for multiple tokens
/// @param tokens The tokens to withdraw fees i
/// @param recipient The address to send the fees to
/// @return success Whether the transfer was successful or not
function batchWithdrawAllERC20(IERC20[] calldata tokens, address recipient) external returns (bool success);
/// @notice Allows partners to withdraw fees allocated to them and stored in the vault
/// @param tokens The tokens to withdraw fees in
/// @param amounts The amounts of fees to withdraw
/// @param recipient The address to send the fees to
/// @return success Whether the transfer was successful or not
function batchWithdrawSomeERC20(
IERC20[] calldata tokens,
uint256[] calldata amounts,
address recipient
)
external
returns (bool success);
/*//////////////////////////////////////////////////////////////
BALANCE GETTERS
//////////////////////////////////////////////////////////////*/
/// @notice Get the balance of a given token for a given partner
/// @param token The token to get the balance of
/// @param partner The partner to get the balance for
/// @return feeBalance The balance of the given token for the given partner
function getBalance(IERC20 token, address partner) external view returns (uint256 feeBalance);
/// @notice Get the balances of a given partner for multiple tokens
/// @param tokens The tokens to get the balances of
/// @param partner The partner to get the balances for
/// @return feeBalances The balances of the given tokens for the given partner
function batchGetBalance(
IERC20[] calldata tokens,
address partner
)
external
view
returns (uint256[] memory feeBalances);
/// @notice Returns the unallocated fees for a given token
/// @param token The token to get the unallocated fees for
/// @return unallocatedFees The unallocated fees for the given token
function getUnallocatedFees(IERC20 token) external view returns (uint256 unallocatedFees);
/*//////////////////////////////////////////////////////////////
OWNER
//////////////////////////////////////////////////////////////*/
/// @notice Registers the given feeData to the vault
/// @param feeData The fee registration data
function registerFees(FeeRegistration memory feeData) external;
/// @notice Sets the augustus contract approval status
/// @param augustus The augustus contract address
/// @param approved The approval status
function setAugustusApproval(address augustus, bool approved) external;
/// @notice Sets the contract pause state
/// @param _isPaused The new pause state
function setContractPauseState(bool _isPaused) external;
}
```
### Augustus Registry
Use AugustusRegistry to verify AugustusSwapper addresses.
* Mainnet: [0xa68bEA62Dc4034A689AA0F58A76681433caCa663](https://etherscan.io/address/0xa68bEA62Dc4034A689AA0F58A76681433caCa663)
* Arbitrum: [0xdC6E2b14260F972ad4e5a31c68294Fba7E720701](https://arbiscan.io/address/0xdC6E2b14260F972ad4e5a31c68294Fba7E720701)
* Avalanche: [0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a](https://snowtrace.io/address/0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a)
* Base: [0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3](https://basescan.org/address/0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3)
* BSC: [0x05b4486f643914a818ed93afc07457e9074be211](https://bscscan.com/address/0x05b4486f643914a818ed93afc07457e9074be211)
* Fantom: [0x161383b5dAFc1cc05Ec058e5B0b0703BA175bdA6](https://ftmscan.com/address/0x161383b5dAFc1cc05Ec058e5B0b0703BA175bdA6)
* Gnosis: [0xa1686Ee049A745211D64ef2B305495D9425e7BD3](https://gnosisscan.io/address/0xa1686Ee049A745211D64ef2B305495D9425e7BD3)
* Optimism: [0x6e7bE86000dF697facF4396efD2aE2C322165dC3](https://optimistic.etherscan.io/address/0x6e7bE86000dF697facF4396efD2aE2C322165dC3)
* Polygon: [0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1](https://polygonscan.com/address/0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1)
* Sonic: [0x515D89fB6b472D56Ca065AB21b32975f6ab8da3E](https://sonicscan.org/address/0x515D89fB6b472D56Ca065AB21b32975f6ab8da3E)
* Unichain: [0xB5253c895361678FF5D0fFDdA81Dd02f1F7a81D6](https://unichain.blockscout.com/address/0xB5253c895361678FF5D0fFDdA81Dd02f1F7a81D6)
* Plasma: [0x09920244F4c4f79c4926b6DCD8bE2Efc5CD1224E](https://plasmascan.to/address/0x09920244F4c4f79c4926b6DCD8bE2Efc5CD1224E)
```solidity
interface IAugustusRegistry {
function isAugustusBanned(address augustus) external view returns (bool);
function isValidAugustus(address augustus) external view returns (bool);
function getAugustusCount() external view returns (uint256);
function getLatestVersion() external view returns (string memory);
function getLatestAugustus() external view returns (address);
function getAugustusByVersion(string calldata version) external view returns (address);
}
```
# Augustus v5 smart contracts
{% hint style="warning" %}
Allowance should be given to **TokenTransferProxy** contract and not to **AugustusSwapper, FUNDS MAY BE LOST OTHERWISE!**
{% endhint %}
## AugustusSwapper
The contract router is responsible for making swaps.
* Mainnet : [0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57](https://etherscan.io/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57#code)
* Arbitrum: [0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57](https://arbiscan.io/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57)
* Avalanche: [0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57](https://cchain.explorer.avax.network/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57/contracts)
* Base: [0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52](https://basescan.org/address/0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52)
* BSC: [0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57](https://bscscan.com/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57#code)
* Optimism: [0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57](https://optimistic.etherscan.io/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57)
* Polygon: [0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57](https://polygonscan.com/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57#code)
### TokenTransferProxy
The Spender contract is responsible for moving ERC20 tokens (and equivalents on side chains). To get the address, you can call `getTokenTransferProxy()` on Augustus.
* Mainnet: [0x216b4b4ba9f3e719726886d34a177484278bfcae](https://etherscan.io/address/0x216b4b4ba9f3e719726886d34a177484278bfcae#code)
* Arbitrum: [0x216B4B4Ba9F3e719726886d34a177484278Bfcae](https://arbiscan.io/address/0x216B4B4Ba9F3e719726886d34a177484278Bfcae)
* Avalanche: [0x216b4b4ba9f3e719726886d34a177484278bfcae](https://cchain.explorer.avax.network/address/0x216B4B4Ba9F3e719726886d34a177484278Bfcae/contracts)
* Base: [0x93aAAe79a53759cD164340E4C8766E4Db5331cD7](https://basescan.org/address/0x93aAAe79a53759cD164340E4C8766E4Db5331cD7)
* BSC: [0x216b4b4ba9f3e719726886d34a177484278bfcae](https://ropsten.etherscan.io/address/0x216b4b4ba9f3e719726886d34a177484278bfcae)
* Optimism: [0x216B4B4Ba9F3e719726886d34a177484278Bfcae](https://optimistic.etherscan.io/address/0x216b4b4ba9f3e719726886d34a177484278bfcae)
* Polygon: [0x216b4b4ba9f3e719726886d34a177484278bfcae](https://polygonscan.com/address/0x216B4B4Ba9F3e719726886d34a177484278Bfcae#code)
```solidity
pragma solidity 0.7.5;
interface ITokenTransferProxy {
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
external;
}
```
### Augustus Registry
Use AugustusRegistry to verify AugustusSwapper addresses.
* Mainnet: [0xa68bEA62Dc4034A689AA0F58A76681433caCa663](https://etherscan.io/address/0xa68bEA62Dc4034A689AA0F58A76681433caCa663)
* Arbitrum: [0xdC6E2b14260F972ad4e5a31c68294Fba7E720701](https://arbiscan.io/address/0xdC6E2b14260F972ad4e5a31c68294Fba7E720701)
* Avalanche: [0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a](https://snowtrace.io/address/0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a)
* Base: [0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3](https://basescan.org/address/0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3)
* BSC: [0x05b4486f643914a818ed93afc07457e9074be211](https://bscscan.com/address/0x05b4486f643914a818ed93afc07457e9074be211)
* Optimism: [0x6e7bE86000dF697facF4396efD2aE2C322165dC3](https://optimistic.etherscan.io/address/0x6e7bE86000dF697facF4396efD2aE2C322165dC3)
* Polygon: [0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1](https://polygonscan.com/address/0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1)
```solidity
interface IAugustusRegistry {
function isAugustusBanned(address augustus) external view returns (bool);
function isValidAugustus(address augustus) external view returns (bool);
function getAugustusCount() external view returns (uint256);
function getLatestVersion() external view returns (string memory);
function getLatestAugustus() external view returns (address);
function getAugustusByVersion(string calldata version) external view returns (address);
}
```
### AugustusSwapper (implements IParaswap through fallback method)
#### ABI (merged AugustusSwapper and IParaswap ABIs)
{% file src="/files/-MjZ8685KZTNGIaoeid5" %}
### **IAugustusSwapper**
```solidity
interface IAugustusSwapper {
struct FeeStructure {
uint256 partnerShare;
bool noPositiveSlippage;
bool positiveSlippageToUser;
uint16 feePercent;
string partnerId;
bytes data;
}
function DEFAULT_ADMIN_ROLE ( ) external view returns ( bytes32 );
function ROUTER_ROLE ( ) external view returns ( bytes32 );
function WHITELISTED_ROLE ( ) external view returns ( bytes32 );
function getAdapterData ( bytes32 key ) external view returns ( bytes );
function getFeeWallet ( ) external view returns ( address );
function getImplementation ( bytes4 selector ) external view returns ( address );
function getPartnerFeeStructure ( address partner ) external view returns ( FeeStructure memory );
function getRoleAdmin ( bytes32 role ) external view returns ( bytes32 );
function getRoleMember ( bytes32 role, uint256 index ) external view returns ( address );
function getRoleMemberCount ( bytes32 role ) external view returns ( uint256 );
function getRouterData ( bytes32 key ) external view returns ( bytes );
function getTokenTransferProxy ( ) external view returns ( address );
function getVersion ( ) external pure returns ( string );
function grantRole ( bytes32 role, address account ) external;
function hasRole ( bytes32 role, address account ) external view returns ( bool );
function initializeAdapter ( address adapter, bytes data ) external;
function initializeRouter ( address router, bytes data ) external;
function isAdapterInitialized ( bytes32 key ) external view returns ( bool );
function isRouterInitialized ( bytes32 key ) external view returns ( bool );
function registerPartner ( address partner, uint256 _partnerShare, bool _noPositiveSlippage, bool _positiveSlippageToUser, uint16 _feePercent, string partnerId, bytes _data ) external;
function renounceRole ( bytes32 role, address account ) external;
function revokeRole ( bytes32 role, address account ) external;
function setFeeWallet ( address _feeWallet ) external;
function setImplementation ( bytes4 selector, address implementation ) external;
function transferTokens ( address token, address destination, uint256 amount ) external;
}
```
(Generated from AugustusSwapper ABI using [ABI2Solidity tool](https://bia.is/tools/abi2solidity/) then edited to add FeeStructure)
### IParaswap
```solidity
pragma solidity 0.7.5;
import "./lib/Utils.sol";
interface IParaswap {
event Swapped(
bytes16 uuid,
address initiator,
address indexed beneficiary,
address indexed srcToken,
address indexed destToken,
uint256 srcAmount,
uint256 receivedAmount,
uint256 expectedAmount
);
event Bought(
bytes16 uuid,
address initiator,
address indexed beneficiary,
address indexed srcToken,
address indexed destToken,
uint256 srcAmount,
uint256 receivedAmount
);
event FeeTaken(
uint256 fee,
uint256 partnerShare,
uint256 paraswapShare
);
function multiSwap(
Utils.SellData calldata data
)
external
payable
returns (uint256);
function megaSwap(
Utils.MegaSwapSellData calldata data
)
external
payable
returns (uint256);
function protectedMultiSwap(
Utils.SellData calldata data
)
external
payable
returns (uint256);
function protectedMegaSwap(
Utils.MegaSwapSellData calldata data
)
external
payable
returns (uint256);
function protectedSimpleSwap(
Utils.SimpleData calldata data
)
external
payable
returns (uint256 receivedAmount);
function protectedSimpleBuy(
Utils.SimpleData calldata data
)
external
payable;
function simpleSwap(
Utils.SimpleData calldata data
)
external
payable
returns (uint256 receivedAmount);
function simpleBuy(
Utils.SimpleData calldata data
)
external
payable;
function swapOnUniswap(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path
)
external
payable;
function swapOnUniswapFork(
address factory,
bytes32 initCode,
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path
)
external
payable;
function buyOnUniswap(
uint256 amountInMax,
uint256 amountOut,
address[] calldata path
)
external
payable;
function buyOnUniswapFork(
address factory,
bytes32 initCode,
uint256 amountInMax,
uint256 amountOut,
address[] calldata path
)
external
payable;
function swapOnUniswapV2Fork(
address tokenIn,
uint256 amountIn,
uint256 amountOutMin,
address weth,
uint256[] calldata pools
)
external
payable;
function buyOnUniswapV2Fork(
address tokenIn,
uint256 amountInMax,
uint256 amountOut,
address weth,
uint256[] calldata pools
)
external
payable;
function swapOnZeroXv2(
IERC20 fromToken,
IERC20 toToken,
uint256 fromAmount,
uint256 amountOutMin,
address exchange,
bytes calldata payload
)
external
payable;
function swapOnZeroXv4(
IERC20 fromToken,
IERC20 toToken,
uint256 fromAmount,
uint256 amountOutMin,
address exchange,
bytes calldata payload
)
external
payable;
}
```
### Utils
```solidity
pragma solidity 0.7.5;
library Utils {
/**
* @param fromToken Address of the source token
* @param fromAmount Amount of source tokens to be swapped
* @param toAmount Minimum destination token amount expected out of this swap
* @param expectedAmount Expected amount of destination tokens without slippage
* @param beneficiary Beneficiary address
* 0 then 100% will be transferred to beneficiary. Pass 10000 for 100%
* @param path Route to be taken for this swap to take place
*/
struct SellData {
address fromToken;
uint256 fromAmount;
uint256 toAmount;
uint256 expectedAmount;
address payable beneficiary;
Utils.Path[] path;
address payable partner;
uint256 feePercent;
bytes permit;
uint256 deadline;
bytes16 uuid;
}
struct MegaSwapSellData {
address fromToken;
uint256 fromAmount;
uint256 toAmount;
uint256 expectedAmount;
address payable beneficiary;
Utils.MegaSwapPath[] path;
address payable partner;
uint256 feePercent;
bytes permit;
uint256 deadline;
bytes16 uuid;
}
struct SimpleData {
address fromToken;
address toToken;
uint256 fromAmount;
uint256 toAmount;
uint256 expectedAmount;
address[] callees;
bytes exchangeData;
uint256[] startIndexes;
uint256[] values;
address payable beneficiary;
address payable partner;
uint256 feePercent;
bytes permit;
uint256 deadline;
bytes16 uuid;
}
struct Adapter {
address payable adapter;
uint256 percent;
uint256 networkFee;
Route[] route;
}
struct Route {
uint256 index;//Adapter at which index needs to be used
address targetExchange;
uint percent;
bytes payload;
uint256 networkFee;//Network fee is associated with 0xv3 trades
}
struct MegaSwapPath {
uint256 fromAmountPercent;
Path[] path;
}
struct Path {
address to;
uint256 totalNetworkFee;//Network fee is associated with 0xv3 trades
Adapter[] adapters;
}
}
```
### **Fee Claimer**
* Ethereum: [0xeF13101C5bbD737cFb2bF00Bbd38c626AD6952F7](https://etherscan.io/address/0xeF13101C5bbD737cFb2bF00Bbd38c626AD6952F7)
* Arbitrum: [0xA7465CCD97899edcf11C56D2d26B49125674e45F](https://arbiscan.io/address/0xA7465CCD97899edcf11C56D2d26B49125674e45F)
* Avalanche: [0xbFcd68FD74B4B458961495F3392Bf96f46A29E67](https://snowtrace.io/address/0xbFcd68FD74B4B458961495F3392Bf96f46A29E67)
* Base: [0x9aaB4B24541af30fD72784ED98D8756ac0eFb3C7](https://basescan.org/address/0x9aaB4B24541af30fD72784ED98D8756ac0eFb3C7#code)
* BSC: [0x2DF17455B96Dde3618FD6B1C3a9AA06D6aB89347](https://bscscan.com/address/0x2DF17455B96Dde3618FD6B1C3a9AA06D6aB89347)
* Fantom: [0x4F14fE8c86A00D6DFB9e91239738499Fc0F587De](https://ftmscan.com/address/0x4F14fE8c86A00D6DFB9e91239738499Fc0F587De)
* Optimism: [0xA7465CCD97899edcf11C56D2d26B49125674e45F](https://optimistic.etherscan.io/address/0xA7465CCD97899edcf11C56D2d26B49125674e45F)
* Polygon: [0x8b5cF413214CA9348F047D1aF402Db1b4E96c06](https://polygonscan.com/address/0x8b5cF413214CA9348F047D1aF402Db1b4E96c060)
```solidity
pragma solidity 0.7.5;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IFeeClaimer {
/**
* @notice register partner's, affiliate's and PP's fee
* @dev only callable by AugustusSwapper contract
* @param _account account address used to withdraw fees
* @param _token token address
* @param _fee fee amount in token
*/
function registerFee(
address _account,
IERC20 _token,
uint256 _fee
) external;
/**
* @notice claim partner share fee in ERC20 token
* @dev transfers ERC20 token balance to the caller's account
* the call will fail if withdrawer have zero balance in the contract
* @param _token address of the ERC20 token
* @param _recipient address
* @return true if the withdraw was successfull
*/
function withdrawAllERC20(IERC20 _token, address _recipient) external returns (bool);
/**
* @notice batch claim whole balance of fee share amount
* @dev transfers ERC20 token balance to the caller's account
* the call will fail if withdrawer have zero balance in the contract
* @param _tokens list of addresses of the ERC20 token
* @param _recipient address of recipient
* @return true if the withdraw was successfull
*/
function batchWithdrawAllERC20(IERC20[] calldata _tokens, address _recipient) external returns (bool);
/**
* @notice claim some partner share fee in ERC20 token
* @dev transfers ERC20 token amount to the caller's account
* the call will fail if withdrawer have zero balance in the contract
* @param _token address of the ERC20 token
* @param _recipient address
* @return true if the withdraw was successfull
*/
function withdrawSomeERC20(
IERC20 _token,
uint256 _tokenAmount,
address _recipient
) external returns (bool);
/**
* @notice batch claim some amount of fee share in ERC20 token
* @dev transfers ERC20 token balance to the caller's account
* the call will fail if withdrawer have zero balance in the contract
* @param _tokens address of the ERC20 tokens
* @param _tokenAmounts array of amounts
* @param _recipient destination account addresses
* @return true if the withdraw was successfull
*/
function batchWithdrawSomeERC20(
IERC20[] calldata _tokens,
uint256[] calldata _tokenAmounts,
address _recipient
) external returns (bool);
/**
* @notice compute unallocated fee in token
* @param _token address of the ERC20 token
* @return amount of unallocated token in fees
*/
function getUnallocatedFees(IERC20 _token) external view returns (uint256);
/**
* @notice returns unclaimed fee amount given the token
* @dev retrieves the balance of ERC20 token fee amount for a partner
* @param _token address of the ERC20 token
* @param _partner account address of the partner
* @return amount of balance
*/
function getBalance(IERC20 _token, address _partner) external view returns (uint256);
/**
* @notice returns unclaimed fee amount given the token in batch
* @dev retrieves the balance of ERC20 token fee amount for a partner in batch
* @param _tokens list of ERC20 token addresses
* @param _partner account address of the partner
* @return _fees array of the token amount
*/
function batchGetBalance(IERC20[] calldata _tokens, address _partner)
external
view
returns (uint256[] memory _fees);
}
```
# Subgraphs
Query historical ParaSwap swap transactions on all supported chains through a GraphQL api via TheGraph.
Subgraph links for each supported chain
## Augustus v5
* [Ethereum](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-subgraph)
* [Arbitrum](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-subgraph-arbitrum)
* [Avalanche ](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-subgraph-avalanche)
* [Base](https://api.studio.thegraph.com/query/52704/paraswap-subgraph-base/v0.0.1)
* [BSC](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-subgraph-bsc)
* [Optimism](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-subgraph-optimism)
* [Polygon ](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-subgraph-polygon)
## AugustusRFQ (Limit Orders, RFQ, P2P, NFTs)
* [Ethereum](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-rfq-subgraph-mainnet)
* [Arbitrum](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-rfq-subgraph-arbitrum)
* [Avalanche](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-rfq-subgraph-avalanche)
* [BSC](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-rfq-subgraph-bsc)
* [Optimism](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-rfq-subgraph-optimism)
* [Polygon](https://thegraph.com/hosted-service/subgraph/paraswap/paraswap-rfq-subgraph-polygon)
The source code is publicly accessible on github [here](https://github.com/paraswap/paraswap-subgraph).
# Security
In this page you can explore all the security details and audits of ParaSwap
Augustus V6.2 /pages/Iu6WwqfjHdxpL6MgSyYf Augustus V6.1 /pages/pbFTRhBptyymWWrun3iB Augustus RFQ /pages/z6EbYO52NzDBfUO8Wnpe Augustus V5 /pages/FXzlGf13yiud4Wl1XHLv
# Augustus V6.2 security audit
In this page you can find all the security details and audit reports relevant to Augustus V6.2
Augustus V6.2 refines the fee-claiming process for partners while maintaining the security standards of V6.1.
Since V6.2 introduces only minor changes to its predecessor, the [five audits and verification by Certora for V6.1](/security/augustus-v6.1) remain relevant. Nonetheless, Augustus V6.2 was audited by three additional security firms to ensure protection against vulnerabilities.
### Audits
{% file src="/files/c32YtDKquMwfAIyJdYCk" %}
{% file src="/files/zFqZuLPhoDFMGhpG3HlT" %}
{% file src="/files/TGckYyLNHtIIuynegnvy" %}
# Augustus V6.1
In this page you can find all the security details and audit reports relevant to Augustus V6.1
## Security Improvements
Augustus V6.1 incorporates additional security measures to improve security and reliability, including:
* **Full re-audit by leading security firms**\
Augustus V6.1 has undergone a rigorous audit process conducted by five leading security firms: Certora, Hexens, Peckshield, Hacken, and Astrasec. These comprehensive audits confirmed that Augustus V6.1 meets the highest security standards.\
In addition, Augustus V6.1 received a [formal verification](https://docs.certora.com/projects/tutorials/en/latest/lesson1_prerequisites/formal_verification.html) by Certora, providing an additional security guarantee and making ParaSwap the first DEX aggregator to achieve this formal verification.
* **An additional mechanism for accelerated threat response**\
Augustus V6.1 is designed to be fully pausable, allowing swift response to potential issues. This means that if any suspicious activity is detected, it can be immediately halted.
* **TimeLock mechanism for Admin Actions**\
Except for Pausing, all Augustus V6.1 contract admin actions are subject to a TimeLock, which makes it resilient to immediate changes.
### Audits
{% file src="/files/xBsOH0zBLAieFnGqG7ru" %}
{% file src="/files/hqpLKer5gYLN2es9B35B" %}
{% file src="/files/mO9GCzNefqgm7y5Txsqd" %}
{% file src="/files/sd0DFYOlf26MBJEVz9Fu" %}
{% file src="/files/v9GO5cjVUgXTJ2hAOWxi" %}
# Augustus RFQ
In this page you can find all the security details and audit reports relevant to Augustus RFQ
## Audits
{% file src="/files/B94W8LKPHjImXrndOOYT" %}
# Augustus V5 security audit
In this page you can find all the security details and audit reports relevant to Augustus V6
## Audits
{% file src="/files/eLy2Fwcr07jOmrvw90YJ" %}
{% file src="/files/ztl0UtuyV9BXsAtLx6CT" %}