@dydxprotocol/v4-client-js 0.30.0

package/src/lib/utils.ts

@@ -0,0 +1,36 @@
+import { MAX_UINT_32 } from '../clients/constants';
+
+/**
+ * Returns a random integer value between 0 and (n-1).
+ */
+export function randomInt(
+  n: number,
+): number {
+  return Math.floor(Math.random() * n);
+}
+
+/**
+ * Generate a random clientId.
+ */
+export function generateRandomClientId(): number {
+  return randomInt(MAX_UINT_32 + 1);
+}
+
+/**
+ * Deterministically generate a valid clientId from an arbitrary string by performing a
+ * quick hashing function on the string.
+ */
+export function clientIdFromString(
+  input: string,
+): number {
+  let hash: number = 0;
+  if (input.length === 0) return hash;
+  for (let i = 0; i < input.length; i++) {
+    hash = ((hash << 5) - hash) + input.charCodeAt(i); // eslint-disable-line no-bitwise
+    hash |= 0; // eslint-disable-line no-bitwise
+  }
+
+  // Bitwise operators covert the value to a 32-bit integer.
+  // We must coerce this into a 32-bit unsigned integer.
+  return hash + (2 ** 31);
+}

package/src/lib/validation.ts

@@ -0,0 +1,151 @@
+import { decode } from 'bech32';
+import Long from 'long';
+
+import { MAX_SUBACCOUNT_NUMBER, MAX_UINT_32 } from '../clients/constants';
+import {
+  Transfer,
+  OrderFlags,
+  ICancelOrder,
+  IPlaceOrder,
+} from '../clients/types';
+import { UserError } from './errors';
+
+/**
+ * @describe validatePlaceOrderMessage validates that an order to place has fields that would be
+ *  valid on-chain.
+ */
+export function validatePlaceOrderMessage(
+  subaccountNumber: number,
+  order: IPlaceOrder,
+): UserError | undefined {
+  if (!verifyNumberIsUint32(order.clientId)) {
+    return new UserError(`clientId: ${order.clientId} is not a valid uint32`);
+  }
+  if (order.quantums.lessThanOrEqual(Long.ZERO)) {
+    return new UserError(`quantums: ${order.quantums} cannot be <= 0`);
+  }
+  if (order.subticks.lessThanOrEqual(Long.ZERO)) {
+    return new UserError(`subticks: ${order.subticks} cannot be <= 0`);
+  }
+  if (!verifySubaccountNumber(subaccountNumber)) {
+    return new UserError(
+      `subaccountNumber: ${subaccountNumber} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`,
+    );
+  }
+  if (!isStatefulOrder(order.orderFlags) && !verifyGoodTilBlock(order.goodTilBlock)) {
+    return new UserError(`goodTilBlock: ${order.goodTilBlock} is not a valid uint32 or is 0`);
+  }
+  if (isStatefulOrder(order.orderFlags) && !verifyGoodTilBlockTime(order.goodTilBlockTime)) {
+    return new UserError(`goodTilBlockTime: ${order.goodTilBlockTime} is not a valid uint32 or is 0`);
+  }
+
+  return undefined;
+}
+
+/**
+ * @describe validateCancelOrderMessage validates that an order to cancel has fields that would be
+ *  valid on-chain.
+ */
+export function validateCancelOrderMessage(
+  subaccountNumber: number,
+  order: ICancelOrder,
+): UserError | undefined {
+  if (!verifyNumberIsUint32(order.clientId)) {
+    return new UserError(`clientId: ${order.clientId} is not a valid uint32`);
+  }
+  if (!isStatefulOrder(order.orderFlags) && !verifyGoodTilBlock(order.goodTilBlock)) {
+    return new UserError(`goodTilBlock: ${order.goodTilBlock} is not a valid uint32 or is 0`);
+  }
+  if (!isStatefulOrder(order.orderFlags) && order.goodTilBlockTime !== undefined) {
+    return new UserError(`goodTilBlockTime is ${order.goodTilBlockTime}, but should not be set for non-stateful orders`);
+  }
+  if (isStatefulOrder(order.orderFlags) && !verifyGoodTilBlockTime(order.goodTilBlockTime)) {
+    return new UserError(`goodTilBlockTime: ${order.goodTilBlockTime} is not a valid uint32 or is 0`);
+  }
+  if (isStatefulOrder(order.orderFlags) && order.goodTilBlock !== undefined) {
+    return new UserError(`goodTilBlock is ${order.goodTilBlock}, but should not be set for stateful orders`);
+  }
+  if (!verifySubaccountNumber(subaccountNumber)) {
+    return new UserError(
+      `subaccountNumber: ${subaccountNumber} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`,
+    );
+  }
+
+  return undefined;
+}
+
+/**
+ * @describe validateTransferMessage validates that a transfer to place has fields that would be
+ *  valid on-chain.
+ */
+export function validateTransferMessage(transfer: Transfer): UserError | undefined {
+  if (!verifySubaccountNumber(transfer.sender!!.number || 0)) {
+    return new UserError(
+      `senderSubaccountNumber: ${transfer.sender!!.number || 0} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`,
+    );
+  }
+  if (!verifySubaccountNumber(transfer.recipient!!.number || 0)) {
+    return new UserError(
+      `recipientSubaccountNumber: ${transfer.recipient!!.number || 0} cannot be < 0 or > ${MAX_SUBACCOUNT_NUMBER}`,
+    );
+  }
+  if (transfer.assetId !== 0) {
+    return new UserError(
+      `asset id: ${transfer.assetId} not supported`,
+    );
+  }
+  if (transfer.amount.lessThanOrEqual(Long.ZERO)) {
+    return new UserError(
+      `amount: ${transfer.amount} cannot be <= 0`,
+    );
+  }
+
+  const addressError: Error | undefined = verifyIsBech32(transfer.recipient!!.owner);
+  if (addressError !== undefined) {
+    return new UserError(addressError.toString());
+  }
+  return undefined;
+}
+
+function verifyGoodTilBlock(goodTilBlock: number | undefined): boolean {
+  if (goodTilBlock === undefined) {
+    return false;
+  }
+
+  return verifyNumberIsUint32(goodTilBlock) && goodTilBlock > 0;
+}
+
+function verifyGoodTilBlockTime(goodTilBlockTime: number | undefined): boolean {
+  if (goodTilBlockTime === undefined) {
+    return false;
+  }
+
+  return verifyNumberIsUint32(goodTilBlockTime) && goodTilBlockTime > 0;
+}
+
+function verifySubaccountNumber(subaccountNumber: number): boolean {
+  return subaccountNumber >= 0 && subaccountNumber <= MAX_SUBACCOUNT_NUMBER;
+}
+
+function verifyNumberIsUint32(num: number): boolean {
+  return num >= 0 && num <= MAX_UINT_32;
+}
+
+function isStatefulOrder(orderFlags: OrderFlags): boolean {
+  return orderFlags === OrderFlags.LONG_TERM || orderFlags === OrderFlags.CONDITIONAL;
+}
+
+function verifyIsBech32(address: string): Error | undefined {
+  try {
+    decode(address);
+  } catch (error) {
+    return error;
+  }
+
+  return undefined;
+}
+
+export function isValidAddress(address: string): boolean {
+  // An address is valid if it starts with `dydx1` and is Bech32 format.
+  return address.startsWith('dydx1') && (verifyIsBech32(address) === undefined);
+}

package/src/network_optimizer.ts

@@ -0,0 +1,70 @@
+import { Block } from '@cosmjs/stargate';
+
+import { ValidatorClient } from './clients/validator-client';
+import { encodeJson } from './lib/helpers';
+import { ValidatorConfig } from './types';
+
+class PingResponse {
+    public readonly block: Block;
+    public readonly responseTime: Date;
+    public endpoint?: string;
+
+    constructor(
+      block: Block,
+    ) {
+      this.block = block;
+      this.responseTime = new Date();
+    }
+}
+
+export const isTruthy = <T>(n?: T | false | null | undefined | 0): n is T => Boolean(n);
+
+export class NetworkOptimizer {
+  private async validatorClients(
+    endpointUrls: string[],
+    chainId: string,
+  ): Promise<ValidatorClient[]> {
+    return (await Promise.all(
+      endpointUrls.map((endpointUrl) => ValidatorClient.connect(
+        new ValidatorConfig(endpointUrl, chainId))
+        .catch((_) => undefined),
+      ),
+    )).filter(isTruthy);
+  }
+
+  async findOptimalNode(endpointUrls: string[], chainId: string): Promise<string> {
+    if (endpointUrls.length === 0) {
+      const errorResponse = {
+        error: {
+          message: 'No nodes provided',
+        },
+      };
+      return encodeJson(errorResponse);
+    }
+    const clients = await this.validatorClients(endpointUrls, chainId);
+    const responses = (await Promise.all(
+      clients
+        .map(async (client) => {
+          const block = await client.get.latestBlock();
+          const response = new PingResponse(block);
+          return {
+            endpoint: client.config.restEndpoint,
+            height: response.block.header.height,
+            time: response.responseTime.getTime(),
+          };
+        })
+        .map((promise) => promise.catch((_) => undefined)),
+    )).filter(isTruthy);
+
+    if (responses.length === 0) {
+      throw new Error('Could not connect to endpoints');
+    }
+    const maxHeight = Math.max(...responses.map(({ height }) => height));
+    return responses
+    // Only consider nodes at `maxHeight`
+      .filter(({ height }) => height === maxHeight)
+    // Return the endpoint with the fastest response time
+      .sort((a, b) => a.time - b.time)[0]
+      .endpoint;
+  }
+}

package/src/types.ts

@@ -0,0 +1,58 @@
+import { StdFee } from '@cosmjs/amino';
+import {
+  Method,
+} from '@cosmjs/tendermint-rpc';
+
+import { TransactionOptions } from './clients/types';
+
+export * from './clients/types';
+export * from './clients/constants';
+
+// How long to wait and how often to check when calling Broadcast with
+// Method.BroadcastTxCommit
+export interface BroadcastOptions {
+  broadcastPollIntervalMs: number;
+  broadcastTimeoutMs: number;
+}
+
+// Options for connecting to centralized APIs like indexer or faucet.
+export interface ApiOptions {
+  faucetHost?: string;
+  indexerHost?: string;
+  timeout?: number;
+}
+
+// Specify when a broadcast should return:
+// 1. Immediately
+// 2. Once the transaction is added to the memPool
+// 3. Once the transaction is committed to a block
+// See https://docs.cosmos.network/master/run-node/txs.html for more information
+export type BroadcastMode = (
+  Method.BroadcastTxAsync | Method.BroadcastTxSync | Method.BroadcastTxCommit
+);
+
+// Defines the options for a transaction.
+export interface Options {
+  transactionOptions?: TransactionOptions;
+  memo?: string;
+  broadcastMode?: BroadcastMode;
+  fee?: StdFee;
+}
+
+export enum ClobPairId {
+  PERPETUAL_PAIR_BTC_USD = 0,
+}
+
+export enum MarketId {
+  PERPETUAL_PRICE_BTC_USD = 0,
+}
+
+export enum PerpetualId {
+  PERPETUAL_BTC_USD = 0,
+}
+
+export interface FaucetRequest {
+  address: string;
+  subaccountNumber: number;
+  amount: number;
+}

package/tasks.json

@@ -0,0 +1,16 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "0.1.0",
+    "command": "npm",
+    "isShellCommand": true,
+    "showOutput": "always",
+    "suppressTaskName": true,
+    "tasks": [
+        {
+            "isBuildCommand": true,
+            "taskName": "build",
+            "args": ["run", "build"]
+        }
+    ]
+}

package/tsconfig.eslint.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "__native__/*.js",
+    "__native__/__ios__/*.js"
+  ],
+  "include": [
+    // Repeat included files from tsconfig.json.
+    "__tests__",
+    "examples",
+    "scripts",
+    "src",
+    // Include e.g. configuration files.
+    "./.*.js",
+    "./*.js"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./node_modules/@dydxprotocol/node-service-base-dev/tsconfig.json",
+  "exclude": [
+    "src/codegen/**/*.ts",
+    "__native__/*.js",
+    "__native__/__ios__/*.js"
+  ],
+  "include": [
+    "__tests__",
+    "examples",
+    "scripts",
+    "src", 
+    "codegen.js",
+    "node_modules/@dydxprotocol/dydxjs/**/**.ts"
+  ],
+  "compilerOptions": {
+    "outDir": "build",
+    "noFallthroughCasesInSwitch": false
+  }
+}

package/webpack.config.js

@@ -0,0 +1,48 @@
+const path = require('path');
+
+const webpack = require('webpack');
+
+module.exports = {
+  mode: 'development',
+  target: ['web', 'es5'], // Set the target to 'web' for browser environment
+  entry: './src/clients/native.ts',
+  devtool: 'source-map',
+  output: {
+    filename: 'v4-native-client.js',
+    path: path.resolve(__dirname, '__native__/__ios__'),
+    pathinfo: true,
+    libraryTarget: 'umd', // Set the libraryTarget to 'umd' for better compatibility
+    globalObject: 'this', // Ensure 'window' is not used in the UMD module for universal compatibility
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+    fallback: {
+      stream: require.resolve('stream-browserify'),
+      zlib: require.resolve('browserify-zlib'),
+      https: require.resolve('https-browserify'),
+      http: require.resolve('stream-http'),
+      path: require.resolve('path-browserify'),
+      crypto: require.resolve('crypto-browserify'),
+    },
+  },
+  plugins: [
+    new webpack.ProvidePlugin({
+      Buffer: ['buffer', 'Buffer'],
+    }),
+    new webpack.DefinePlugin({
+      process: {
+        env: {
+          NODE_ENV: JSON.stringify('production'),
+        },
+      },
+    }),
+  ],
+};