@ritbit/v4-client-js 2.4.0 → 2.4.2

package/src/lib/validation.ts

@@ -1,197 +0,0 @@
-import { decode } from 'bech32';
-import Long from 'long';
-
-import { BECH32_PREFIX, MAX_SUBACCOUNT_NUMBER, MAX_UINT_32 } from '../clients/constants';
-import {
-  MsgTransfer,
-  OrderFlags,
-  ICancelOrder,
-  IPlaceOrder,
-  IBatchCancelOrder,
-} 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 validateBatchCancelOrderMessage validates that orders to batch cancel have fields that would be
- *  valid on-chain.
- */
-export function validateBatchCancelOrderMessage(
-  subaccountNumber: number,
-  orders: IBatchCancelOrder,
-): UserError | undefined {
-  for (const orderBatch of orders.shortTermOrders) {
-    for (const clientId of orderBatch.clientIds) {
-      if (!verifyNumberIsUint32(clientId)) {
-        return new UserError(`clientId: ${clientId} is not a valid uint32`);
-      }
-    }
-  }
-
-  if (!verifyGoodTilBlock(orders.goodTilBlock)) {
-    return new UserError(`goodTilBlock: ${orders.goodTilBlock} is not a valid uint32 or is 0`);
-  }
-
-  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: MsgTransfer): 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;
-}
-
-export function verifyOrderFlags(orderFlags: OrderFlags): boolean {
-  return (
-    orderFlags === OrderFlags.SHORT_TERM ||
-    orderFlags === OrderFlags.LONG_TERM ||
-    orderFlags === OrderFlags.CONDITIONAL
-  );
-}
-
-export 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 the BECH32 prefix and is Bech32 format.
-  return address.startsWith(BECH32_PREFIX + '1') && verifyIsBech32(address) === undefined;
-}

package/src/network_optimizer.ts

@@ -1,132 +0,0 @@
-import { IndexerClient } from './clients/indexer-client';
-import { ValidatorClient } from './clients/validator-client';
-import { encodeJson } from './lib/helpers';
-import { IndexerConfig, ValidatorConfig } from './types';
-
-class PingResponse {
-  public readonly height: number;
-  public readonly responseTime: Date;
-  public endpoint?: string;
-
-  constructor(height: number) {
-    this.height = height;
-    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, {
-              CHAINTOKEN_DENOM: 'placeholder',
-              CHAINTOKEN_DECIMALS: 18,
-              USDC_DENOM: 'uusdc',
-              USDC_DECIMALS: 6,
-            }),
-          ).catch((_) => undefined),
-        ),
-      )
-    ).filter(isTruthy);
-  }
-
-  private indexerClients(endpointUrls: string[]): IndexerClient[] {
-    return endpointUrls
-      .map(
-        (endpointUrl) =>
-          new IndexerClient(
-            // socket is not used for finding optimal indexer, but required as a parameter to the config
-            new IndexerConfig(
-              endpointUrl,
-              endpointUrl.replace('https://', 'wss://').replace('http://', 'ws://'),
-            ),
-          ),
-      )
-      .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.header.height);
-            return {
-              endpoint: client.config.restEndpoint,
-              height: response.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` or `maxHeight - 1`
-        .filter(({ height }) => height === maxHeight || height === maxHeight - 1)
-        // Return the endpoint with the fastest response time
-        .sort((a, b) => a.time - b.time)[0].endpoint
-    );
-  }
-
-  async findOptimalIndexer(endpointUrls: string[]): Promise<string> {
-    if (endpointUrls.length === 0) {
-      const errorResponse = {
-        error: {
-          message: 'No URL provided',
-        },
-      };
-      return encodeJson(errorResponse);
-    }
-    const clients = this.indexerClients(endpointUrls);
-    const responses = (
-      await Promise.all(
-        clients
-          .map(async (client) => {
-            const block = await client.utility.getHeight();
-            const response = new PingResponse(+block.height);
-            return {
-              endpoint: client.config.restEndpoint,
-              height: response.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` or `maxHeight - 1`
-        .filter(({ height }) => height === maxHeight || height === maxHeight - 1)
-        // Return the endpoint with the fastest response time
-        .sort((a, b) => a.time - b.time)[0].endpoint
-    );
-  }
-}

package/src/types.ts

@@ -1,44 +0,0 @@
-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,
-  PERPETUAL_PAIR_ETH_USD = 1,
-}

package/tasks.json

@@ -1,16 +0,0 @@
-{
-  // 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.base.json

@@ -1,21 +0,0 @@
-{
-  "extends": "./node_modules/@dydxprotocol/node-service-base-dev/tsconfig.json",
-  "exclude": [
-    "src/codegen/**/*.ts",
-    "__native__/*.js",
-    "__native__/__ios__/*.js",
-    "node_modules/@ritbit/v4-proto/**/bundle.ts"
-  ],
-  "include": [
-    "__tests__",
-    "examples",
-    "scripts",
-    "src",
-    "node_modules/@ritbit/v4-proto/**/**.ts"
-  ],
-  "compilerOptions": {
-    "noFallthroughCasesInSwitch": false,
-    "target": "ES2019",
-    "skipLibCheck": true
-  }
-}

package/tsconfig.cjs.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "build/cjs",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "declaration": false,
-    "skipLibCheck": true
-  }
-}

package/tsconfig.eslint.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.base.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.esm.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "build/esm",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "declaration": true,
-    "declarationMap": true,
-    "skipLibCheck": true
-  }
-}

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "./tsconfig.esm.json",
-  "compilerOptions": {
-    "noEmit": true
-  }
-}

package/webpack.config.js

@@ -1,56 +0,0 @@
-const path = require('path');
-
-const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
-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: {
-          loader: 'ts-loader',
-          options: {
-            configFile: 'tsconfig.cjs.json',
-          },
-        },
-      },
-    ],
-  },
-  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'),
-      util: require.resolve('util'),
-    },
-  },
-  plugins: [
-    new webpack.ProvidePlugin({
-      Buffer: ['buffer', 'Buffer'],
-    }),
-    new webpack.DefinePlugin({
-      process: {
-        env: {
-          NODE_ENV: JSON.stringify('production'),
-        },
-      },
-    }),
-    new NodePolyfillPlugin(),
-  ],
-};