@ritbit/v4-client-js 1.3.17

package/src/clients/constants.ts

@@ -0,0 +1,358 @@
+import { PageRequest } from '@ritbit/v4-proto/src/codegen/cosmos/base/query/v1beta1/pagination';
+import { AxiosProxyConfig } from 'axios';
+import Long from 'long';
+
+import { BroadcastOptions, DenomConfig } from './types';
+
+export * from '../lib/constants';
+
+/**
+ * Disclaimer: Note that as of the date hereof, the testnet and RITBIT Chain deployment are the only known deployments of the 
+ * RITBIT Chain software, and other deployment options may be added.
+ */
+
+// Chain ID
+export const DEV_CHAIN_ID = 'ritbit-local';
+export const STAGING_CHAIN_ID = 'ritbit-testnet';
+export const TESTNET_CHAIN_ID = 'ritbit-testnet';
+export const LOCAL_CHAIN_ID = 'ritbit-local';
+export const MAINNET_CHAIN_ID = 'ritbit-mainnet';
+
+// ------------ API URLs ------------
+export enum IndexerApiHost {
+  TESTNET = 'https://indexer.testnet.ritbit.trade/',
+  STAGING = 'https://indexer.testnet.ritbit.trade/',
+  LOCAL = 'http://local.ritbit.ru:3002',
+  MAINNET = 'https://indexer.ritbit.trade',
+}
+
+export enum IndexerWSHost {
+  TESTNET = 'wss://indexer.testnet.ritbit.trade/v4/ws',
+  STAGING = 'wss://indexer.testnet.ritbit.trade/v4/ws',
+  LOCAL = 'ws://local.ritbit.ru:3003',
+  MAINNET = 'wss://indexer.ritbit.trade/v4/ws',
+}
+
+export enum FaucetApiHost {
+  TESTNET = 'https://faucet.testnet.ritbit.trade',
+}
+
+export enum ValidatorApiHost {
+  TESTNET = 'https://validator.testnet.ritbit.trade',
+  STAGING = 'https://validator.testnet.ritbit.trade',
+  LOCAL = 'http://local.ritbit.ru:26657',
+  MAINNET = 'https://validator.ritbit.trade',
+}
+
+// ------------ Network IDs ------------
+
+export enum NetworkId {
+  TESTNET = 'ritbit-testnet',
+  MAINNET = 'ritbit-mainnet',
+}
+export const NETWORK_ID_TESTNET: string = 'ritbit-testnet';
+export const NETWORK_ID_MAINNET: string = 'ritbit-mainnet';
+
+// ------------ Gas Denoms ------------
+export enum SelectedGasDenom {
+  NATIVE = 'NATIVE',
+  USDC = 'USDC',
+}
+
+// ------------ MsgType URLs ------------
+// Default CosmosSDK
+// x/bank
+export const TYPE_URL_MSG_SEND = '/cosmos.bank.v1beta1.MsgSend';
+
+// x/gov
+export const TYPE_URL_MSG_SUBMIT_PROPOSAL = '/cosmos.gov.v1.MsgSubmitProposal';
+
+// x/clob
+export const TYPE_URL_MSG_PLACE_ORDER = '/ritbit.clob.MsgPlaceOrder';
+export const TYPE_URL_MSG_CANCEL_ORDER = '/ritbit.clob.MsgCancelOrder';
+export const TYPE_URL_BATCH_CANCEL = '/ritbit.clob.MsgBatchCancel';
+export const TYPE_URL_MSG_CREATE_CLOB_PAIR = '/ritbit.clob.MsgCreateClobPair';
+export const TYPE_URL_MSG_UPDATE_CLOB_PAIR = '/ritbit.clob.MsgUpdateClobPair';
+
+// x/delaymsg
+export const TYPE_URL_MSG_DELAY_MESSAGE = '/ritbit.delaymsg.MsgDelayMessage';
+
+// x/listing
+export const TYPE_URL_MSG_CREATE_MARKET_PERMISSIONLESS =
+  '/ritbit.listing.MsgCreateMarketPermissionless';
+
+// x/perpetuals
+export const TYPE_URL_MSG_CREATE_PERPETUAL = '/ritbit.perpetuals.MsgCreatePerpetual';
+
+// x/prices
+export const TYPE_URL_MSG_CREATE_ORACLE_MARKET = '/ritbit.prices.MsgCreateOracleMarket';
+
+// x/sending
+export const TYPE_URL_MSG_CREATE_TRANSFER = '/ritbit.sending.MsgCreateTransfer';
+export const TYPE_URL_MSG_WITHDRAW_FROM_SUBACCOUNT =
+  '/ritbit.sending.MsgWithdrawFromSubaccount';
+export const TYPE_URL_MSG_DEPOSIT_TO_SUBACCOUNT = '/ritbit.sending.MsgDepositToSubaccount';
+
+// x/affiliates
+export const TYPE_URL_MSG_REGISTER_AFFILIATE = '/ritbit.affiliates.MsgRegisterAffiliate';
+
+// x/vault
+export const TYPE_URL_MSG_DEPOSIT_TO_MEGAVAULT = '/ritbit.vault.MsgDepositToMegavault';
+export const TYPE_URL_MSG_WITHDRAW_FROM_MEGAVAULT = '/ritbit.vault.MsgWithdrawFromMegavault';
+
+// x/staking
+export const TYPE_URL_MSG_DELEGATE = '/cosmos.staking.v1beta1.MsgDelegate';
+export const TYPE_URL_MSG_UNDELEGATE = '/cosmos.staking.v1beta1.MsgUndelegate';
+
+// x/distribution
+export const TYPE_URL_MSG_WITHDRAW_DELEGATOR_REWARD =
+  '/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward';
+
+// x/accountplus
+export const TYPE_URL_MSG_ADD_AUTHENTICATOR = '/ritbit.accountplus.MsgAddAuthenticator';
+export const TYPE_URL_MSG_REMOVE_AUTHENTICATOR = '/ritbit.accountplus.MsgRemoveAuthenticator';
+
+// ------------ Chain Constants ------------
+// The following are same across different networks / deployments.
+export const GOV_MODULE_ADDRESS = 'rit10d07y265gmmuvt4z0w9aw880jnsr700j086rvs';
+export const DELAYMSG_MODULE_ADDRESS = 'rit1mkkvp26dngu6n8rmalaxyp3gwkjuzztqg7pc3h';
+export const MEGAVAULT_MODULE_ADDRESS = 'rit18tkxrnrkqc2t0lr3zxr5g6a4hdvqksyl6u4m0h';
+
+// ------------ Market Statistic Day Types ------------
+export enum MarketStatisticDay {
+  ONE = '1',
+  SEVEN = '7',
+  THIRTY = '30',
+}
+
+// ------------ Order Types ------------
+// This should match OrderType in Abacus
+export enum OrderType {
+  LIMIT = 'LIMIT',
+  MARKET = 'MARKET',
+  STOP_LIMIT = 'STOP_LIMIT',
+  TAKE_PROFIT_LIMIT = 'TAKE_PROFIT',
+  STOP_MARKET = 'STOP_MARKET',
+  TAKE_PROFIT_MARKET = 'TAKE_PROFIT_MARKET',
+}
+
+// ------------ Order Side ------------
+// This should match OrderSide in Abacus
+export enum OrderSide {
+  BUY = 'BUY',
+  SELL = 'SELL',
+}
+
+// ------------ Order TimeInForce ------------
+// This should match OrderTimeInForce in Abacus
+export enum OrderTimeInForce {
+  GTT = 'GTT',
+  IOC = 'IOC',
+  FOK = 'FOK',
+}
+
+// ------------ Order Execution ------------
+// This should match OrderExecution in Abacus
+export enum OrderExecution {
+  DEFAULT = 'DEFAULT',
+  IOC = 'IOC',
+  FOK = 'FOK',
+  POST_ONLY = 'POST_ONLY',
+}
+
+// ------------ Order Status ------------
+// This should match OrderStatus in Abacus
+export enum OrderStatus {
+  BEST_EFFORT_OPENED = 'BEST_EFFORT_OPENED',
+  OPEN = 'OPEN',
+  FILLED = 'FILLED',
+  BEST_EFFORT_CANCELED = 'BEST_EFFORT_CANCELED',
+  CANCELED = 'CANCELED',
+}
+
+export enum TickerType {
+  PERPETUAL = 'PERPETUAL', // Only PERPETUAL is supported right now
+}
+
+export enum PositionStatus {
+  OPEN = 'OPEN',
+  CLOSED = 'CLOSED',
+  LIQUIDATED = 'LIQUIDATED',
+}
+
+// ----------- Time Period for Sparklines -------------
+
+export enum TimePeriod {
+  ONE_DAY = 'ONE_DAY',
+  SEVEN_DAYS = 'SEVEN_DAYS',
+}
+
+export enum PnlTickInterval {
+  HOUR = 'hour',
+  day = 'day',
+}
+
+// ----------- Authenticators -------------
+
+export enum AuthenticatorType {
+  ALL_OF = 'AllOf',
+  ANY_OF = 'AnyOf',
+  SIGNATURE_VERIFICATION = 'SignatureVerification',
+  MESSAGE_FILTER = 'MessageFilter',
+  CLOB_PAIR_ID_FILTER = 'ClobPairIdFilter',
+  SUBACCOUNT_FILTER = 'SubaccountFilter',
+}
+
+export interface Authenticator {
+  type: AuthenticatorType;
+  config: string | Authenticator[];
+}
+
+export enum TradingRewardAggregationPeriod {
+  DAILY = 'DAILY',
+  WEEKLY = 'WEEKLY',
+  MONTHLY = 'MONTHLY',
+}
+
+// ------------ API Defaults ------------
+export const DEFAULT_API_TIMEOUT: number = 3_000;
+
+export const MAX_MEMO_CHARACTERS: number = 256;
+
+export const SHORT_BLOCK_WINDOW: number = 20;
+
+export const SHORT_BLOCK_FORWARD: number = 15;
+
+// Querying
+export const PAGE_REQUEST: PageRequest = {
+  key: new Uint8Array(),
+  offset: Long.UZERO,
+  limit: Long.MAX_UNSIGNED_VALUE,
+  countTotal: true,
+  reverse: false,
+};
+
+export class IndexerConfig {
+  public restEndpoint: string;
+  public websocketEndpoint: string;
+  public proxy?: AxiosProxyConfig;
+
+  constructor(restEndpoint: string, websocketEndpoint: string, proxy?: AxiosProxyConfig) {
+    this.restEndpoint = restEndpoint;
+    this.websocketEndpoint = websocketEndpoint;
+    this.proxy = proxy;
+  }
+}
+
+export class ValidatorConfig {
+  public restEndpoint: string;
+  public chainId: string;
+  public denoms: DenomConfig;
+  public broadcastOptions?: BroadcastOptions;
+  public defaultClientMemo?: string;
+  public useTimestampNonce?: boolean;
+  public timestampNonceOffsetMs?: number;
+
+  constructor(
+    restEndpoint: string,
+    chainId: string,
+    denoms: DenomConfig,
+    broadcastOptions?: BroadcastOptions,
+    defaultClientMemo?: string,
+    useTimestampNonce?: boolean,
+    timestampNonceOffsetMs?: number,
+  ) {
+    this.restEndpoint = restEndpoint?.endsWith('/') ? restEndpoint.slice(0, -1) : restEndpoint;
+    this.chainId = chainId;
+
+    this.denoms = denoms;
+    this.broadcastOptions = broadcastOptions;
+    this.defaultClientMemo = defaultClientMemo;
+    this.useTimestampNonce = useTimestampNonce;
+    this.timestampNonceOffsetMs = timestampNonceOffsetMs;
+  }
+}
+
+export class Network {
+  constructor(
+    public env: string,
+    public indexerConfig: IndexerConfig,
+    public validatorConfig: ValidatorConfig,
+  ) {}
+
+  static testnet(): Network {
+    const indexerConfig = new IndexerConfig(IndexerApiHost.TESTNET, IndexerWSHost.TESTNET);
+    const validatorConfig = new ValidatorConfig(
+      ValidatorApiHost.TESTNET,
+      TESTNET_CHAIN_ID,
+      {
+        CHAINTOKEN_DENOM: 'urit',
+        USDC_DENOM: 'ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5',
+        USDC_GAS_DENOM: 'uusdc',
+        USDC_DECIMALS: 6,
+        CHAINTOKEN_DECIMALS: 18,
+      },
+      undefined,
+      'Client Example',
+    );
+    return new Network('testnet', indexerConfig, validatorConfig);
+  }
+
+  static staging(): Network {
+    const indexerConfig = new IndexerConfig(IndexerApiHost.STAGING, IndexerWSHost.STAGING);
+    const validatorConfig = new ValidatorConfig(
+      ValidatorApiHost.STAGING,
+      STAGING_CHAIN_ID,
+      {
+        CHAINTOKEN_DENOM: 'urit',
+        USDC_DENOM: 'ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5',
+        USDC_GAS_DENOM: 'uusdc',
+        USDC_DECIMALS: 6,
+        CHAINTOKEN_DECIMALS: 18,
+      },
+      undefined,
+      'Client Example',
+    );
+    return new Network('staging', indexerConfig, validatorConfig);
+  }
+
+  static local(): Network {
+    const indexerConfig = new IndexerConfig(IndexerApiHost.LOCAL, IndexerWSHost.LOCAL);
+    const validatorConfig = new ValidatorConfig(
+      ValidatorApiHost.LOCAL,
+      LOCAL_CHAIN_ID,
+      {
+        CHAINTOKEN_DENOM: 'urit',
+        USDC_DENOM: 'ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5',
+        USDC_GAS_DENOM: 'uusdc',
+        USDC_DECIMALS: 6,
+        CHAINTOKEN_DECIMALS: 18,
+      },
+      undefined,
+      'Client Example',
+    );
+    return new Network('local', indexerConfig, validatorConfig);
+  }
+
+  static mainnet(): Network {
+    const indexerConfig = new IndexerConfig(IndexerApiHost.MAINNET, IndexerWSHost.MAINNET);
+    const validatorConfig = new ValidatorConfig(
+      ValidatorApiHost.MAINNET,
+      MAINNET_CHAIN_ID,
+      {
+        CHAINTOKEN_DENOM: 'urit',
+        USDC_DENOM: 'ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5',
+        USDC_GAS_DENOM: 'uusdc',  
+        USDC_DECIMALS: 6,
+        CHAINTOKEN_DECIMALS: 18,
+      },
+      undefined,
+      'Client Example',
+    );
+    return new Network('mainnet', indexerConfig, validatorConfig);
+  }
+
+  getString(): string {
+    return this.env;
+  }
+}

package/src/clients/faucet-client.ts

@@ -0,0 +1,48 @@
+import { Response } from './lib/axios';
+import RestClient from './modules/rest';
+
+export class FaucetClient extends RestClient {
+  /**
+   * @description For testnet only, add USDC to an subaccount
+   *
+   * @returns The HTTP response.
+   */
+  public async fill(
+    address: string,
+    subaccountNumber: number,
+    amount: number,
+    headers?: {},
+  ): Promise<Response> {
+    const uri = '/faucet/tokens';
+
+    return this.post(
+      uri,
+      {},
+      {
+        address,
+        subaccountNumber,
+        amount,
+      },
+      headers,
+    );
+  }
+
+  /**
+   * @description For testnet only, add native tokens to an address
+   * @param address destination address for native tokens
+   * @param headers requestHeaders
+   * @returns The HTTP response.
+   */
+  public async fillNative(address: string, headers?: {}): Promise<Response> {
+    const uri = '/faucet/native-token';
+
+    return this.post(
+      uri,
+      {},
+      {
+        address,
+      },
+      headers,
+    );
+  }
+}

package/src/clients/helpers/chain-helpers.ts

@@ -0,0 +1,231 @@
+import BigNumber from 'bignumber.js';
+import Long from 'long';
+
+import { OrderType, OrderSide, OrderTimeInForce, OrderExecution } from '../constants';
+import { Order_ConditionType, Order_Side, Order_TimeInForce } from '../modules/proto-includes';
+import { OrderFlags } from '../types';
+
+export function round(input: number, base: number): number {
+  return BigNumber(input)
+    .div(BigNumber(base))
+    .integerValue(BigNumber.ROUND_FLOOR)
+    .times(BigNumber(base))
+    .toNumber();
+}
+
+export function calculateQuantums(
+  size: number,
+  atomicResolution: number,
+  stepBaseQuantums: number,
+): Long {
+  const rawQuantums = BigNumber(size).times(
+    BigNumber(10).pow(BigNumber(atomicResolution).negated()),
+  );
+  const quantums = round(rawQuantums.toNumber(), stepBaseQuantums);
+  // stepBaseQuantums functions as minimum order size
+  const result = Math.max(quantums, stepBaseQuantums);
+  return Long.fromNumber(result);
+}
+
+export function calculateVaultQuantums(size: number): bigint {
+  return BigInt(BigNumber(size).times(1_000_000).toFixed(0, BigNumber.ROUND_FLOOR));
+}
+
+export function calculateSubticks(
+  price: number,
+  atomicResolution: number,
+  quantumConversionExponent: number,
+  subticksPerTick: number,
+): Long {
+  const QUOTE_QUANTUMS_ATOMIC_RESOLUTION = -6;
+  const exponent = atomicResolution - quantumConversionExponent - QUOTE_QUANTUMS_ATOMIC_RESOLUTION;
+  const rawSubticks = BigNumber(price).times(BigNumber(10).pow(exponent));
+  const subticks = round(rawSubticks.toNumber(), subticksPerTick);
+  const result = Math.max(subticks, subticksPerTick);
+  return Long.fromNumber(result);
+}
+
+export function calculateSide(side: OrderSide): Order_Side {
+  return side === OrderSide.BUY ? Order_Side.SIDE_BUY : Order_Side.SIDE_SELL;
+}
+
+export function calculateTimeInForce(
+  type: OrderType,
+  timeInForce?: OrderTimeInForce,
+  execution?: OrderExecution,
+  postOnly?: boolean,
+): Order_TimeInForce {
+  switch (type) {
+    case OrderType.MARKET:
+      switch (timeInForce) {
+        case OrderTimeInForce.FOK:
+          return Order_TimeInForce.TIME_IN_FORCE_FILL_OR_KILL;
+
+        default:
+          return Order_TimeInForce.TIME_IN_FORCE_IOC;
+      }
+
+    case OrderType.LIMIT:
+      switch (timeInForce) {
+        case OrderTimeInForce.GTT:
+          if (postOnly == null) {
+            throw new Error('postOnly must be set if order type is LIMIT and timeInForce is GTT');
+          }
+          return postOnly
+            ? Order_TimeInForce.TIME_IN_FORCE_POST_ONLY
+            : Order_TimeInForce.TIME_IN_FORCE_UNSPECIFIED;
+
+        case OrderTimeInForce.FOK:
+          return Order_TimeInForce.TIME_IN_FORCE_FILL_OR_KILL;
+
+        case OrderTimeInForce.IOC:
+          return Order_TimeInForce.TIME_IN_FORCE_IOC;
+
+        default:
+          throw new Error('Unexpected code path: timeInForce');
+      }
+
+    case OrderType.STOP_LIMIT:
+    case OrderType.TAKE_PROFIT_LIMIT:
+      if (execution == null) {
+        throw new Error('execution must be set if order type is STOP_LIMIT or TAKE_PROFIT_LIMIT');
+      }
+      switch (execution) {
+        case OrderExecution.DEFAULT:
+          return Order_TimeInForce.TIME_IN_FORCE_UNSPECIFIED;
+
+        case OrderExecution.POST_ONLY:
+          return Order_TimeInForce.TIME_IN_FORCE_POST_ONLY;
+
+        case OrderExecution.FOK:
+          return Order_TimeInForce.TIME_IN_FORCE_FILL_OR_KILL;
+
+        case OrderExecution.IOC:
+          return Order_TimeInForce.TIME_IN_FORCE_IOC;
+
+        default:
+          throw new Error('Unexpected code path: timeInForce');
+      }
+
+    case OrderType.STOP_MARKET:
+    case OrderType.TAKE_PROFIT_MARKET:
+      if (execution == null) {
+        throw new Error('execution must be set if order type is STOP_MARKET or TAKE_PROFIT_MARKET');
+      }
+      switch (execution) {
+        case OrderExecution.DEFAULT:
+          throw new Error(
+            'Execution value DEFAULT not supported for STOP_MARKET or TAKE_PROFIT_MARKET',
+          );
+
+        case OrderExecution.POST_ONLY:
+          throw new Error(
+            'Execution value POST_ONLY not supported for STOP_MARKET or TAKE_PROFIT_MARKET',
+          );
+
+        case OrderExecution.FOK:
+          return Order_TimeInForce.TIME_IN_FORCE_FILL_OR_KILL;
+
+        case OrderExecution.IOC:
+          return Order_TimeInForce.TIME_IN_FORCE_IOC;
+
+        default:
+          throw new Error('Unexpected code path: timeInForce');
+      }
+
+    default:
+      throw new Error('Unexpected code path: timeInForce');
+  }
+}
+
+export function calculateOrderFlags(type: OrderType, timeInForce?: OrderTimeInForce): OrderFlags {
+  switch (type) {
+    case OrderType.MARKET:
+      return OrderFlags.SHORT_TERM;
+
+    case OrderType.LIMIT:
+      if (timeInForce === undefined) {
+        throw new Error('timeInForce must be set if orderType is LIMIT');
+      }
+      if (timeInForce === OrderTimeInForce.GTT) {
+        return OrderFlags.LONG_TERM;
+      } else {
+        return OrderFlags.SHORT_TERM;
+      }
+
+    case OrderType.STOP_LIMIT:
+    case OrderType.TAKE_PROFIT_LIMIT:
+    case OrderType.STOP_MARKET:
+    case OrderType.TAKE_PROFIT_MARKET:
+      return OrderFlags.CONDITIONAL;
+
+    default:
+      throw new Error('Unexpected code path: orderFlags');
+  }
+}
+
+export function calculateClientMetadata(orderType: OrderType): number {
+  switch (orderType) {
+    case OrderType.MARKET:
+    case OrderType.STOP_MARKET:
+    case OrderType.TAKE_PROFIT_MARKET:
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+
+export function calculateConditionType(orderType: OrderType): Order_ConditionType {
+  switch (orderType) {
+    case OrderType.LIMIT:
+      return Order_ConditionType.CONDITION_TYPE_UNSPECIFIED;
+
+    case OrderType.MARKET:
+      return Order_ConditionType.CONDITION_TYPE_UNSPECIFIED;
+
+    case OrderType.STOP_LIMIT:
+    case OrderType.STOP_MARKET:
+      return Order_ConditionType.CONDITION_TYPE_STOP_LOSS;
+
+    case OrderType.TAKE_PROFIT_LIMIT:
+    case OrderType.TAKE_PROFIT_MARKET:
+      return Order_ConditionType.CONDITION_TYPE_TAKE_PROFIT;
+
+    default:
+      return Order_ConditionType.CONDITION_TYPE_UNSPECIFIED;
+  }
+}
+
+export function calculateConditionalOrderTriggerSubticks(
+  orderType: OrderType,
+  atomicResolution: number,
+  quantumConversionExponent: number,
+  subticksPerTick: number,
+  triggerPrice?: number,
+): Long {
+  switch (orderType) {
+    case OrderType.LIMIT:
+    case OrderType.MARKET:
+      return Long.fromNumber(0);
+
+    case OrderType.STOP_LIMIT:
+    case OrderType.STOP_MARKET:
+    case OrderType.TAKE_PROFIT_LIMIT:
+    case OrderType.TAKE_PROFIT_MARKET:
+      if (triggerPrice === undefined) {
+        throw new Error(
+          'triggerPrice must be set if orderType is STOP_LIMIT, STOP_MARKET, TAKE_PROFIT_LIMIT, or TAKE_PROFIT_MARKET',
+        );
+      }
+      return calculateSubticks(
+        triggerPrice,
+        atomicResolution,
+        quantumConversionExponent,
+        subticksPerTick,
+      );
+
+    default:
+      return Long.fromNumber(0);
+  }
+}

package/src/clients/helpers/request-helpers.ts

@@ -0,0 +1,71 @@
+import Long from "long";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function generateQueryPath(url: string, params: {}): string {
+  const definedEntries = Object.entries(params).filter(
+    ([_key, value]: [string, unknown]) => value !== undefined,
+  );
+
+  if (!definedEntries.length) {
+    return url;
+  }
+
+  const paramsString = definedEntries
+    .map(([key, value]: [string, unknown]) => `${key}=${value}`)
+    .join('&');
+  return `${url}?${paramsString}`;
+}
+
+export function parseToPrimitives<T>(x: T): T {
+  if (typeof x === 'number' || typeof x === 'string' || typeof x === 'boolean' || x === null) {
+    return x;
+  }
+
+  if (Array.isArray(x)) {
+    return x.map((item) => parseToPrimitives(item)) as T;
+  }
+
+  if (Long.isLong(x)) {
+    return x.toString() as T;
+  }
+
+  if (x instanceof Uint8Array) {
+    return bytesToBigInt(x).toString() as T;
+  }
+
+  if (x instanceof Date) {
+    return x.toString() as T;
+  }
+
+  if (typeof x === 'object') {
+    const parsedObj: { [key: string]: any } = {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in x) {
+      if (Object.prototype.hasOwnProperty.call(x, key)) {
+        parsedObj[key] = parseToPrimitives((x as any)[key]);
+      }
+    }
+    return parsedObj as T;
+  }
+
+  if (typeof x === 'bigint') {
+    return x.toString() as T;
+  }
+
+  throw new Error(`Unsupported data type: ${typeof x}`);
+}
+
+/**
+ * Converts a byte array (representing an arbitrary-size signed integer) into a bigint.
+ * @param u Array of bytes represented as a Uint8Array.
+ */
+function bytesToBigInt(u: Uint8Array): bigint {
+  if (u.length <= 1) {
+    return BigInt(0);
+  }
+  // eslint-disable-next-line no-bitwise
+  const negated: boolean = (u[0] & 1) === 1;
+  const hex: string = Buffer.from(u.slice(1)).toString('hex');
+  const abs: bigint = BigInt(`0x${hex}`);
+  return negated ? -abs : abs;
+}