@ritbit/v4-client-js 1.3.17

package/__tests__/modules/client/ValidatorGetEndpoints.test.ts

@@ -0,0 +1,50 @@
+import { ValidatorClient } from '../../../src/clients/validator-client';
+import { Network } from '../../../src/clients/constants';
+import { DYDX_TEST_ADDRESS } from './constants';
+
+describe('Validator Client', () => {
+  let client: ValidatorClient;
+  describe('Get', () => {
+    beforeEach(async () => {
+      client = await ValidatorClient.connect(Network.testnet().validatorConfig);
+    });
+
+    it('Account', async () => {
+      const account = await client.get.getAccount(DYDX_TEST_ADDRESS);
+      expect(account.address).toBe(DYDX_TEST_ADDRESS);
+    });
+
+    it('Balance', async () => {
+      const balances = await client.get.getAccountBalances(DYDX_TEST_ADDRESS);
+      expect(balances).not.toBeUndefined();
+    });
+
+    it('All Subaccounts', async () => {
+      const subaccounts = await client.get.getSubaccounts();
+      expect(subaccounts.subaccount).not.toBeUndefined();
+    });
+
+    it('Subaccount', async () => {
+      const subaccount = await client.get.getSubaccount(DYDX_TEST_ADDRESS, 0);
+      expect(subaccount.subaccount).not.toBeUndefined();
+    });
+
+    it('Clob pairs', async () => {
+      const clobpairs = await client.get.getAllClobPairs();
+      expect(clobpairs.clobPair).not.toBeUndefined();
+      expect(clobpairs.clobPair[0].id).toBe(0);
+    });
+
+    it('Prices', async () => {
+      const prices = await client.get.getAllPrices();
+      expect(prices.marketPrices).not.toBeUndefined();
+      expect(prices.marketPrices[0].id).toBe(0);
+    });
+
+    it('Equity tier limit configuration', async () => {
+      const response = await client.get.getEquityTierLimitConfiguration();
+      expect(response.equityTierLimitConfig).not.toBeUndefined();
+      expect(response.equityTierLimitConfig?.shortTermOrderEquityTiers[0].limit).toBe(0);
+    });
+  });
+});

package/__tests__/modules/client/ValidatorPostEndpoints.test.ts

@@ -0,0 +1,52 @@
+import { Order_Side } from '@ritbit/v4-proto/src/codegen/ritbit/clob/order';
+
+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 '../../../examples/constants';
+import { BECH32_PREFIX } from '../../../src';
+
+function dummyOrder(height: number): IPlaceOrder {
+  const placeOrder = defaultOrder;
+  placeOrder.clientId = randomInt(1000000000);
+  placeOrder.goodTilBlock = height + 3;
+  // placeOrder.goodTilBlockTime = height + 3;
+  const random = randomInt(1000);
+  if (random % 2 === 0) {
+    placeOrder.side = Order_Side.SIDE_BUY;
+  } else {
+    placeOrder.side = Order_Side.SIDE_SELL;
+  }
+  return placeOrder;
+}
+
+describe('Validator Client', () => {
+  let wallet: LocalWallet;
+  let client: ValidatorClient;
+
+  describe('Post', () => {
+    beforeEach(async () => {
+      wallet = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC, BECH32_PREFIX);
+      client = await ValidatorClient.connect(Network.testnet().validatorConfig);
+    });
+
+    it('PlaceOrder', async () => {
+      console.log('**Client**');
+      console.log(client);
+      const address = wallet.address!;
+      const account = await client.get.getAccount(address);
+      console.log('**Account**');
+      console.log(account);
+      const height = await client.get.latestBlockHeight();
+      const subaccount = SubaccountInfo.forLocalWallet(wallet, 0);
+      const placeOrder = dummyOrder(height);
+      placeOrder.clientId = randomInt(1_000_000_000);
+      const tx = await client.post.placeOrderObject(subaccount, placeOrder);
+      console.log('**Order Tx**');
+      console.log(tx);
+    });
+  });
+});

package/__tests__/modules/client/constants.ts

@@ -0,0 +1,5 @@
+export const DYDX_TEST_ADDRESS = 'dydx14zzueazeh0hj67cghhf9jypslcf9sh2n5k6art';
+export const DYDX_TEST_PRIVATE_KEY =
+  'e92a6595c934c991d3b3e987ea9b3125bf61a076deab3a9cb519787b7b3e8d77';
+export const DYDX_TEST_MNEMONIC =
+  'mirror actor skill push coach wait confirm orchard lunch mobile athlete gossip awake miracle matter bus reopen team ladder lazy list timber render wait';

package/__tests__/modules/onboarding.test.ts

@@ -0,0 +1,66 @@
+import {
+  exportMnemonicAndPrivateKey,
+  deriveHDKeyFromEthereumSignature,
+} from '../../src/lib/onboarding';
+import {
+  DirectSecp256k1HdWallet,
+  DirectSecp256k1Wallet,
+  OfflineSigner,
+} from '@cosmjs/proto-signing';
+import {
+  MNEMONIC_FROM_SIGNATURE_RESULT,
+  ENTROPY_FROM_SIGNATURE_RESULT,
+  PRIVATE_KEY_FROM_SIGNATURE_RESULT,
+  PUBLIC_KEY_FROM_SIGNATURE_RESULT,
+  SIGNATURE_RESULT,
+} from '../helpers/constants';
+
+describe('Onboarding', () => {
+  describe('exportMnemonicAndPrivateKey', () => {
+    it('Successfully creates HDKey', () => {
+      expect(exportMnemonicAndPrivateKey(ENTROPY_FROM_SIGNATURE_RESULT)).toEqual({
+        mnemonic: MNEMONIC_FROM_SIGNATURE_RESULT,
+        privateKey: PRIVATE_KEY_FROM_SIGNATURE_RESULT,
+        publicKey: PUBLIC_KEY_FROM_SIGNATURE_RESULT,
+      });
+    });
+
+    it('Expect mnemonic and private key to generate the same address', async () => {
+      const { mnemonic, privateKey } = exportMnemonicAndPrivateKey(ENTROPY_FROM_SIGNATURE_RESULT);
+
+      const wallet: OfflineSigner = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic!, {
+        prefix: 'dydx',
+      });
+      const pkWallet = await DirectSecp256k1Wallet.fromKey(privateKey!, 'dydx');
+      const mnemonicAddress = (await wallet.getAccounts())[0].address;
+      const pkAddress = (await pkWallet.getAccounts())[0].address;
+      expect(mnemonicAddress).toEqual(pkAddress);
+    });
+  });
+
+  describe('deriveHDKeyFromEthereumSignature', () => {
+    it('Throw error if signature not valid', () => {
+      expect(() => deriveHDKeyFromEthereumSignature('0x04db21dfsa321b')).toThrow();
+    });
+    it('Successfully creates HDKey', () => {
+      expect(deriveHDKeyFromEthereumSignature(SIGNATURE_RESULT)).toEqual({
+        mnemonic: MNEMONIC_FROM_SIGNATURE_RESULT,
+        privateKey: PRIVATE_KEY_FROM_SIGNATURE_RESULT,
+        publicKey: PUBLIC_KEY_FROM_SIGNATURE_RESULT,
+      });
+    });
+
+    it('Successfully creates HDKey from signature with different v values', () => {
+      const suffixes = ['00', '1b', '01', '1c'];
+
+      const testSignatures = suffixes.map((suffix) => SIGNATURE_RESULT.slice(0, -2) + suffix);
+      testSignatures.forEach((sig) => {
+        expect(deriveHDKeyFromEthereumSignature(sig)).toEqual({
+          mnemonic: MNEMONIC_FROM_SIGNATURE_RESULT,
+          privateKey: PRIVATE_KEY_FROM_SIGNATURE_RESULT,
+          publicKey: PUBLIC_KEY_FROM_SIGNATURE_RESULT,
+        });
+      });
+    });
+  });
+});