@ritbit/v4-client-js 1.3.17

package/examples/transfer_example_withdraw_other.ts

@@ -0,0 +1,60 @@
+import { EncodeObject } from '@cosmjs/proto-signing';
+import { Method } from '@cosmjs/tendermint-rpc';
+import Long from 'long';
+
+import { TEST_RECIPIENT_ADDRESS } from '../__tests__/helpers/constants';
+import { BECH32_PREFIX } from '../src';
+import { Network } from '../src/clients/constants';
+import LocalWallet from '../src/clients/modules/local-wallet';
+import { SubaccountInfo } from '../src/clients/subaccount';
+import { ValidatorClient } from '../src/clients/validator-client';
+import { DYDX_TEST_MNEMONIC } from './constants';
+
+async function test(): Promise<void> {
+  const wallet = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC, BECH32_PREFIX);
+  console.log(wallet);
+
+  const client = await ValidatorClient.connect(Network.testnet().validatorConfig);
+  console.log('**Client**');
+  console.log(client);
+
+  const subaccount = SubaccountInfo.forLocalWallet(wallet, 0);
+
+  const amount = new Long(100_000_000);
+
+  const msgs: Promise<EncodeObject[]> = new Promise((resolve) => {
+    const msg = client.post.composer.composeMsgWithdrawFromSubaccount(
+      subaccount.address,
+      subaccount.subaccountNumber,
+      0,
+      amount,
+      TEST_RECIPIENT_ADDRESS,
+    );
+
+    resolve([msg]);
+  });
+
+  const totalFee = await client.post.simulate(subaccount, () => msgs, undefined);
+  console.log('**Total Fee**');
+  console.log(totalFee);
+
+  const amountAfterFee = amount.sub(Long.fromString(totalFee.amount[0].amount));
+  console.log('**Amount after fee**');
+  console.log(amountAfterFee);
+
+  const tx = await client.post.withdraw(
+    subaccount,
+    0,
+    amountAfterFee,
+    TEST_RECIPIENT_ADDRESS,
+    Method.BroadcastTxCommit,
+  );
+  console.log('**Withdraw and Send**');
+  console.log(tx);
+}
+
+test()
+  .then(() => {})
+  .catch((error) => {
+    console.log(error.message);
+  });

package/examples/utility_endpoints.ts

@@ -0,0 +1,42 @@
+/**
+ * Simple JS example demostrating accessing public data with Indexer REST endpoints
+ */
+
+import { Network } from '../src/clients/constants';
+import { IndexerClient } from '../src/clients/indexer-client';
+
+async function test(): Promise<void> {
+  const client = new IndexerClient(Network.testnet().indexerConfig);
+
+  // Get indexer server time
+  try {
+    const response = await client.utility.getTime();
+    console.log(response);
+    const timeIso = response.iso;
+    const timeEpoch = response.epoch;
+    console.log('time');
+    console.log(timeIso);
+    console.log(timeEpoch);
+  } catch (error) {
+    console.log(error.message);
+  }
+
+  // Get indexer server height
+  try {
+    const response = await client.utility.getHeight();
+    console.log(response);
+    const height = response.height;
+    const heightTime = response.time;
+    console.log('height');
+    console.log(height);
+    console.log(heightTime);
+  } catch (error) {
+    console.log(error.message);
+  }
+}
+
+test()
+  .then(() => {})
+  .catch((error) => {
+    console.log(error.message);
+  });

package/examples/validator_get_example.ts

@@ -0,0 +1,160 @@
+import { Network } from '../src/clients/constants';
+import { ValidatorClient } from '../src/clients/validator-client';
+import { DYDX_TEST_ADDRESS } from './constants';
+
+async function test(): Promise<void> {
+  const client = await ValidatorClient.connect(Network.testnet().validatorConfig);
+
+  try {
+    const account = await client.get.getAccount(DYDX_TEST_ADDRESS);
+    console.log('Account');
+    console.log(JSON.stringify(account));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const coins = await client.get.getAccountBalances(DYDX_TEST_ADDRESS);
+    console.log('Balances');
+    console.log(JSON.stringify(coins));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const subaccounts = await client.get.getSubaccounts();
+    console.log('Subaccounts');
+    console.log(JSON.stringify(subaccounts));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const subaccount = await client.get.getSubaccount(DYDX_TEST_ADDRESS, 0);
+    console.log('Subaccount 0');
+    console.log(JSON.stringify(subaccount));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const subaccount = await client.get.getSubaccount(DYDX_TEST_ADDRESS, 1);
+    console.log('Subaccount 1');
+    console.log(JSON.stringify(subaccount));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const clobpairs = await client.get.getAllClobPairs();
+    console.log('Clobs');
+    console.log(JSON.stringify(clobpairs));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const prices = await client.get.getAllPrices();
+    console.log('Prices');
+    console.log(JSON.stringify(prices));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const feeTiers = await client.get.getFeeTiers();
+    console.log('Fee Tiers');
+    console.log(JSON.stringify(feeTiers));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const userfeeTier = await client.get.getUserFeeTier(DYDX_TEST_ADDRESS);
+    console.log('User Fee Tiers');
+    console.log(JSON.stringify(userfeeTier));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const userStats = await client.get.getUserStats(DYDX_TEST_ADDRESS);
+    console.log('User Fee Tiers');
+    console.log(JSON.stringify(userStats));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const equityTierLimitConfiguration = await client.get.getEquityTierLimitConfiguration();
+    console.log('Equity Tier Limit Configuration');
+    console.log(JSON.stringify(equityTierLimitConfiguration));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const rewardsParams = await client.get.getRewardsParams();
+    console.log('Rewards Params');
+    console.log(JSON.stringify(rewardsParams));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const delegations = await client.get.getDelegatorDelegations(DYDX_TEST_ADDRESS);
+    console.log('Delegations');
+    console.log(JSON.stringify(delegations));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const unbondingDelegations =
+      await client.get.getDelegatorUnbondingDelegations(DYDX_TEST_ADDRESS);
+    console.log('Unbonding Delegationss');
+    console.log(JSON.stringify(unbondingDelegations));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const delegationsTotalRewards =
+      await client.get.getDelegationTotalRewards(DYDX_TEST_ADDRESS);
+    console.log('Delegations total rewards');
+    console.log(JSON.stringify(delegationsTotalRewards));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const getAllBondedValidators = await client.get.getAllValidators('BOND_STATUS_BONDED');
+    console.log('All Validators');
+    console.log(JSON.stringify(getAllBondedValidators));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const delayedCompleteBridgeMessagesParams = await client.get.getDelayedCompleteBridgeMessages();
+    console.log('All delayed complete bridge messages');
+    console.log(JSON.stringify(delayedCompleteBridgeMessagesParams));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+
+  try {
+    const delayedCompleteBridgeMessagesParams =
+      await client.get.getDelayedCompleteBridgeMessages(DYDX_TEST_ADDRESS);
+    console.log('Filtered delayed complete bridge messages');
+    console.log(JSON.stringify(delayedCompleteBridgeMessagesParams));
+  } catch (error) {
+    console.log(JSON.stringify(error.message));
+  }
+}
+
+test()
+  .then(() => {})
+  .catch((error) => {
+    console.log(error.message);
+  });

package/examples/validator_post_example.ts

@@ -0,0 +1,81 @@
+import Long from 'long';
+import protobuf from 'protobufjs';
+
+import { BECH32_PREFIX } from '../src';
+import { Network } from '../src/clients/constants';
+import LocalWallet from '../src/clients/modules/local-wallet';
+import { SubaccountInfo } from '../src/clients/subaccount';
+import { IPlaceOrder } from '../src/clients/types';
+import { ValidatorClient } from '../src/clients/validator-client';
+import { randomInt } from '../src/lib/utils';
+import { DYDX_TEST_MNEMONIC, defaultOrder } from './constants';
+import ordersParams from './raw_orders.json';
+
+// Required for encoding and decoding queries that are of type Long.
+// Must be done once but since the individal modules should be usable
+// - must be set in each module that encounters encoding/decoding Longs.
+// Reference: https://github.com/protobufjs/protobuf.js/issues/921
+protobuf.util.Long = Long;
+protobuf.configure();
+
+function dummyOrder(height: number): IPlaceOrder {
+  const placeOrder = defaultOrder;
+  placeOrder.clientId = randomInt(1000000000);
+  placeOrder.goodTilBlock = height + 3;
+  return placeOrder;
+}
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function test(): Promise<void> {
+  const wallet = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC, BECH32_PREFIX);
+  console.log(wallet);
+
+  const client = await ValidatorClient.connect(Network.testnet().validatorConfig);
+  console.log('**Client**');
+  console.log(client);
+
+  const value1 = Long.fromNumber(400000000000);
+  console.log(value1.toString());
+
+  const subaccount = SubaccountInfo.forLocalWallet(wallet, 0);
+  for (const orderParams of ordersParams) {
+    const height = await client.get.latestBlockHeight();
+    const placeOrder = dummyOrder(height);
+
+    placeOrder.timeInForce = orderParams.timeInForce;
+    placeOrder.reduceOnly = false; // reduceOnly is currently disabled
+    placeOrder.orderFlags = orderParams.orderFlags;
+    placeOrder.side = orderParams.side;
+    placeOrder.quantums = Long.fromNumber(orderParams.quantums);
+    placeOrder.subticks = Long.fromNumber(orderParams.subticks);
+    try {
+      if (placeOrder.orderFlags !== 0) {
+        placeOrder.goodTilBlock = 0;
+        const now = new Date();
+        const millisecondsPerSecond = 1000;
+        const interval = 60 * millisecondsPerSecond;
+        const future = new Date(now.valueOf() + interval);
+        placeOrder.goodTilBlockTime = Math.round(future.getTime() / 1000);
+      } else {
+        placeOrder.goodTilBlockTime = 0;
+      }
+
+      const tx = await client.post.placeOrderObject(subaccount, placeOrder);
+      console.log('**Order Tx**');
+      console.log(tx);
+    } catch (error) {
+      console.log(error.message);
+    }
+
+    await sleep(5000); // wait for placeOrder to complete
+  }
+}
+
+test()
+  .then(() => {})
+  .catch((error) => {
+    console.log(error.message);
+  });

package/examples/wallet_address.ts

@@ -0,0 +1,18 @@
+import { BECH32_PREFIX } from '../src';
+import LocalWallet from '../src/clients/modules/local-wallet';
+import { DYDX_TEST_ADDRESS, DYDX_TEST_MNEMONIC } from './constants';
+
+async function test(): Promise<void> {
+  const wallet = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC, BECH32_PREFIX);
+  console.log(wallet);
+  const address = wallet.address;
+  const addressOk = address === DYDX_TEST_ADDRESS;
+  console.log(addressOk);
+  console.log(address);
+}
+
+test()
+  .then(() => {})
+  .catch((error) => {
+    console.log(error.message);
+  });

package/examples/websocket_example.ts

@@ -0,0 +1,44 @@
+import { Network } from '../src/clients/constants';
+import {
+  CandlesResolution,
+  IncomingMessageTypes,
+  SocketClient,
+} from '../src/clients/socket-client';
+import { DYDX_TEST_ADDRESS } from './constants';
+
+function test(): void {
+  const mySocket = new SocketClient(
+    Network.testnet().indexerConfig,
+    () => {
+      console.log('socket opened');
+    },
+    () => {
+      console.log('socket closed');
+    },
+    (message) => {
+      console.log(message);
+      if (typeof message.data === 'string') {
+        const jsonString = message.data as string;
+        try {
+          const data = JSON.parse(jsonString);
+          if (data.type === IncomingMessageTypes.CONNECTED) {
+            mySocket.subscribeToMarkets();
+            mySocket.subscribeToOrderbook('ETH-USD');
+            mySocket.subscribeToTrades('ETH-USD');
+            mySocket.subscribeToCandles('ETH-USD', CandlesResolution.FIFTEEN_MINUTES);
+            mySocket.subscribeToSubaccount(DYDX_TEST_ADDRESS, 0);
+          }
+          console.log(data);
+        } catch (e) {
+          console.error('Error parsing JSON message:', e);
+        }
+      }
+    },
+    (event) => {
+      console.error('Encountered error:', event.message);
+    },
+  );
+  mySocket.connect();
+}
+
+test();

package/examples/websocket_orderbook_example.ts

@@ -0,0 +1,239 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-param-reassign */
+import { Network } from '../src/clients/constants';
+import { SocketClient } from '../src/clients/socket-client';
+
+function test(): void {
+  let orderBookBidList: [number, number, number][] = [];
+  let orderBookAskList: [number, number, number][] = [];
+
+  const mySocket = new SocketClient(
+    Network.mainnet().indexerConfig,
+    () => {
+      console.log('socket opened');
+
+      mySocket.subscribeToOrderbook('ETH-USD');
+    },
+    () => {
+      console.log('socket closed');
+    },
+    (message) => {
+      try {
+        if (typeof message.data === 'string') {
+          const jsonString = message.data;
+          const parsingData = JSON.parse(jsonString);
+          const messageId = parsingData.message_id;
+          const orderBookDataList = parsingData.contents;
+
+          if (orderBookDataList instanceof Array) {
+            // common orderBook data;
+            [orderBookBidList, orderBookAskList] = updateOrderBook(
+              orderBookDataList,
+              orderBookBidList,
+              orderBookAskList,
+              messageId,
+            );
+
+            // sort
+            orderBookBidList = sortByNthElementDesc(orderBookBidList, 0);
+            orderBookAskList = sortByNthElementAsc(orderBookAskList, 0);
+
+            // resolving crossed orderBook
+            if (
+              orderBookBidList.length > 0 &&
+              orderBookAskList.length > 0 &&
+              orderBookBidList[0][0] >= orderBookAskList[0][0]
+            ) {
+              [orderBookBidList, orderBookAskList] = resolveCrossedOrderBook(
+                orderBookBidList,
+                orderBookAskList,
+              );
+            }
+
+            printOrderBook(orderBookBidList, orderBookAskList);
+
+            if (orderBookBidList.length > 300) {
+              orderBookBidList.splice(50);
+            }
+
+            if (orderBookAskList.length > 300) {
+              orderBookAskList.splice(50);
+            }
+          } else if (orderBookDataList !== null && orderBookDataList !== undefined) {
+            // initial OrderBook data
+            setInitialOrderBook(orderBookDataList, orderBookBidList, orderBookAskList, messageId);
+          }
+        }
+      } catch (e) {
+        console.error('Error parsing JSON message:', e);
+      }
+    },
+    (event) => {
+      console.error('Encountered error:', event.message);
+    },
+  );
+
+  mySocket.connect();
+}
+
+const sortByNthElementAsc = (
+  arr: [number, number, number][],
+  n: number,
+): [number, number, number][] => {
+  return arr.sort((a, b) => {
+    if (a[n] < b[n]) return -1;
+    if (a[n] > b[n]) return 1;
+    return 0;
+  });
+};
+const sortByNthElementDesc = (
+  arr: [number, number, number][],
+  n: number,
+): [number, number, number][] => {
+  return arr.sort((a, b) => {
+    if (a[n] > b[n]) return -1;
+    if (a[n] < b[n]) return 1;
+    return 0;
+  });
+};
+
+const printOrderBook = (
+  orderBookBidList: [number, number, number][],
+  orderBookAskList: [number, number, number][],
+): void => {
+  // print
+  console.log(`OrderBook for ETH-USD:`);
+  console.log(`Price     Qty`);
+  for (let i = 4; i > -1; i--) {
+    const priceStr = String(orderBookAskList[i][0]);
+    const spaces = createSpaces(10 - priceStr.length);
+    console.log(`${priceStr}${spaces}${orderBookAskList[i][1]}`);
+  }
+  console.log('---------------------');
+  for (let i = 0; i < 5; i++) {
+    const priceStr = String(orderBookBidList[i][0]);
+    const spaces = createSpaces(10 - priceStr.length);
+    console.log(`${priceStr}${spaces}${orderBookBidList[i][1]}`);
+  }
+  console.log('');
+};
+
+function createSpaces(count: number): string {
+  if (count <= 0) {
+    return '';
+  }
+
+  let spaces = '';
+  for (let i = 0; i < count; i++) {
+    spaces += ' ';
+  }
+  return spaces;
+}
+
+const resolveCrossedOrderBook = (
+  orderBookBidList: [number, number, number][],
+  orderBookAskList: [number, number, number][],
+): [[number, number, number][], [number, number, number][]] => {
+  while (orderBookBidList[0][0] >= orderBookAskList[0][0]) {
+    if (orderBookBidList[0][2] < orderBookAskList[0][2]) {
+      orderBookBidList.shift();
+    } else if (orderBookBidList[0][2] > orderBookAskList[0][2]) {
+      orderBookAskList.shift();
+    } else {
+      if (orderBookBidList[0][1] > orderBookAskList[0][1]) {
+        orderBookBidList[0][1] -= orderBookAskList[0][1];
+        orderBookAskList.shift();
+      } else if (orderBookBidList[0][1] < orderBookAskList[0][1]) {
+        orderBookAskList[0][1] -= orderBookBidList[0][1];
+        orderBookBidList.shift();
+      } else {
+        orderBookAskList.shift();
+        orderBookBidList.shift();
+      }
+    }
+  }
+
+  return [orderBookBidList, orderBookAskList];
+};
+const setInitialOrderBook = (
+  orderBookDataList: { bids: []; asks: [] },
+  orderBookBidList: [number, number, number][],
+  orderBookAskList: [number, number, number][],
+  messageId: number,
+): void => {
+  orderBookDataList.bids.forEach((item: { price: string; size: string }) => {
+    orderBookBidList.push([Number(item.price), Number(item.size), messageId]);
+  });
+
+  orderBookDataList.asks.forEach((item: { price: string; size: string }) => {
+    orderBookAskList.push([Number(item.price), Number(item.size), messageId]);
+  });
+};
+
+const updateOrderBook = (
+  orderBookDataList: { bids: [[]]; asks: [[]] }[],
+  orderBookBidList: [number, number, number][],
+  orderBookAskList: [number, number, number][],
+  messageId: number,
+): [[number, number, number][], [number, number, number][]] => {
+  orderBookDataList.forEach((entry: { bids: [[]]; asks: [[]] }) => {
+    if (entry.bids !== null && entry.bids !== undefined) {
+      const flattened = entry.bids.reduce((acc: any[], val: any[]) => acc.concat(val), []);
+      const entryBidPrice = Number(flattened[0]);
+      const entryBidSize = Number(flattened[1]);
+
+      // remove prices with zero Qty
+      if (entryBidSize === 0) {
+        for (let i = orderBookBidList.length - 1; i >= 0; i--) {
+          if (orderBookBidList[i][0] === entryBidPrice) {
+            orderBookBidList.splice(i, 1);
+          }
+        }
+      } else {
+        // The price that already exists in the order book is modified only Qty
+        if (orderBookBidList.some((innerArray) => innerArray[0] === entryBidPrice)) {
+          orderBookBidList.forEach((item, index) => {
+            if (item[0] === entryBidPrice) {
+              orderBookBidList[index][1] = entryBidSize;
+              orderBookBidList[index][2] = messageId;
+            }
+          });
+        } else {
+          // Add new data to order book
+          orderBookBidList.push([entryBidPrice, entryBidSize, messageId]);
+        }
+      }
+    }
+    if (entry.asks !== null && entry.asks !== undefined) {
+      const flattened = entry.asks.reduce((acc: any[], val: any[]) => acc.concat(val), []);
+      const entryAskPrice = Number(flattened[0]);
+      const entryAskSize = Number(flattened[1]);
+
+      if (entryAskSize === 0) {
+        // remove prices with zero Qty
+        for (let i = orderBookAskList.length - 1; i >= 0; i--) {
+          if (orderBookAskList[i][0] === entryAskPrice) {
+            orderBookAskList.splice(i, 1);
+          }
+        }
+      } else {
+        // The price that already exists in the order book is modified only Qty
+        if (orderBookAskList.some((innerArray) => innerArray[0] === entryAskPrice)) {
+          orderBookAskList.forEach((item, index) => {
+            if (item[0] === entryAskPrice) {
+              orderBookAskList[index][1] = entryAskSize;
+              orderBookAskList[index][2] = messageId;
+            }
+          });
+        } else {
+          // Add new data to order book
+          orderBookAskList.push([entryAskPrice, entryAskSize, messageId]);
+        }
+      }
+    }
+  });
+
+  return [orderBookBidList, orderBookAskList];
+};
+
+test();

package/jest.config.js

@@ -0,0 +1,12 @@
+// Use the base configuration as-is.
+exports = require('@dydxprotocol/node-service-base-dev/jest.config');
+
+module.exports = {
+  ...exports,
+  roots: ['<rootDir>/build/cjs/__tests__'],
+  testRegex: 'build/cjs/__tests__\\/.*\\.test\\.js$',
+  moduleNameMapper: {
+    '^axios$': require.resolve('axios'),
+  },
+  coveragePathIgnorePatterns: ['src/codegen/'],
+};

package/jest.globalSetup.js

@@ -0,0 +1,5 @@
+// This function runs once before all tests.
+module.exports = () => {
+  // eslint-disable-next-line
+  require('dotenv-flow').config();
+};

package/jest.setup.js

@@ -0,0 +1 @@
+// This file runs before each test file.