# 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.md).

The only differences are:

* slightly different route (`/ft/p2p/...` instead of `/ft/orders/...` )
* taker should contain [Augustus Swapper](/augustus-swapper/smart-contracts.md) address
* the intended order taker is [encoded in the nonceAndMeta](/api/augustusrfq/data-structure-in-our-centralized-system.md) 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.md)
{% 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.md)
{% 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"
	}
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://developers.velora.xyz/api/augustusrfq/api-references/fungible-tokens/create-a-p2p-limit-order.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.