@zoguxprotocol/client-js 0.2.0

package/src/lib/validation.ts

@@ -0,0 +1,197 @@
+import { decode } from 'bech32';
+import Long from 'long';
+
+import { MAX_SUBACCOUNT_NUMBER, MAX_UINT_32 } from '../clients/constants';
+import {
+  Transfer,
+  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: 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;
+}
+
+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 `zogux1` and is Bech32 format.
+  return address.startsWith('zogux1') && verifyIsBech32(address) === undefined;
+}

package/src/network_optimizer.ts

@@ -0,0 +1,132 @@
+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

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

@@ -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.base.json

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

package/tsconfig.cjs.json

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

package/tsconfig.eslint.json

@@ -0,0 +1,14 @@
+{
+  "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

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

package/webpack.config.js

@@ -0,0 +1,56 @@
+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(),
+  ],
+};