@zoguxprotocol/client-js 0.2.0

package/src/clients/noble-client.ts

@@ -0,0 +1,108 @@
+import { EncodeObject, Registry, Coin } from '@cosmjs/proto-signing';
+import {
+  calculateFee,
+  DeliverTxResponse,
+  GasPrice,
+  StdFee,
+  defaultRegistryTypes,
+  SigningStargateClient,
+  MsgTransferEncodeObject,
+} from '@cosmjs/stargate';
+
+import { GAS_MULTIPLIER } from './constants';
+import { MsgDepositForBurn, MsgDepositForBurnWithCaller } from './lib/cctpProto';
+import LocalWallet from './modules/local-wallet';
+
+export class NobleClient {
+  private wallet?: LocalWallet;
+  private restEndpoint: string;
+  private stargateClient?: SigningStargateClient;
+  private defaultClientMemo?: string;
+
+  constructor(restEndpoint: string, defaultClientMemo?: string) {
+    this.restEndpoint = restEndpoint;
+    this.defaultClientMemo = defaultClientMemo;
+  }
+
+  get isConnected(): boolean {
+    return Boolean(this.stargateClient);
+  }
+
+  async connect(wallet: LocalWallet): Promise<void> {
+    if (wallet?.offlineSigner === undefined) {
+      throw new Error('Wallet signer not found');
+    }
+    this.wallet = wallet;
+    this.stargateClient = await SigningStargateClient.connectWithSigner(
+      this.restEndpoint,
+      wallet.offlineSigner,
+      {
+        registry: new Registry([
+          ['/circle.cctp.v1.MsgDepositForBurn', MsgDepositForBurn],
+          ['/circle.cctp.v1.MsgDepositForBurnWithCaller', MsgDepositForBurnWithCaller],
+          ...defaultRegistryTypes,
+        ]),
+      },
+    );
+  }
+
+  getAccountBalances(): Promise<readonly Coin[]> {
+    if (!this.stargateClient || this.wallet?.address === undefined) {
+      throw new Error('stargateClient not initialized');
+    }
+    return this.stargateClient.getAllBalances(this.wallet.address);
+  }
+
+  getAccountBalance(denom: string): Promise<Coin> {
+    if (!this.stargateClient || this.wallet?.address === undefined) {
+      throw new Error('stargateClient not initialized');
+    }
+    return this.stargateClient.getBalance(this.wallet.address, denom);
+  }
+
+  async IBCTransfer(message: MsgTransferEncodeObject): Promise<DeliverTxResponse> {
+    const tx = await this.send([message]);
+    return tx;
+  }
+
+  async send(
+    messages: EncodeObject[],
+    gasPrice: GasPrice = GasPrice.fromString('0.1uusdc'),
+    memo?: string,
+  ): Promise<DeliverTxResponse> {
+    if (!this.stargateClient) {
+      throw new Error('NobleClient stargateClient not initialized');
+    }
+    if (this.wallet?.address === undefined) {
+      throw new Error('NobleClient wallet not initialized');
+    }
+    // Simulate to get the gas estimate
+    const fee = await this.simulateTransaction(messages, gasPrice, memo ?? this.defaultClientMemo);
+
+    // Sign and broadcast the transaction
+    return this.stargateClient.signAndBroadcast(
+      this.wallet.address,
+      messages,
+      fee,
+      memo ?? this.defaultClientMemo,
+    );
+  }
+
+  async simulateTransaction(
+    messages: readonly EncodeObject[],
+    gasPrice: GasPrice = GasPrice.fromString('0.1uusdc'),
+    memo?: string,
+  ): Promise<StdFee> {
+    if (!this.stargateClient) {
+      throw new Error('NobleClient stargateClient not initialized');
+    }
+    if (this.wallet?.address === undefined) {
+      throw new Error('NobleClient wallet not initialized');
+    }
+    // Get simulated response
+    const gasEstimate = await this.stargateClient.simulate(this.wallet?.address, messages, memo);
+
+    // Calculate and return the fee
+    return calculateFee(Math.floor(gasEstimate * GAS_MULTIPLIER), gasPrice);
+  }
+}

package/src/clients/socket-client.ts

@@ -0,0 +1,331 @@
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import WebSocket, { ErrorEvent, MessageEvent } from 'ws';
+
+import { getProxyAgent } from '../lib/utils';
+import { IndexerConfig } from './constants';
+
+enum OutgoingMessageTypes {
+  SUBSCRIBE = 'subscribe',
+  UNSUBSCRIBE = 'unsubscribe',
+}
+
+enum SocketChannels {
+  SUBACCOUNTS = 'v4_subaccounts',
+  ORDERBOOK = 'v4_orderbook',
+  TRADES = 'v4_trades',
+  MARKETS = 'v4_markets',
+  CANDLES = 'v4_candles',
+}
+
+export enum IncomingMessageTypes {
+  CONNECTED = 'connected',
+  SUBSCRIBED = 'subscribed',
+  ERROR = 'error',
+  CHANNEL_DATA = 'channel_data',
+  CHANNEL_BATCH_DATA = 'channel_batch_data',
+  PONG = 'pong',
+}
+
+export enum CandlesResolution {
+  ONE_MINUTE = '1MIN',
+  FIVE_MINUTES = '5MINS',
+  FIFTEEN_MINUTES = '15MINS',
+  THIRTY_MINUTES = '30MINS',
+  ONE_HOUR = '1HOUR',
+  FOUR_HOURS = '4HOURS',
+  ONE_DAY = '1DAY',
+}
+
+export class SocketClient {
+  private url: string;
+  private ws?: WebSocket;
+  private proxyAgent?: HttpsProxyAgent<string>;
+  private onOpenCallback?: () => void;
+  private onCloseCallback?: () => void;
+  private onMessageCallback?: (event: MessageEvent) => void;
+  private onErrorCallback?: (event: ErrorEvent) => void;
+  private lastMessageTime: number = Date.now();
+
+  constructor(
+    config: IndexerConfig,
+    onOpenCallback: () => void,
+    onCloseCallback: () => void,
+    onMessageCallback: (event: MessageEvent) => void,
+    onErrorCallback: (event: ErrorEvent) => void,
+  ) {
+    this.url = config.websocketEndpoint;
+    this.proxyAgent = config.proxy ? getProxyAgent(config.proxy) : undefined;
+    this.onOpenCallback = onOpenCallback;
+    this.onCloseCallback = onCloseCallback;
+    this.onMessageCallback = onMessageCallback;
+    this.onErrorCallback = onErrorCallback;
+  }
+
+  connect(): void {
+    this.ws = new WebSocket(this.url, {
+      agent: this.proxyAgent,
+    });
+    this.ws.addEventListener('open', this.handleOpen.bind(this));
+    this.ws.addEventListener('close', this.handleClose.bind(this));
+    this.ws.addEventListener('message', this.handleMessage.bind(this));
+    this.ws.addEventListener('error', this.handleError.bind(this));
+  }
+
+  /**
+   * @description Close the websocket connection.
+   *
+   */
+  close(): void {
+    this.ws?.close();
+    this.ws = undefined;
+  }
+
+  /**
+   * @description Check is the websocket connection connecting
+   */
+  isConnecting(): boolean {
+    return this.ws?.readyState === WebSocket.CONNECTING;
+  }
+
+  /**
+   * @description Check is the websocket connection open
+   */
+  isOpen(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  /**
+   * @description Check is the websocket connection closing
+   */
+  isClosing(): boolean {
+    return this.ws?.readyState === WebSocket.CLOSING;
+  }
+
+  /**
+   * @description Check is the websocket connection closed
+   */
+  isClosed(): boolean {
+    return this.ws?.readyState === WebSocket.CLOSED;
+  }
+
+  /**
+   * @description Send data to the websocket connection.
+   *
+   */
+  send(data: string): void {
+    this.ws?.send(data);
+  }
+
+  private handleOpen(): void {
+    if (this.onOpenCallback) {
+      this.onOpenCallback();
+    }
+  }
+
+  private handleClose(): void {
+    if (this.onCloseCallback) {
+      this.onCloseCallback();
+    }
+  }
+
+  private handleMessage(event: MessageEvent): void {
+    if (event.data === 'PING') {
+      this.send('PONG');
+    } else {
+      this.lastMessageTime = Date.now();
+      if (this.onMessageCallback) {
+        this.onMessageCallback(event);
+      }
+    }
+  }
+
+  private handleError(event: ErrorEvent): void {
+    if (this.onErrorCallback) {
+      this.onErrorCallback(event);
+    }
+  }
+
+  /**
+   * @description Set callback when the socket is opened.
+   *
+   */
+  set onOpen(callback: () => void) {
+    this.onOpenCallback = callback;
+  }
+
+  /**
+   * @description Set callback when the socket is closed.
+   *
+   */
+  set onClose(callback: () => void) {
+    this.onCloseCallback = callback;
+  }
+
+  /**
+   * @description Set callback when the socket receives a message.
+   *
+   */
+  set onMessage(callback: (event: MessageEvent) => void) {
+    this.onMessageCallback = callback;
+  }
+
+  /**
+   * @description Set callback when the socket encounters an error.
+   */
+  set onError(callback: (event: ErrorEvent) => void) {
+    this.onErrorCallback = callback;
+  }
+
+  /**
+   * @description Send a subscribe message to the websocket connection.
+   *
+   */
+  subscribe(channel: string, params?: object): void {
+    const message = {
+      type: OutgoingMessageTypes.SUBSCRIBE,
+      channel,
+      ...params,
+    };
+    this.send(JSON.stringify(message));
+  }
+
+  /**
+   * @description Send an unsubscribe message to the websocket connection.
+   *
+   */
+  unsubscribe(channel: string, params?: object): void {
+    const message = {
+      type: OutgoingMessageTypes.UNSUBSCRIBE,
+      channel,
+      ...params,
+    };
+    this.send(JSON.stringify(message));
+  }
+
+  /**
+   * @description Subscribe to markets channel.
+   *
+   */
+  subscribeToMarkets(): void {
+    const channel = SocketChannels.MARKETS;
+    const params = {
+      batched: true,
+    };
+    this.subscribe(channel, params);
+  }
+
+  /**
+   * @description Unsubscribe from markets channel
+   *
+   */
+  unsubscribeFromMarkets(): void {
+    const channel = SocketChannels.MARKETS;
+    this.unsubscribe(channel);
+  }
+
+  /**
+   * @description Subscribe to trade channel
+   * for a specific market.
+   *
+   */
+  subscribeToTrades(market: string): void {
+    const channel = SocketChannels.TRADES;
+    const params = {
+      id: market,
+      batched: true,
+    };
+    this.subscribe(channel, params);
+  }
+
+  /**
+   * @description Unscribed from trade channel
+   * for a specific market.
+   *
+   */
+  unsubscribeFromTrades(market: string): void {
+    const channel = SocketChannels.TRADES;
+    const params = {
+      id: market,
+    };
+    this.unsubscribe(channel, params);
+  }
+
+  /**
+   * @description Subscribe to orderbook channel
+   * for a specific market.
+   *
+   */
+  subscribeToOrderbook(market: string): void {
+    const channel = SocketChannels.ORDERBOOK;
+    const params = {
+      id: market,
+      batched: true,
+    };
+    this.subscribe(channel, params);
+  }
+
+  /**
+   * @description Unsubscribe from orderbook channel
+   * for a specific market.
+   */
+  unsubscribeFromOrderbook(market: string): void {
+    const channel = SocketChannels.ORDERBOOK;
+    const params = {
+      id: market,
+    };
+    this.unsubscribe(channel, params);
+  }
+
+  /**
+   * @description Subscribe to candles channel
+   * for a specific market and resolution.
+   *
+   */
+  subscribeToCandles(market: string, resolution: CandlesResolution): void {
+    const channel = SocketChannels.CANDLES;
+    const params = {
+      id: `${market}/${resolution}`,
+      batched: true,
+    };
+    this.subscribe(channel, params);
+  }
+
+  /**
+   * @description Unsubscribe from candles channel
+   * for a specific market and resolution.
+   */
+  unsubscribeFromCandles(market: string, resolution: CandlesResolution): void {
+    const channel = SocketChannels.CANDLES;
+    const params = {
+      id: `${market}/${resolution}`,
+    };
+    this.unsubscribe(channel, params);
+  }
+
+  /**
+   * @description Subscribe to subaccount channel
+   * for a specific address and subaccount number.
+   */
+  subscribeToSubaccount(address: string, subaccountNumber: number): void {
+    const channel = SocketChannels.SUBACCOUNTS;
+    const subaccountId = `${address}/${subaccountNumber}`;
+    const params = {
+      id: subaccountId,
+    };
+    this.subscribe(channel, params);
+  }
+
+  /**
+   * @description Unsubscribe from subaccount channel
+   * for a specific address and subaccount number.
+   *
+   */
+  unsubscribeFromSubaccount(address: string, subaccountNumber: number): void {
+    const channel = SocketChannels.SUBACCOUNTS;
+    const subaccountId = `${address}/${subaccountNumber}`;
+    const params = {
+      id: subaccountId,
+    };
+    this.unsubscribe(channel, params);
+  }
+}

package/src/clients/subaccount.ts

@@ -0,0 +1,57 @@
+import Long from 'long';
+
+import { MAX_SUBACCOUNT_NUMBER } from './constants';
+import LocalWallet from './modules/local-wallet';
+
+export class SubaccountInfo {
+  readonly address: string;
+  readonly subaccountNumber: number;
+  readonly signingWallet: LocalWallet;
+  readonly authenticators?: Long[];
+
+  private constructor(
+    signingWallet: LocalWallet,
+    address: string,
+    subaccountNumber: number = 0,
+    authenticators?: Long[],
+  ) {
+    if (subaccountNumber < 0 || subaccountNumber > MAX_SUBACCOUNT_NUMBER) {
+      throw new Error(`Subaccount number must be between 0 and ${MAX_SUBACCOUNT_NUMBER}`);
+    }
+
+    this.address = address;
+    this.subaccountNumber = subaccountNumber;
+    this.signingWallet = signingWallet;
+    this.authenticators = authenticators;
+  }
+
+  static forLocalWallet(wallet: LocalWallet, subaccountNumber: number = 0): SubaccountInfo {
+    const address = wallet.address;
+    if (address === undefined) {
+      throw new Error('Address not available from wallet');
+    }
+    return new SubaccountInfo(wallet, address, subaccountNumber);
+  }
+
+  static forPermissionedWallet(
+    signingWallet: LocalWallet,
+    accountAddress: string,
+    subaccountNumber: number = 0,
+    authenticators: Long[],
+  ): SubaccountInfo {
+    return new SubaccountInfo(signingWallet, accountAddress, subaccountNumber, authenticators);
+  }
+
+  get isPermissionedWallet(): boolean {
+    return this.address !== this.signingWallet.address;
+  }
+
+  cloneWithSubaccount(subaccountNumber: number): SubaccountInfo {
+    return new SubaccountInfo(
+      this.signingWallet,
+      this.address,
+      subaccountNumber,
+      this.authenticators,
+    );
+  }
+}

package/src/clients/types.ts

@@ -0,0 +1,191 @@
+import { Coin } from '@cosmjs/proto-signing';
+import { Method } from '@cosmjs/tendermint-rpc';
+import {
+  Order_ConditionType,
+  Order_Side,
+  Order_TimeInForce,
+} from '@zoguxprotocol/proto/src/codegen/zogux/clob/order';
+import { PerpetualMarketType } from '@zoguxprotocol/proto/src/codegen/zogux/perpetuals/perpetual';
+import BigNumber from 'bignumber.js';
+import Long from 'long';
+
+export type Integer = BigNumber;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GenericParams = { [name: string]: any };
+
+// TODO: Find a better way.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Data = any;
+
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+// Information for signing a transaction while offline - without sequence.
+export interface PartialTransactionOptions {
+  accountNumber: number;
+  chainId: string;
+}
+
+// Information for signing a transaction while offline.
+export interface TransactionOptions extends PartialTransactionOptions {
+  sequence: number;
+  authenticators?: Long[];
+}
+
+// OrderFlags, just a number in proto, defined as enum for convenience
+export enum OrderFlags {
+  SHORT_TERM = 0,
+  LONG_TERM = 64,
+  CONDITIONAL = 32,
+}
+
+// TWAP order parameters
+export interface ITwapParameters {
+  duration: number; // Duration in seconds [300, 86400]
+  interval: number; // Interval in seconds [30, 3600]
+  priceTolerance: number; // Price tolerance in ppm [0, 1_000_000)
+}
+
+// Builder code parameters for partner/builder fees
+export interface IBuilderCodeParameters {
+  builderAddress: string; // Address to receive the fee
+  feePpm: number; // Fee in parts per million
+}
+
+export interface IBasicOrder {
+  clientId: number;
+  orderFlags: OrderFlags;
+  clobPairId: number;
+  goodTilBlock?: number;
+  goodTilBlockTime?: number;
+}
+
+export interface IPlaceOrder extends IBasicOrder {
+  side: Order_Side;
+  quantums: Long;
+  subticks: Long;
+  timeInForce: Order_TimeInForce;
+  reduceOnly: boolean;
+  clientMetadata: number;
+  conditionType?: Order_ConditionType;
+  conditionalOrderTriggerSubticks?: Long;
+  twapParameters?: ITwapParameters;
+  builderCodeParameters?: IBuilderCodeParameters;
+  orderRouterAddress?: string;
+}
+
+export interface ICancelOrder extends IBasicOrder {}
+
+export interface IBatchCancelOrder {
+  shortTermOrders: { clobPairId: number; clientIds: number[] }[];
+  goodTilBlock: number;
+}
+
+// How long to wait and how often to check when calling Broadcast with
+// Method.BroadcastTxCommit
+export interface BroadcastOptions {
+  broadcastPollIntervalMs: number;
+  broadcastTimeoutMs: number;
+}
+
+export interface DenomConfig {
+  USDC_DENOM: string;
+  USDC_DECIMALS: number;
+  USDC_GAS_DENOM?: string;
+
+  CHAINTOKEN_DENOM: string;
+  CHAINTOKEN_DECIMALS: number;
+  CHAINTOKEN_GAS_DENOM?: string;
+}
+
+// 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;
+
+// ------ Utility Endpoint Responses ------ //
+export interface TimeResponse {
+  iso: string;
+  epoch: number;
+}
+
+export interface HeightResponse {
+  height: number;
+  time: string;
+}
+
+export interface ComplianceResponse {
+  restricted: boolean;
+  reason?: string;
+}
+
+export enum ComplianceReason {
+  MANUAL = 'MANUAL',
+  US_GEO = 'US_GEO',
+  CA_GEO = 'CA_GEO',
+  GB_GEO = 'GB_GEO',
+  SANCTIONED_GEO = 'SANCTIONED_GEO',
+  COMPLIANCE_PROVIDER = 'COMPLIANCE_PROVIDER',
+}
+
+export enum ComplianceStatus {
+  COMPLIANT = 'COMPLIANT',
+  FIRST_STRIKE_CLOSE_ONLY = 'FIRST_STRIKE_CLOSE_ONLY',
+  FIRST_STRIKE = 'FIRST_STRIKE',
+  CLOSE_ONLY = 'CLOSE_ONLY',
+  BLOCKED = 'BLOCKED',
+}
+
+export interface ComplianceV2Response {
+  status: ComplianceStatus;
+  reason?: ComplianceReason;
+  updatedAt?: string;
+}
+
+// ------------ Squid ------------ //
+export type SquidIBCPayload = {
+  msgTypeUrl: '/ibc.applications.transfer.v1.MsgTransfer';
+  msg: Partial<{
+    sourcePort: string;
+    sourceChannel: string;
+    token: Coin;
+    sender: string;
+    receiver: string;
+    timeoutTimestamp: Long;
+    memo: string;
+  }>;
+};
+
+// ------------ x/gov: Add New Market ------------ //
+
+export type GovAddNewMarketParams = {
+  // common
+  id: number;
+  ticker: string;
+
+  // x/prices
+  priceExponent: number;
+  minPriceChange: number;
+  minExchanges: number;
+  exchangeConfigJson: string;
+
+  // x/perpetuals
+  liquidityTier: number;
+  atomicResolution: number;
+  marketType: PerpetualMarketType;
+
+  // x/clob
+  quantumConversionExponent: number;
+  stepBaseQuantums: Long;
+  subticksPerTick: number;
+
+  // x/delaymsg
+  delayBlocks: number;
+};
+
+export * from './modules/proto-includes';