EVEDEX

https://docs.evedex.com
Admin
EVEDEX is a hybrid decentralized cryptocurrency exchange built on Arbitrum that provides perpetual...
Tokens:179,722
Snippets:1,186
Trust Score:8.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install exchange-bot-sdk dependency

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

Install the @evedex/exchange-bot-sdk package via npm. This is the first step after initializing an npm project.

```bash
npm i @evedex/exchange-bot-sdk --save
```

--------------------------------

### createLimitOrder method usage

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

Example of creating a signed limit order with take-profit and stop-loss settings.

```typescript
import { WebSocket } from "ws";
import {
  Environment,
  Container,
  type LimitOrderPayload,
  Side,
  TpSlType,
} from "@evedex/exchange-bot-sdk";

const config = {
  environment: Environment.DEV,
  centrifugeWebSocket: WebSocket,
  wallets: {
    myWallet: {
      privateKey: "your-private-key",
    },
  },
  apiKeys: {
    mainApiKey: {
      apiKey: "your-api-key",
    },
  },
};

const devContainer = new Container(config);
const walletAccount = devContainer.account("myWallet");
const limitOrderPayload: LimitOrderPayload = {
  instrument: "BTCUSDT",
  side: Side.Buy,
  leverage: 10,
  quantity: 0.01,
  limitPrice: 100000,
  tpsl: [
    {
      type: TpSlType.TakeProfit,
      side: Side.Buy,
      quantity: 0.01,
      price: 120000,
    },
    {
      type: TpSlType.StopLoss,
      side: Side.Buy,
      quantity: 0.01,
      price: 80000,
    },
  ],
};
const createLimitOrderResult = await walletAccount.createLimitOrder(limitOrderPayload);
```

```json
{
  "id": "a6f1c4e5-3b7d-42e6-b6b3-a4c65a6d43e6",
  "user": "67890",
  "instrument": "BTCUSDT",
  "side": "BUY",
  "type": "LIMIT",
  "quantity": 0.01,
  "cashQuantity": 0,
  "limitPrice": 100000,
  "stopPrice": null,
  "status": "NEW",
  "unFilledQuantity": 0.01,
  "filledAvgPrice": 0,
  "realizedPnL": 0,
  "fee": [
    {
      "coin": "USDT",
      "quantity": 10.0
    }
  ],
  "createdAt": "2022-01-01T12:00:00.000Z",
  "updatedAt": "2022-01-15T14:30:00.000Z",
  "triggeredAt": null,
  "group": "manually"
}
```

--------------------------------

### Full Evedex SDK Usage Example

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

A complete implementation demonstrating how to initialize the SDK, subscribe to market data, fetch account information, and manage orders using both wallet and API key accounts.

```typescript
import * as evedexSdk from "@evedex/exchange-bot-sdk";
import { AxiosError } from "axios";
import WebSocket from "ws";

const cfg = {
  centrifugeWebSocket: WebSocket,
  // your wallet private key
  wallets: { myWallet: { privateKey: "5b7..." } },
  // your api key
  apiKeys: { myApiKey: { apiKey: "GNL+Y/VgRj..." } },
};

const container = new evedexSdk.DemoContainer(cfg); // or ProdContainer
const gateway = container.gateway(); // for public api methods

const sampleMarketData = async () => {
  //let's subscribe to the order book update and print 1st value
  console.log("Subscribing to order book update");
  gateway.onOrderBookUpdate((o) => {
    console.log(o);
    gateway.unListenOrderBook("BTCUSDT:DEMO");
  });
  gateway.listenOrderBook("BTCUSDT:DEMO");

  //let's subscribe to the order book best update and print 1st value
  console.log("Subscribing to order book best update");
  gateway.onOrderBookBestUpdate((o) => {
    console.log(o);
    gateway.unListenOrderBookBest("BTCUSDT:DEMO");
  });
  gateway.listenOrderBookBest("BTCUSDT:DEMO");

  //let's fetch orderbook directly
  console.log(await gateway.fetchMarketDepth({ instrument: "BTCUSDT:DEMO", maxLevel: 10 }));

  //let's fetch instruments
  console.log(
    (await container.gateway().fetchInstrumentsWithMetrics()).find(
      (i) => i.name === "BTCUSDT:DEMO",
    ),
  );
  console.log(
    (await container.gateway().fetchInstruments()).find((i) => i.name === "BTCUSDT:DEMO"),
  );

  //lets fetch coins
  console.log((await gateway.fetchCoins()).find((c: any) => c.name === "BTC"));
  console.log(await gateway.fetchTrades({ instrument: "BTCUSDT:DEMO" }));
};

const sampleAccountData = async (account: evedexSdk.WalletAccount | evedexSdk.ApiKeyAccount) => {
  //show account info
  console.log(await account.fetchMe());
  const accountState = account.getBalance(); // for account ws callbacks and state
  // let's subscribe to account state metrics
  await accountState.listen(); //await is important here as it will wait till cache is populated
  console.log("Account metrics subscription done, getting state now:");

  // log current state from cache
  console.log(accountState.getOrderList().filter((o) => o.status === evedexSdk.OrderStatus.New));
  console.log(accountState.getFundingQuantity(evedexSdk.CollateralCurrency.USDT));
  console.log(accountState.getAvailableBalance());
  console.log(accountState.getPositionList());
  console.log(accountState.getTpSlList());
  console.log(accountState.getPower("BTCUSDT:DEMO"));

  //also we can fetch the same data from gateway directly
  console.log(await account.fetchOrders({ instrument: "BTCUSDT:DEMO" }));
  console.log(await account.fetchPositions());
  console.log(await account.fetchAvailableBalance());
  console.log(await account.fetchTpSlList({ instrument: "BTCUSDT:DEMO" }));

  //now let's attach callbacks to account updates to print new values
  console.log("Subscribing to account updates");
  accountState.onAccountUpdate((a) => console.info(a));
  accountState.onFundingUpdate((f) => console.info(f));
  accountState.onPositionUpdate((p) => console.info(p));
  accountState.onOrderUpdate((o) => console.info(o));
  accountState.onTpSlUpdate((t) => console.info(t));
};

const sampleOrders = async (account: evedexSdk.WalletAccount) => {
  // //this is how leverage is managed
  await account.updatePosition({ instrument: "BTCUSDT:DEMO", leverage: 20 });

  console.log("Placing limit order");
  const md = await gateway.fetchMarketDepth({ instrument: "BTCUSDT:DEMO", maxLevel: 1 });

  const limitOrder = {
    instrument: "BTCUSDT:DEMO",
    side: evedexSdk.Side.Buy,
    quantity: 0.001,
    limitPrice: md.bids[0].price - 500,
    leverage: 20,
  };
  const order = await account.createLimitOrder(limitOrder);
  console.info(`Order created: ${order.id}`);
  console.log("Cancelling limit order...");

  await account.cancelOrder({ orderId: order.id });
  try {
    //both queries will fail with 400 as order is already cancelled
    await account.massCancelUserOrders({ instrument: "BTCUSDT:DEMO" });
    await account.massCancelUserOrdersById({ orderIds: [order.id] });
  } catch (e: any) {
    if (e instanceof AxiosError) console.log(e.response?.data.error);
  }
};

const main = async () => {
  const account = await container.account("myWallet"); // for account methods
  const apiKeyAccount = await container.apiKeyAccount("myApiKey"); // for readonly account methods via api key
  console.log("Init done");

  await sampleMarketData();
  await sampleAccountData(apiKeyAccount); // or apiKeyAccount
  await sampleOrders(account); //order placements only for wallet account

  console.log("Done");
};

main().catch((e) => console.error(e));
```

--------------------------------

### Create SIWE Message and Signature for Authorization

Source: https://docs.evedex.com/developers/developers/authorization.md

Example of creating the SIWE message and signature for authorization. It fetches a nonce from GET /auth/nonce, builds the message, signs it with the user's wallet, and sends it to POST /auth/user/sign-up to receive a JWT token. Throws 'Invalid auth' if the response status is 400 or higher.

```typescript
function createSiweMessage(
  { address, uri, version, chainId, nonce, issuedAt }: {address: string, uri: string, version: string, chainId: number, nonce: string, issuedAt: string}
) {
  return `${uri} wants you to sign in with your Ethereum account:
${address}


URI: ${uri}
Version: ${version}
Chain ID: ${chainId}
Nonce: ${nonce}
Issued At: ${issuedAt}`;
}

const signer = await ethers.getSigner();
const message = `EVEDEX sign in`;
const address = await signer.getAddress();

const nonceRes = await fetch(`https://auth.evedex.com/auth/nonce`, {
  method: 'GET',
  headers: { accept: 'application/json' },
});
const { nonce } = await nonceRes.json();

const siweMessage = createSiweMessage({
  address: address,
  statement: `Sign in to https://exchange.evedex.com`,
  uri: 'https://exchange.evedex.com',
  version: '1',
  chainId: await signer.provider.getNetwork().then(({ chainId }) => chainId),
  nonce,
  issuedAt: new Date().toISOString(),
});
const signature = await signer.signMessage(siweMessage);

const response = await fetch(`https://auth.evedex.com/auth/user/sign-up`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    wallet: address,
    message: siweMessage,
    nonce,
    signature,
  }),
});
if (response.status >= 400) {
  throw new Error('Invalid auth');
}

const { token } = await response.json();
```

--------------------------------

### Initialize Balance and Listen

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

Demonstrates how to initialize the container, access a wallet account, and start listening for balance updates.

```typescript
import { WebSocket } from "ws";
import { Environment, Container } from "@evedex/exchange-bot-sdk";

const config = {
  environment: Environment.DEV,
  centrifugeWebSocket: WebSocket,
  wallets: {
    myWallet: {
      privateKey: "your-private-key",
    },
  },
  apiKeys: {
    mainApiKey: {
      apiKey: "your-api-key",
    },
  },
};

const devContainer = new Container(config);

const walletAccount = await devContainer.account("myWallet");

const balance = walletAccount.getBalance();

await balance.listen();
```

--------------------------------

### Configuration JSON Example

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

A sample JSON configuration structure for defining buy and sell power settings.

```json
{
  "buy": {
    "power": 1000
  },
  "sell": {
    "power": 2000
  }
}
```

--------------------------------

### Install ws package for Node.js

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

Install the 'ws' package to provide a WebSocket implementation for Node.js environments, required for initializing the container.

```bash
npm i ws --save
```

--------------------------------

### Balance sample: listen and fetch account data

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

Initialize a wallet account, get the Balance instance, listen for exchange events, and fetch cached and REST data like power and orders.

```typescript
import * as evedexSdk from "@evedex/exchange-bot-sdk";

const container = new evedexSdk.DemoContainer({
  centrifugeWebSocket: WebSocket,
  wallets: {
    baseAccount: {
      privateKey: "0x...",
    },
  },
});

const account = await container.account("baseAccount");

const balance = account.getBalance();

balance.listen();

console.log(balance.getPower("BTCUSDT:DEMO"));

console.log(await balance.fetchOrders({ instrument: "BTCUSDT:DEMO" }));

balance.onAccountUpdate((a) => console.info(a));
```

--------------------------------

### Perform HTTP GET request for documentation query

Source: https://docs.evedex.com/glossary.md

Use this HTTP GET request format to query the documentation. Replace <question> with your specific inquiry and <endgoal> with your broader objective.

```http
GET https://docs.evedex.com/glossary.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Query documentation with ask and goal parameters

Source: https://docs.evedex.com/developers

Query the documentation dynamically by performing an HTTP GET request on the current page URL with the `ask` query parameter and the optional `goal` query parameter. The response contains a direct answer and relevant excerpts and sources.

```http
GET https://docs.evedex.com/developers.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Example WebSocket payload for last candlestick

Source: https://docs.evedex.com/developers/developers/market_data.md

Example payload from the WebSocket feed, identical to the REST candle representation: timestamp, open, close, high, low, volumeUsd, and volume.

```text
[1763494975613, 93545.491, 93436.58650459, 93545.491, 93325.95, 2242.47807611016, 0.024]
```

--------------------------------

### GET https://docs.evedex.com/glossary.md?ask=<question>&goal=<end_goal>

Source: https://docs.evedex.com/llms.txt

Performs a documentation query using the 'ask' parameter to get a direct answer with relevant excerpts. The 'goal' parameter is optional and helps tailor the answer to the user's broader objective.

```APIDOC
## GET https://docs.evedex.com/glossary.md?ask=<question>&goal=<end_goal>

### Description
Performs a documentation query using the 'ask' parameter to get a direct answer with relevant excerpts and sources. The 'goal' parameter is optional and helps tailor the answer to the user's broader objective.

### Method
GET

### Endpoint
https://docs.evedex.com/glossary.md?ask=<question>&goal=<end_goal>

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question, specific and self-contained, written in natural language.
- **goal** (string) - Optional - The broader end goal the user is trying to accomplish, used to tailor the answer.

### Response
#### Success Response (200)
- **answer** (string) - Direct answer to the question.
- **excerpts** (array) - Relevant excerpts from the documentation.
- **sources** (array) - Sources of the excerpts.

#### Response Example
{
  "answer": "...",
  "excerpts": ["..."],
  "sources": ["..."]
}
```

--------------------------------

### Container.constructor(config: ContainerConfig)

Source: https://docs.evedex.com/developers/developers/exchange_bot_sdk.md

Initializes a new Container instance with the provided configuration, including environment, WebSocket implementation, wallets, and API keys.

```APIDOC
## Container.constructor(config: ContainerConfig)

### Description
Initializes a new Container instance with the provided configuration.

### Method
constructor

### Parameters
- **config** (ContainerConfig) - Required - Configuration object containing environment, centrifugeWebSocket, wallets, and apiKeys.

### Request Example
```typescript
import { WebSocket } from "ws";
import { Environment, Container } from "@evedex/exchange-bot-sdk";

const config = {
  environment: Environment.DEV,
  centrifugeWebSocket: WebSocket,
  wallets: {
    myWallet: {
      privateKey: "your-private-key",
    },
  },
  apiKeys: {
    mainApiKey: {
      apiKey: "your-api-key",
    },
  },
};

const devContainer = new Container(config);
```
```
Tokens:
Raw