@dydxprotocol/v4-client-js 0.30.0

package/__tests__/helpers/baseClients.ts

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+export class BaseTendermintClient {
+  async block(): Promise<void> {}
+  async broadcastTxSync(): Promise<void> {}
+  async broadcastTxAsync(): Promise<void> {}
+  async txSearchAll(): Promise<void> {}
+}
+
+export class BaseQueryClient {
+  tx = {
+    async simulate(): Promise<void> {},
+  };
+
+  async queryUnverified(): Promise<void> {}
+}
+
+export class BaseStargateSigningClient {
+  async sign(): Promise<void> {}
+}
+
+export class BaseWallet {
+  async getAccounts(): Promise<void> {}
+}

package/__tests__/helpers/constants.ts

@@ -0,0 +1,85 @@
+import Long from 'long';
+
+import { generateRandomClientId } from '../../src/lib/utils';
+import {
+  ClobPairId,
+  TransactionOptions,
+  ICancelOrder,
+  Transfer,
+  OrderFlags,
+  IPlaceOrder,
+  Order_Side,
+  Order_TimeInForce,
+} from '../../src/types';
+
+export const TEST_ADDRESS: string = 'dydx1vl9h9nkmau4e9v7tm30wekespu3d2qhd9404wa';
+export const TEST_RECIPIENT_ADDRESS: string = 'dydx1slanxj8x9ntk9knwa6cvfv2tzlsq5gk3dshml0';
+export const TEST_CHAIN_ID: string = 'dydxprotocol';
+export const TEST_HOST: string = 'http://localhost:26657';
+
+export const defaultTransactionOptions: TransactionOptions = {
+  accountNumber: 1,
+  sequence: 10,
+  chainId: TEST_CHAIN_ID,
+};
+
+// PlaceOrder variables
+export const defaultOrder: IPlaceOrder = {
+  clientId: 0,
+  orderFlags: OrderFlags.SHORT_TERM,
+  clobPairId: ClobPairId.PERPETUAL_PAIR_BTC_USD,
+  side: Order_Side.SIDE_BUY,
+  quantums: Long.fromNumber(10),
+  subticks: Long.fromNumber(100),
+  goodTilBlock: 10000,
+  timeInForce: Order_TimeInForce.TIME_IN_FORCE_UNSPECIFIED,
+  reduceOnly: false,
+  clientMetadata: 0,
+};
+
+// CancelOrder variables
+export const defaultCancelOrder: ICancelOrder = {
+  clientId: generateRandomClientId(),
+  orderFlags: OrderFlags.SHORT_TERM,
+  clobPairId: ClobPairId.PERPETUAL_PAIR_BTC_USD,
+  goodTilBlock: 4250,
+};
+
+// Transfer variables
+export const defaultTransfer: Transfer = {
+  sender: {
+    owner: TEST_ADDRESS,
+    number: 0,
+  },
+  recipient: {
+    owner: 'dydx14063jves4u9zhm7eja5ltf3t8zspxd92qnk23t',
+    number: 0,
+  },
+  assetId: 0,
+  amount: Long.fromNumber(1000),
+};
+
+// ------ Onboarding Constants ------ //
+// Base Signature Result
+export const SIGNATURE_RESULT = '0xf2006b4fc0afa08a6048b40d3d67e437ac2e20e6bacf3f947f9b33aa2756d204287f5fb2155bec067d879a25d7ddac791826cf28e2786919065e19848020f1531b';
+
+// Derived privateKeyBytes from Base Signature Result
+export const ENTROPY_FROM_SIGNATURE_RESULT: Uint8Array = new Uint8Array([
+  247, 183, 226, 106, 76, 125, 241, 35, 149, 75, 103, 180, 165, 243, 80, 128,
+  34, 20, 238, 201, 131, 180, 61, 76, 223, 179, 37, 211, 144, 197, 171, 251,
+]);
+
+// Derived HDKey privateKey from Base Signature Result
+export const PRIVATE_KEY_FROM_SIGNATURE_RESULT: Uint8Array = new Uint8Array([
+  14, 92, 178, 198, 64, 65, 27, 153, 11, 45, 118, 194, 71, 194, 10, 140, 145,
+  40, 203, 107, 231, 191, 138, 220, 168, 104, 28, 69, 58, 193, 203, 213,
+]);
+
+// Derived HDKey publicKey from Base Signature Result
+export const PUBLIC_KEY_FROM_SIGNATURE_RESULT: Uint8Array = new Uint8Array([
+  2, 204, 94, 45, 7, 83, 196, 55, 195, 107, 10, 35, 169, 32, 24, 37, 193, 196,
+  34, 210, 84, 26, 107, 89, 119, 240, 211, 63, 187, 34, 162, 197, 36,
+]);
+
+// Derived HDKey mnemonic from Base Signature Result
+export const MNEMONIC_FROM_SIGNATURE_RESULT = 'waste sample once ocean tenant mushroom festival hollow regret convince stage able candy jazz champion isolate diary group under entry decorate glare quiz job';

package/__tests__/lib/helpers.test.ts

@@ -0,0 +1,40 @@
+import { PartialTransactionOptions, TransactionOptions } from '../../src';
+import { DEFAULT_SEQUENCE } from '../../src/lib/constants';
+import { convertPartialTransactionOptionsToFull, stripHexPrefix } from '../../src/lib/helpers';
+import { defaultTransactionOptions } from '../helpers/constants';
+
+describe('helpers', () => {
+  describe('convertPartialTransactionOptionsToFull', () => it.each([
+    [
+      'partial transactionOptions',
+      {
+        accountNumber: defaultTransactionOptions.accountNumber,
+        chainId: defaultTransactionOptions.chainId,
+      },
+      { ...defaultTransactionOptions, sequence: DEFAULT_SEQUENCE },
+    ],
+    [
+      'undefined transactionOptions',
+      undefined,
+      undefined,
+    ],
+  ])('convertPartialTransactionOptionsToFull: %s', (
+    _name: string,
+    partialTransactionOptions: PartialTransactionOptions | undefined,
+    expectedResult: TransactionOptions | undefined,
+  ) => {
+    const transactionOptions: TransactionOptions | void = convertPartialTransactionOptionsToFull(
+      partialTransactionOptions,
+    );
+    expect(expectedResult).toEqual(transactionOptions);
+  }));
+
+  describe('stripHexPrefix', () => {
+    it('strips 0x prefix', () => {
+      expect(stripHexPrefix('0x123')).toEqual('123');
+    });
+    it('returns input if no prefix', () => {
+      expect(stripHexPrefix('10x23')).toEqual('10x23');
+    });
+  });
+});

package/__tests__/lib/util.test.ts

@@ -0,0 +1,83 @@
+import {
+  MAX_UINT_32,
+} from '../../src/lib/constants';
+import {
+  randomInt,
+  generateRandomClientId,
+  clientIdFromString,
+} from '../../src/lib/utils';
+
+describe('lib/util', () => {
+  describe('randomInt', () => {
+    it('random values', () => {
+      const maxValue: number = 9999;
+      let lastValue: number = 0;
+      for (let i = 0; i < 100; i++) {
+        const value: number = randomInt(maxValue);
+
+        // Within the expected bounds.
+        expect(value).toBeGreaterThanOrEqual(0);
+        expect(value).toBeLessThanOrEqual(maxValue);
+
+        // No collision.
+        expect(value).not.toEqual(lastValue);
+        lastValue = value;
+      }
+    });
+
+    it('zero', () => {
+      expect(randomInt(0)).toEqual(0);
+    });
+  });
+
+  describe('generateRandomClientId', () => {
+    it('random values', () => {
+      let lastValue: number = 0;
+      for (let i = 0; i < 100; i++) {
+        const value: number = generateRandomClientId();
+
+        // Within the expected bounds.
+        expect(value).toBeGreaterThanOrEqual(0);
+        expect(value).toBeLessThanOrEqual(MAX_UINT_32);
+
+        // No collision.
+        expect(value).not.toEqual(lastValue);
+        lastValue = value;
+      }
+    });
+  });
+
+  describe('clientIdFromString', () => {
+    it('hard-coded', () => {
+      expect(clientIdFromString('test')).toEqual(2151040146);
+    });
+
+    it('random values', () => {
+      let lastValue: number = 0;
+      let lastInput: number = 0;
+      for (let i = 0; i < 1000; i++) {
+        // Prevent input collision.
+        let input: number = randomInt(MAX_UINT_32);
+        if (input === lastInput) {
+          input += 1;
+        }
+
+        const value: number = clientIdFromString(`${input}`);
+        const valueAgain: number = clientIdFromString(`${input}`);
+
+        // Deterministic.
+        expect(value).toEqual(valueAgain);
+
+        // Within the expected bounds.
+        expect(value).toBeGreaterThanOrEqual(0);
+        expect(value).toBeLessThanOrEqual(MAX_UINT_32);
+
+        // No collision.
+        expect(value).not.toEqual(lastValue);
+        expect(value).not.toEqual(input);
+        lastValue = value;
+        lastInput = input;
+      }
+    });
+  });
+});

package/__tests__/lib/validation.test.ts

@@ -0,0 +1,244 @@
+import {
+  ICancelOrder,
+  IPlaceOrder,
+  OrderFlags,
+  Transfer,
+} from '../../src/types';
+import { MAX_SUBACCOUNT_NUMBER, MAX_UINT_32 } from '../../src/lib/constants';
+import { UserError } from '../../src/lib/errors';
+import {
+  isValidAddress,
+  validateCancelOrderMessage,
+  validatePlaceOrderMessage,
+  validateTransferMessage,
+} from '../../src/lib/validation';
+import {
+  TEST_ADDRESS, defaultCancelOrder, defaultOrder, defaultTransfer,
+} from '../helpers/constants';
+import Long from 'long';
+
+const MAX_UINT_32_PLUS_1: number = MAX_UINT_32 + 1;
+const MAX_SUBACCOUNT_NUMBER_PLUS_1: number = MAX_SUBACCOUNT_NUMBER + 1;
+
+describe('Validations', () => {
+  it.each([
+    ['valid', defaultOrder, undefined],
+    [
+      '0 value clientId',
+      { ...defaultOrder, clientId: 0 },
+      undefined,
+    ],
+    [
+      'underflow clientId',
+      { ...defaultOrder, clientId: -1 },
+      new UserError(`clientId: ${-1} is not a valid uint32`),
+    ],
+    [
+      'overflow clientId',
+      { ...defaultOrder, clientId: MAX_UINT_32_PLUS_1 },
+      new UserError(`clientId: ${MAX_UINT_32_PLUS_1} is not a valid uint32`),
+    ],
+    [
+      'underflow quantums',
+      { ...defaultOrder, quantums: Long.NEG_ONE },
+      new UserError(`quantums: ${-1} cannot be <= 0`),
+    ],
+    [
+      'underflow goodTilBlock',
+      { ...defaultOrder, goodTilBlock: -1 },
+      new UserError(`goodTilBlock: ${-1} is not a valid uint32 or is 0`),
+    ],
+    [
+      'overflow goodTilBlock',
+      { ...defaultOrder, goodTilBlock: MAX_UINT_32_PLUS_1 },
+      new UserError(`goodTilBlock: ${MAX_UINT_32_PLUS_1} is not a valid uint32 or is 0`),
+    ],
+    [
+      '0 goodTilBlock',
+      { ...defaultOrder, goodTilBlock: 0 },
+      new UserError(`goodTilBlock: ${0} is not a valid uint32 or is 0`),
+    ],
+    [
+      'underflow subticks',
+      { ...defaultOrder, subticks: Long.NEG_ONE },
+      new UserError(`subticks: ${-1} cannot be <= 0`),
+    ],
+  ])('Validate order: %s', (_name: string, order: IPlaceOrder, expectedError: UserError | undefined) => {
+    const validationError: UserError | void = validatePlaceOrderMessage(0, order);
+    expect(validationError).toEqual(expectedError);
+  });
+
+  it.each([
+    ['valid', defaultCancelOrder, undefined],
+    [
+      '0 value clientId',
+      { ...defaultCancelOrder, clientId: 0 },
+      undefined,
+    ],
+    [
+      'underflow clientId',
+      { ...defaultCancelOrder, clientId: -1 },
+      new UserError(`clientId: ${-1} is not a valid uint32`),
+    ],
+    [
+      'overflow clientId',
+      { ...defaultCancelOrder, clientId: MAX_UINT_32_PLUS_1 },
+      new UserError(`clientId: ${MAX_UINT_32_PLUS_1} is not a valid uint32`),
+    ],
+    [
+      'underflow goodTilBlock',
+      { ...defaultCancelOrder, goodTilBlock: -1 },
+      new UserError(`goodTilBlock: ${-1} is not a valid uint32 or is 0`),
+    ],
+    [
+      'overflow goodTilBlock',
+      { ...defaultCancelOrder, goodTilBlock: MAX_UINT_32_PLUS_1 },
+      new UserError(`goodTilBlock: ${MAX_UINT_32_PLUS_1} is not a valid uint32 or is 0`),
+    ],
+    [
+      '0 goodTilBlock',
+      { ...defaultCancelOrder, goodTilBlock: 0 },
+      new UserError(`goodTilBlock: ${0} is not a valid uint32 or is 0`),
+    ],
+    [
+      'contains GoodTilBlockTime',
+      { ...defaultCancelOrder, goodTilBlockTime: 10 },
+      new UserError('goodTilBlockTime is 10, but should not be set for non-stateful orders'),
+    ],
+    [
+      'stateful order - valid',
+      {
+        ...defaultCancelOrder,
+        orderFlags: OrderFlags.LONG_TERM,
+        goodTilBlock: undefined,
+        goodTilBlockTime: 10,
+      },
+      undefined,
+    ],
+    [
+      'stateful order - undefined goodTilBlockTime',
+      { ...defaultCancelOrder, orderFlags: OrderFlags.LONG_TERM },
+      new UserError(`goodTilBlockTime: ${undefined} is not a valid uint32 or is 0`),
+    ],
+    [
+      'stateful order - zero goodTilBlockTime',
+      { ...defaultCancelOrder, orderFlags: OrderFlags.LONG_TERM, goodTilBlockTime: 0 },
+      new UserError(`goodTilBlockTime: ${0} is not a valid uint32 or is 0`),
+    ],
+    [
+      'stateful order - underflow goodTilBlockTime',
+      { ...defaultCancelOrder, orderFlags: OrderFlags.LONG_TERM, goodTilBlockTime: -1 },
+      new UserError(`goodTilBlockTime: ${-1} is not a valid uint32 or is 0`),
+    ],
+    [
+      'stateful order - overflow goodTilBlockTime',
+      {
+        ...defaultCancelOrder,
+        orderFlags: OrderFlags.LONG_TERM,
+        goodTilBlockTime: MAX_UINT_32_PLUS_1,
+      },
+      new UserError(`goodTilBlockTime: ${MAX_UINT_32_PLUS_1} is not a valid uint32 or is 0`),
+    ],
+    [
+      'stateful order - has GoodTilBlock',
+      {
+        ...defaultCancelOrder,
+        orderFlags: OrderFlags.LONG_TERM,
+        goodTilBlock: 10,
+        goodTilBlockTime: 10,
+      },
+      new UserError('goodTilBlock is 10, but should not be set for stateful orders'),
+    ],
+  ])('Validate cancel order: %s', (_name: string, order: ICancelOrder, expectedError: UserError | undefined) => {
+    const validationError: UserError | void = validateCancelOrderMessage(0, order);
+    expect(validationError).toEqual(expectedError);
+  });
+
+  it.each([
+    ['valid', defaultTransfer, undefined],
+    [
+      'underflow senderSubaccountNumber',
+      { ...defaultTransfer, sender: { owner: TEST_ADDRESS, number: -1 } },
+      new UserError(`senderSubaccountNumber: ${-1} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`),
+    ],
+    [
+      'exceeds max subaccount number - senderSubaccountNumber',
+      { ...defaultTransfer, sender: { owner: TEST_ADDRESS, number: MAX_SUBACCOUNT_NUMBER_PLUS_1 } },
+      new UserError(
+        `senderSubaccountNumber: ${MAX_SUBACCOUNT_NUMBER_PLUS_1} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`,
+      ),
+    ],
+    [
+      '0 senderSubaccountNumber',
+      { ...defaultTransfer, sender: { owner: TEST_ADDRESS, number: 0 } },
+      undefined,
+    ],
+    [
+      'underflow recipientSubaccountNumber',
+      { ...defaultTransfer, recipient: { owner: TEST_ADDRESS, number: -1 } },
+      new UserError(`recipientSubaccountNumber: ${-1} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`),
+    ],
+    [
+      'exceeds max subaccount number - recipient.subaccountNumber',
+      {
+        ...defaultTransfer,
+        recipient: { owner: TEST_ADDRESS, number: MAX_SUBACCOUNT_NUMBER_PLUS_1 },
+      },
+      new UserError(
+        `recipientSubaccountNumber: ${MAX_SUBACCOUNT_NUMBER_PLUS_1} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`,
+      ),
+    ],
+    [
+      '0 recipientSubaccountNumber',
+      { ...defaultTransfer, recipient: { owner: TEST_ADDRESS, number: 0 } },
+      undefined,
+    ],
+    [
+      'non-zero asset id',
+      { ...defaultTransfer, assetId: 1 },
+      new UserError(`asset id: ${1} not supported`),
+    ],
+    [
+      '0 amount',
+      { ...defaultTransfer, amount: Long.ZERO },
+      new UserError(`amount: ${0} cannot be <= 0`),
+    ],
+    [
+      'too short recipientAddress',
+      {
+        ...defaultTransfer,
+        recipient: {
+          owner: 'dydx14063jves4u9zhm7eja5ltf3t8zspxd92qnk23',
+          number: 0,
+        },
+      },
+      new UserError('Error: Invalid checksum for dydx14063jves4u9zhm7eja5ltf3t8zspxd92qnk23'),
+    ],
+    [
+      'invalid recipientAddress',
+      {
+        ...defaultTransfer,
+        recipient: {
+          owner: 'fakeAddress1234',
+          number: 0,
+        },
+      },
+      new UserError('Error: Mixed-case string fakeAddress1234'),
+    ],
+  ])(
+    'Validate transfer: %s',
+    (_name: string, transfer: Transfer, expectedError: UserError | undefined) => {
+      const validationError: UserError | void = validateTransferMessage(transfer);
+      expect(validationError).toEqual(expectedError);
+    });
+
+  it.each([
+    ['valid', 'dydx17xpfvakm2amg962yls6f84z3kell8c5leqdyt2', true],
+    ['invalid: does not start with dydx1', 'dydx27xpfvakm2amg962yls6f84z3kell8c5leqdyt2', false],
+    ['invalid: too short', 'dydx17xpfvakm2amg962yls6f84z3kell8c5leqdyt', false],
+    ['invalid: too long', 'dydx17xpfvakm2amg962yls6f84z3kell8c5leqdyt2s', false],
+  ])('Validate address: %s', (_name: string, address: string, expectedResult: boolean) => {
+    const validationResult: boolean = isValidAddress(address);
+    expect(validationResult).toEqual(expectedResult);
+  });
+});

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

@@ -0,0 +1,106 @@
+import { Network } from '../../../src/clients/constants';
+import { IndexerClient } from '../../../src/clients/indexer-client';
+import { DYDX_TEST_ADDRESS } from './constants';
+
+describe('IndexerClient', () => {
+  const client = new IndexerClient(Network.staging().indexerConfig);
+
+  describe('Private Endpoints', () => {
+    it('Subaccounts', async () => {
+      const response = await client.account.getSubaccounts(DYDX_TEST_ADDRESS);
+      const subaccounts = response.subaccounts;
+      expect(subaccounts.size).not.toBeNull();
+      const subaccount0 = subaccounts[0];
+      const subaccountNumber = subaccount0.subaccountNumber;
+      expect(subaccountNumber).not.toBeNull();
+    });
+
+    it('Subaccount 0', async () => {
+      const response = await client.account.getSubaccount(DYDX_TEST_ADDRESS, 0);
+      const subaccount = response.subaccount;
+      expect(subaccount).not.toBeNull();
+      const subaccountNumber = subaccount.subaccountNumber;
+      expect(subaccountNumber).not.toBeNull();
+    });
+
+    it('Asset Positions', async () => {
+      const response = await client.account.getSubaccountAssetPositions(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const positions = response.positions;
+      expect(positions).not.toBeNull();
+      if (positions.length > 0) {
+        const position = positions[0];
+        expect(position).not.toBeNull();
+      }
+    });
+
+    it('Perpetual Positions', async () => {
+      const response = await client.account.getSubaccountPerpetualPositions(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const positions = response.positions;
+      expect(positions).not.toBeNull();
+      if (positions.length > 0) {
+        const position = positions[0];
+        expect(position).not.toBeNull();
+      }
+    });
+
+    it('Transfers', async () => {
+      const response = await client.account.getSubaccountTransfers(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const transfers = response.transfers;
+      expect(transfers).not.toBeNull();
+      if (transfers.length > 0) {
+        const transfer = transfers[0];
+        expect(transfer).not.toBeNull();
+      }
+    });
+
+    it('Orders', async () => {
+      const response = await client.account.getSubaccountOrders(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const orders = response;
+      expect(orders).not.toBeNull();
+      if (orders.length > 0) {
+        const order = orders[0];
+        expect(order).not.toBeNull();
+      }
+    });
+
+    it('Fills', async () => {
+      const response = await client.account.getSubaccountFills(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const fills = response.fills;
+      expect(fills).not.toBeNull();
+      if (fills.length > 0) {
+        const fill = fills[0];
+        expect(fill).not.toBeNull();
+      }
+    });
+
+    /*
+    ** Funding endpoint is not implemented in the indexer yet
+    it('Funding', async () => {
+      const response = await client.account.getSubaccountFunding(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const funding = response.funding;
+      expect(funding).not.toBeNull();
+      if (funding.length > 0) {
+        const funding0 = funding[0];
+        expect(funding0).not.toBeNull();
+      }
+    });
+    */
+
+    it('Historical PNL', async () => {
+      const response = await client.account.getSubaccountHistoricalPNLs(DYDX_TEST_ADDRESS, 0);
+      expect(response).not.toBeNull();
+      const historicalPnl = response.historicalPnl;
+      expect(historicalPnl).not.toBeNull();
+      if (historicalPnl.length > 0) {
+        const historicalPnl0 = historicalPnl[0];
+        expect(historicalPnl0).not.toBeNull();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,14 @@
+import { FaucetApiHost } from '../../../src/clients/constants';
+import { FaucetClient } from '../../../src/clients/faucet-client';
+import { DYDX_TEST_ADDRESS } from './constants';
+
+describe('FaucetClient', () => {
+  const client = new FaucetClient(FaucetApiHost.STAGING);
+
+  describe('Faucet Endpoints', () => {
+    it('Fill', async () => {
+      const response = await client.fill(DYDX_TEST_ADDRESS, 0, 2000);
+      expect(response?.status).toBe(202);
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+import { Network } from '../../../src/clients/constants';
+import { IndexerClient } from '../../../src/clients/indexer-client';
+
+// ------------ Markets ------------
+export const MARKET_BTC_USD: string = 'BTC-USD';
+
+describe('IndexerClient', () => {
+  const client = new IndexerClient(Network.staging().indexerConfig);
+
+  describe('Public Endpoints', () => {
+    it('Indexer time', async () => {
+      const response = await client.markets.getTime();
+      const iso = response.iso;
+      expect(iso).not.toBeUndefined();
+    });
+
+    it('Indexer height', async () => {
+      const response = await client.markets.getHeight();
+      const height = response.height;
+      const time = response.time;
+      expect(height).not.toBeUndefined();
+      expect(time).not.toBeUndefined();
+    });
+
+    it('Markets', async () => {
+      const response = await client.markets.getPerpetualMarkets();
+      const btc = response.markets[MARKET_BTC_USD];
+      const status = btc.status;
+      expect(status).toBe('ACTIVE');
+    });
+
+    it('BTC Market', async () => {
+      const response = await client.markets.getPerpetualMarkets(MARKET_BTC_USD);
+      const btc = response.markets[MARKET_BTC_USD];
+      const status = btc.status;
+      expect(status).toBe('ACTIVE');
+    });
+
+    it('BTC Trades', async () => {
+      const response = await client.markets.getPerpetualMarketTrades(MARKET_BTC_USD);
+      const trades = response.trades;
+      expect(trades).not.toBeUndefined();
+    });
+
+    it('BTC Orderbook', async () => {
+      const response = await client.markets.getPerpetualMarketOrderbook(MARKET_BTC_USD);
+      const asks = response.asks;
+      const bids = response.bids;
+      expect(asks).not.toBeUndefined();
+      expect(bids).not.toBeUndefined();
+    });
+
+    it('BTC Candles', async () => {
+      const response = await client.markets.getPerpetualMarketCandles(MARKET_BTC_USD, '1MIN');
+      const candles = response.candles;
+      expect(candles).not.toBeUndefined();
+    });
+
+    it('BTC Historical Funding', async () => {
+      const response = await client.markets.getPerpetualMarketHistoricalFunding(MARKET_BTC_USD);
+      expect(response).not.toBeNull();
+      const historicalFunding = response.historicalFunding;
+      expect(historicalFunding).not.toBeNull();
+      if (historicalFunding.length > 0) {
+        const historicalFunding0 = historicalFunding[0];
+        expect(historicalFunding0).not.toBeNull();
+      }
+    });
+
+    it('Sparklines', async () => {
+      const response = await client.markets.getPerpetualMarketSparklines();
+      const btcSparklines = response[MARKET_BTC_USD];
+      expect(btcSparklines).not.toBeUndefined();
+    });
+  });
+});