@ritbit/v4-client-js 1.3.17

package/src/clients/modules/proto-includes.ts

@@ -0,0 +1,33 @@
+export * as GovV1Module from 'cosmjs-types/cosmos/gov/v1/query';
+export * as StatsModule from '@ritbit/v4-proto/src/codegen/ritbit/stats/query';
+
+export * as ClobModule from '@ritbit/v4-proto/src/codegen/ritbit/clob/query';
+export * as PerpetualsModule from '@ritbit/v4-proto/src/codegen/ritbit/perpetuals/query';
+export * as PricesModule from '@ritbit/v4-proto/src/codegen/ritbit/prices/query';
+export * as SubaccountsModule from '@ritbit/v4-proto/src/codegen/ritbit/subaccounts/query';
+export * as FeeTierModule from '@ritbit/v4-proto/src/codegen/ritbit/feetiers/query';
+export * as RateLimitModule from '@ritbit/v4-proto/src/codegen/ritbit/ratelimit/query';
+export * as RewardsModule from '@ritbit/v4-proto/src/codegen/ritbit/rewards/query';
+export * as StakingModule from 'cosmjs-types/cosmos/staking/v1beta1/query';
+export * as BridgeModule from '@ritbit/v4-proto/src/codegen/ritbit/bridge/query';
+export * as DistributionModule from 'cosmjs-types/cosmos/distribution/v1beta1/query';
+export * as AffiliateModule from '@ritbit/v4-proto/src/codegen/ritbit/affiliates/query';
+export * as VaultModule from '@ritbit/v4-proto/src/codegen/ritbit/vault/query';
+export * as ListingModule from '@ritbit/v4-proto/src/codegen/ritbit/listing/query';
+
+// Note: cosmos/base/abci is not available in cosmjs-types, keeping from v4-proto
+// export * from '@ritbit/v4-proto/src/codegen/cosmos/base/abci/v1beta1/abci';
+export { ProposalStatus } from 'cosmjs-types/cosmos/gov/v1/gov';
+export * from 'cosmjs-types/cosmos/gov/v1/gov';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/clob/order';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/clob/tx';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/delaymsg/tx';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/perpetuals/tx';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/prices/tx';
+export * from '@ritbit/v4-proto/src/codegen/google/protobuf/any';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/subaccounts/subaccount';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/sending/tx';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/sending/transfer';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/assets/genesis';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/assets/asset';
+export * from '@ritbit/v4-proto/src/codegen/ritbit/listing/tx';

package/src/clients/modules/rest.ts

@@ -0,0 +1,40 @@
+import axios, { AxiosInstance, AxiosProxyConfig } from 'axios';
+
+import { DEFAULT_API_TIMEOUT } from '../constants';
+import { generateQueryPath } from '../helpers/request-helpers';
+import { Response } from '../lib/axios';
+import { Data } from '../types';
+
+export default class RestClient {
+  readonly host: string;
+  readonly apiTimeout: Number;
+  readonly axiosInstance: AxiosInstance;
+
+  constructor(host: string, apiTimeout?: Number | null, proxy?: AxiosProxyConfig) {
+    if (host.endsWith('/')) {
+      this.host = host.slice(0, -1);
+    } else {
+      this.host = host;
+    }
+    this.apiTimeout = apiTimeout || DEFAULT_API_TIMEOUT;
+    this.axiosInstance = axios.create({
+      proxy,
+    });
+  }
+
+  async get(requestPath: string, params: {} = {}): Promise<Data> {
+    const url = `${this.host}${generateQueryPath(requestPath, params)}`;
+    const response = await this.axiosInstance.get(url);
+    return response.data;
+  }
+
+  async post(
+    requestPath: string,
+    params: {} = {},
+    body?: unknown | null,
+    headers: {} = {},
+  ): Promise<Response> {
+    const url = `${this.host}${generateQueryPath(requestPath, params)}`;
+    return this.axiosInstance.post(url, body, { headers });
+  }
+}

package/src/clients/modules/signer.ts

@@ -0,0 +1,139 @@
+import { Secp256k1Pubkey } from '@cosmjs/amino';
+import { fromBase64 } from '@cosmjs/encoding';
+import { Int53 } from '@cosmjs/math';
+import {
+  EncodeObject,
+  encodePubkey,
+  isOfflineDirectSigner,
+  makeAuthInfoBytes,
+  makeSignDoc,
+  OfflineSigner,
+} from '@cosmjs/proto-signing';
+import { SigningStargateClient, StdFee } from '@cosmjs/stargate';
+import { TxExtension } from '@ritbit/v4-proto/src/codegen/ritbit/accountplus/tx';
+import { TxBody, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { Any } from 'cosmjs-types/google/protobuf/any';
+import Long from 'long';
+import protobuf from 'protobufjs';
+
+import { generateRegistry } from '../lib/registry';
+import { TransactionOptions } from '../types';
+
+// Required for encoding and decoding queries that are of type Long.
+// Must be done once but since the individal modules should be usable
+// - must be set in each module that encounters encoding/decoding Longs.
+// Reference: https://github.com/protobufjs/protobuf.js/issues/921
+protobuf.util.Long = Long;
+protobuf.configure();
+
+export class TransactionSigner {
+  readonly address: string;
+  readonly stargateSigningClient: SigningStargateClient;
+  readonly offlineSigner: OfflineSigner;
+
+  constructor(
+    address: string,
+    stargateSigningClient: SigningStargateClient,
+    offlineSigner: OfflineSigner,
+  ) {
+    this.address = address;
+    this.stargateSigningClient = stargateSigningClient;
+    this.offlineSigner = offlineSigner;
+  }
+
+  /**
+   * @description Get the encoded signed transaction or the promise is rejected if
+   * no fee can be set for the transaction.
+   *
+   * @throws UserError if the fee is undefined.
+   * @returns The signed and encoded transaction.
+   */
+  async signTransaction(
+    messages: EncodeObject[],
+    transactionOptions: TransactionOptions,
+    fee?: StdFee,
+    memo: string = '',
+    publicKey?: Secp256k1Pubkey,
+  ): Promise<Uint8Array> {
+    if (!fee) {
+      throw new Error('Fee cannot be undefined');
+    }
+
+    const registry = generateRegistry();
+
+    // Encode the messages
+    const encodedMessages = messages.map((msg) => registry.encodeAsAny(msg));
+
+    // Encode the TxExtension message
+    const txExtension = TxExtension.encode({
+      selectedAuthenticators: transactionOptions.authenticators ?? [],
+    }).finish();
+
+    // Create the non-critical extension message
+    const nonCriticalExtensionOptions: Any[] = [
+      Any.fromPartial({
+        typeUrl: '/ritbit.accountplus.TxExtension',
+        value: txExtension,
+      }),
+    ];
+
+    // Construct the TxBody
+    const txBody: TxBody = TxBody.fromPartial({
+      messages: encodedMessages,
+      memo,
+      extensionOptions: [],
+      nonCriticalExtensionOptions,
+    });
+
+    // Encode the TxBody
+    const txBodyBytes = TxBody.encode(txBody).finish();
+
+    if (!publicKey) {
+      throw new Error('Public key cannot be undefined');
+    }
+    const pubkey = encodePubkey(publicKey); // Use the public key of the signer
+
+    const gasLimit = Int53.fromString(String(fee.gas)).toNumber();
+    const authInfoBytes = makeAuthInfoBytes(
+      [{ pubkey, sequence: transactionOptions.sequence }],
+      fee.amount,
+      gasLimit,
+      undefined,
+      undefined,
+    );
+
+    // Create the SignDoc
+    const signDoc = makeSignDoc(
+      txBodyBytes,
+      authInfoBytes,
+      transactionOptions.chainId,
+      transactionOptions.accountNumber,
+    );
+
+    // Use OfflineSigner to sign the transaction
+    const signerAddress = this.address;
+    if (isOfflineDirectSigner(this.offlineSigner)) {
+      const { signed, signature } = await this.offlineSigner.signDirect(signerAddress, signDoc);
+
+      const txRaw = TxRaw.fromPartial({
+        bodyBytes: signed.bodyBytes,
+        authInfoBytes: signed.authInfoBytes,
+        signatures: [fromBase64(signature.signature)],
+      });
+      return Uint8Array.from(TxRaw.encode(txRaw).finish());
+    } else {
+      const rawTx: TxRaw = await this.stargateSigningClient.sign(
+        this.address,
+        messages,
+        fee,
+        memo,
+        {
+          accountNumber: transactionOptions.accountNumber,
+          sequence: transactionOptions.sequence,
+          chainId: transactionOptions.chainId,
+        },
+      );
+      return Uint8Array.from(TxRaw.encode(rawTx).finish());
+    }
+  }
+}

package/src/clients/modules/tendermintClient.ts

@@ -0,0 +1,168 @@
+import { toHex } from '@cosmjs/encoding';
+import { Uint53 } from '@cosmjs/math';
+import { Block, TimeoutError, IndexedTx } from '@cosmjs/stargate';
+import {
+  Method,
+  Tendermint37Client,
+  toRfc3339WithNanoseconds,
+  tendermint37,
+} from '@cosmjs/tendermint-rpc';
+import { sleep } from '@cosmjs/utils';
+
+type Attribute = tendermint37.Attribute;
+type BlockResponse = tendermint37.BlockResponse;
+type BroadcastTxAsyncResponse = tendermint37.BroadcastTxAsyncResponse;
+type BroadcastTxSyncResponse = tendermint37.BroadcastTxSyncResponse;
+type TxResponse = tendermint37.TxResponse;
+type Event = tendermint37.Event;
+
+import { BroadcastErrorObject } from '../lib/errors';
+import { BroadcastMode, BroadcastOptions } from '../types';
+
+export class TendermintClient {
+  readonly baseClient: Tendermint37Client;
+  broadcastOptions: BroadcastOptions;
+
+  constructor(baseClient: Tendermint37Client, broadcastOptions: BroadcastOptions) {
+    this.baseClient = baseClient;
+    this.broadcastOptions = broadcastOptions;
+  }
+
+  /**
+   * @description Get a specific block if height is specified. Otherwise, get the most recent block.
+   *
+   * @returns Information about the block queried.
+   */
+  async getBlock(height?: number): Promise<Block> {
+    const response: BlockResponse = await this.baseClient.block(height);
+    return {
+      id: toHex(response.blockId.hash).toUpperCase(),
+      header: {
+        version: {
+          block: new Uint53(response.block.header.version.block).toString(),
+          app: new Uint53(response.block.header.version.app).toString(),
+        },
+        height: response.block.header.height,
+        chainId: response.block.header.chainId,
+        time: toRfc3339WithNanoseconds(response.block.header.time),
+      },
+      txs: response.block.txs,
+    };
+  }
+
+  /**
+   * @description Broadcast a signed transaction with a specific mode.
+   * @throws BroadcastErrorObject when result code is not zero. TypeError when mode is invalid.
+   * @returns Differs depending on the BroadcastMode used.
+   * See https://docs.cosmos.network/master/run-node/txs.html for more information.
+   */
+  async broadcastTransaction(
+    tx: Uint8Array,
+    mode: BroadcastMode,
+  ): Promise<BroadcastTxAsyncResponse | BroadcastTxSyncResponse | IndexedTx> {
+    switch (mode) {
+      case Method.BroadcastTxAsync:
+        return this.broadcastTransactionAsync(tx);
+      case Method.BroadcastTxSync:
+        return this.broadcastTransactionSync(tx);
+      case Method.BroadcastTxCommit:
+        return this.broadcastTransactionCommit(tx);
+      default:
+        throw new TypeError('broadcastTransaction: invalid BroadcastMode');
+    }
+  }
+
+  /**
+   * @description Broadcast a signed transaction.
+   * @returns The transaction hash.
+   */
+  broadcastTransactionAsync(tx: Uint8Array): Promise<BroadcastTxAsyncResponse> {
+    return this.baseClient.broadcastTxAsync({ tx });
+  }
+
+  /**
+   * @description Broadcast a signed transaction and await the response.
+   * @throws BroadcastErrorObject when result code is not zero.
+   * @returns The response from the node once the transaction is processed by `CheckTx`.
+   */
+  async broadcastTransactionSync(tx: Uint8Array): Promise<BroadcastTxSyncResponse> {
+    const result: BroadcastTxSyncResponse = await this.baseClient.broadcastTxSync({ tx });
+    if (result.code !== 0) {
+      throw new BroadcastErrorObject(`Broadcasting transaction failed: ${result.log}`, result);
+    }
+    return result;
+  }
+
+  /**
+   * @description Broadcast a signed transaction and await for it to be included in the blockchain.
+   * @throws BroadcastErrorObject when result code is not zero.
+   * @returns The result of the transaction once included in the blockchain.
+   */
+  async broadcastTransactionCommit(tx: Uint8Array): Promise<IndexedTx> {
+    const result: BroadcastTxSyncResponse = await this.broadcastTransactionSync(tx);
+    return this.queryHash(result.hash);
+  }
+
+  /**
+   * @description Using tx method, query for a transaction on-chain with retries specified by
+   * the client BroadcastOptions.
+   *
+   * @throws TimeoutError if the transaction is not committed on-chain within the timeout limit.
+   * @returns An indexed transaction containing information about the transaction when committed.
+   */
+  async queryHash(hash: Uint8Array, time: number = 0): Promise<IndexedTx> {
+    const now: number = Date.now();
+    const transactionId: string = toHex(hash).toUpperCase();
+
+    if (time >= this.broadcastOptions.broadcastTimeoutMs) {
+      throw new TimeoutError(
+        `Transaction with hash [${hash}] was submitted but was not yet found on the chain. You might want to check later. Query timed out after ${
+          this.broadcastOptions.broadcastTimeoutMs / 1000
+        } seconds.`,
+        transactionId,
+      );
+    }
+
+    await sleep(this.broadcastOptions.broadcastPollIntervalMs);
+
+    // If the transaction is not found, the tx method will throw an Internal Error.
+    try {
+      const tx: TxResponse = await this.baseClient.tx({ hash });
+
+      return {
+        height: tx.height,
+        hash: toHex(tx.hash).toUpperCase(),
+        code: tx.result.code,
+        rawLog: tx.result.log !== undefined ? tx.result.log : '',
+        tx: tx.tx,
+        txIndex: tx.index,
+        gasUsed: tx.result.gasUsed,
+        gasWanted: tx.result.gasWanted,
+        // Convert stargate events to tendermint events.
+        events: tx.result.events.map((event: Event) => {
+          return {
+            ...event,
+            attributes: event.attributes.map((attr: Attribute) => {
+              return {
+                ...attr,
+                key: Buffer.from(attr.key).toString(),
+                value: Buffer.from(attr.value).toString(),
+              };
+            }),
+          };
+        }),
+        // @ts-ignore
+        msgResponses: [],
+      };
+    } catch (error) {
+      return this.queryHash(hash, time + Date.now() - now);
+    }
+  }
+
+  /**
+   * @description Set the broadcast options for this module.
+   */
+  setBroadcastOptions(broadcastOptions: BroadcastOptions): void {
+    this.broadcastOptions = broadcastOptions;
+  }
+}

package/src/clients/modules/utility.ts

@@ -0,0 +1,47 @@
+import type {
+  ComplianceResponse,
+  ComplianceV2Response,
+  HeightResponse,
+  TimeResponse,
+} from '../types';
+import RestClient from './rest';
+
+export default class UtilityClient extends RestClient {
+  /**
+   * @description Get the current time of the Indexer
+   * @returns {TimeResponse} isoString and epoch
+   */
+  async getTime(): Promise<TimeResponse> {
+    const uri = '/v4/time';
+    return this.get(uri);
+  }
+
+  /**
+   * @description Get the block height of the most recent block processed by the Indexer
+   * @returns {HeightResponse} block height and time
+   */
+  async getHeight(): Promise<HeightResponse> {
+    const uri = '/v4/height';
+    return this.get(uri);
+  }
+
+  /**
+   * @description Screen an address to see if it is restricted
+   * @param {string} address evm or dydx address
+   * @returns {ComplianceResponse} whether the specified address is restricted
+   */
+  async screen(address: string): Promise<ComplianceResponse> {
+    const uri = '/v4/screen';
+    return this.get(uri, { address });
+  }
+
+  /**
+   * @description Screen an address to see if it is restricted
+   * @param {string} address evm or dydx address
+   * @returns {ComplianceResponse} whether the specified address is restricted
+   */
+  async complianceScreen(address: string): Promise<ComplianceV2Response> {
+    const uri = `/v4/compliance/screen/${address}`;
+    return this.get(uri);
+  }
+}

package/src/clients/modules/vault.ts

@@ -0,0 +1,23 @@
+import { PnlTickInterval } from '../constants';
+import { Data } from '../types';
+import RestClient from './rest';
+
+/**
+ * @description REST endpoints for data unrelated to a particular address.
+ */
+export default class VaultClient extends RestClient {
+  async getMegavaultHistoricalPnl(resolution?: PnlTickInterval | null): Promise<Data> {
+    const uri = '/v4/vault/v1/megavault/historicalPnl';
+    return this.get(uri, { resolution });
+  }
+
+  async getVaultsHistoricalPnl(resolution?: PnlTickInterval | null): Promise<Data> {
+    const uri = '/v4/vault/v1/vaults/historicalPnl';
+    return this.get(uri, { resolution });
+  }
+
+  async getMegavaultPositions(): Promise<Data> {
+    const uri = '/v4/vault/v1/megavault/positions';
+    return this.get(uri);
+  }
+}