@nadohq/client 0.1.0-alpha.1

package/src/apis/market/MarketExecuteAPI.ts

@@ -0,0 +1,169 @@
+import { BaseNadoAPI } from '../base';
+import { OptionalSignatureParams } from '../types';
+import {
+  CancelAndPlaceOrderParams,
+  CancelOrdersParams,
+  CancelProductOrdersParams,
+  CancelTriggerOrdersParams,
+  CancelTriggerProductOrdersParams,
+  PlaceIsolatedOrderParams,
+  PlaceOrderParams,
+  PlaceTriggerOrderParams,
+} from './types';
+
+export class MarketExecuteAPI extends BaseNadoAPI {
+  /**
+   * Places an order through the engine
+   * @param params
+   */
+  async placeOrder(params: PlaceOrderParams) {
+    const { id: orderId, productId, order, nonce } = params;
+
+    return this.context.engineClient.placeOrder({
+      id: orderId,
+      order: {
+        ...order,
+        subaccountOwner: this.getSubaccountOwnerIfNeeded(params.order),
+      },
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: await this.getOrderbookVerifyingAddressIfNeeded(params),
+      productId,
+      spotLeverage: params.spotLeverage,
+      nonce,
+    });
+  }
+
+  /**
+   * Places an isolated order through the engine
+   * @param params
+   */
+  async placeIsolatedOrder(params: PlaceIsolatedOrderParams) {
+    const { id: orderId, productId, order, nonce, borrowMargin } = params;
+
+    return this.context.engineClient.placeIsolatedOrder({
+      id: orderId,
+      order: {
+        ...order,
+        subaccountOwner: this.getSubaccountOwnerIfNeeded(params.order),
+      },
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: await this.getOrderbookVerifyingAddressIfNeeded(params),
+      productId,
+      borrowMargin,
+      nonce,
+    });
+  }
+
+  /**
+   * Cancels orders through the engine
+   * @param params
+   */
+  async cancelOrders(params: CancelOrdersParams) {
+    return this.context.engineClient.cancelOrders({
+      ...params,
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      verifyingAddr: this.getEndpointAddress(),
+    });
+  }
+
+  /**
+   * Cancels orders through the engine and places a new one
+   * @param params
+   */
+  async cancelAndPlace(params: CancelAndPlaceOrderParams) {
+    const { productId, order, nonce, spotLeverage } = params.placeOrder;
+    const subaccountOwner = this.getSubaccountOwnerIfNeeded(
+      params.cancelOrders,
+    );
+    const chainId = this.getWalletClientChainIdIfNeeded(params.cancelOrders);
+
+    return this.context.engineClient.cancelAndPlace({
+      cancelOrders: {
+        ...params.cancelOrders,
+        subaccountOwner,
+        verifyingAddr:
+          params.cancelOrders.verifyingAddr ?? this.getEndpointAddress(),
+        chainId,
+      },
+      placeOrder: {
+        order: {
+          ...order,
+          subaccountOwner,
+        },
+        verifyingAddr: await this.getOrderbookVerifyingAddressIfNeeded(
+          params.placeOrder,
+        ),
+        chainId,
+        productId,
+        spotLeverage,
+        nonce,
+      },
+    });
+  }
+
+  /**
+   * Cancels all orders for provided products through the engine.
+   * @param params
+   */
+  async cancelProductOrders(params: CancelProductOrdersParams) {
+    return this.context.engineClient.cancelProductOrders({
+      ...params,
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      verifyingAddr: this.getEndpointAddress(),
+    });
+  }
+
+  /**
+   * Places a trigger order through the trigger service
+   * @param params
+   */
+  async placeTriggerOrder(params: PlaceTriggerOrderParams) {
+    return this.context.triggerClient.placeTriggerOrder({
+      ...params,
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: await this.getOrderbookVerifyingAddressIfNeeded(params),
+      order: {
+        subaccountOwner: this.getSubaccountOwnerIfNeeded(params.order),
+        ...params.order,
+      },
+    });
+  }
+
+  /**
+   * Cancels all trigger orders for provided digests through the trigger service.
+   * @param params
+   */
+  async cancelTriggerOrders(params: CancelTriggerOrdersParams) {
+    return this.context.triggerClient.cancelTriggerOrders({
+      ...params,
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+    });
+  }
+
+  /**
+   * Cancels all trigger orders for provided products through the trigger service.
+   * @param params
+   */
+  async cancelTriggerProductOrders(params: CancelTriggerProductOrdersParams) {
+    return this.context.triggerClient.cancelProductOrders({
+      ...params,
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+    });
+  }
+
+  protected async getOrderbookVerifyingAddressIfNeeded(
+    params: OptionalSignatureParams<{
+      productId: number;
+    }>,
+  ): Promise<string> {
+    return (
+      params.verifyingAddr ?? (await this.getOrderbookAddress(params.productId))
+    );
+  }
+}

package/src/apis/market/MarketQueryAPI.ts

@@ -0,0 +1,214 @@
+import { getAllMarkets, GetAllMarketsResponse } from '@nadohq/contracts';
+import {
+  GetEngineMarketLiquidityParams,
+  GetEngineMarketPriceParams,
+  GetEngineMarketPricesParams,
+  GetEngineMaxOrderSizeParams,
+  GetEngineSubaccountOrdersParams,
+  GetEngineSubaccountProductOrdersParams,
+  ValidateEngineOrderParams,
+} from '@nadohq/engine-client';
+import {
+  GetIndexerCandlesticksParams,
+  GetIndexerEdgeCandlesticksParams,
+  GetIndexerEdgeMarketSnapshotsParams,
+  GetIndexerFundingRateParams,
+  GetIndexerMarketSnapshotsParams,
+  GetIndexerMultiProductFundingRatesParams,
+  GetIndexerMultiProductSnapshotsParams,
+  GetIndexerOrdersParams,
+  GetIndexerOrdersResponse,
+  GetIndexerProductSnapshotsParams,
+} from '@nadohq/indexer-client';
+import { BaseNadoAPI } from '../base';
+import { GetTriggerOrdersParams } from './types';
+
+export class MarketQueryAPI extends BaseNadoAPI {
+  /**
+   * Retrieves all market states from the on-chain contracts
+   */
+  async getAllMarkets(): Promise<GetAllMarketsResponse> {
+    return getAllMarkets(this.context.contracts);
+  }
+
+  /**
+   * Retrieves all market states from the offchain engine
+   */
+  async getAllEngineMarkets(): Promise<GetAllMarketsResponse> {
+    return this.context.engineClient.getAllMarkets();
+  }
+
+  /**
+   * Get all edge engine markets
+   */
+  async getEdgeAllEngineMarkets(): Promise<
+    Record<number, GetAllMarketsResponse>
+  > {
+    return this.context.engineClient.getEdgeAllMarkets();
+  }
+
+  /**
+   * Retrieves all spread health groups
+   */
+  async getHealthGroups() {
+    return this.context.engineClient.getHealthGroups();
+  }
+
+  /**
+   * Queries engine to determine if the order can be submitted within health requirements
+   */
+  async validateOrderParams(params: ValidateEngineOrderParams) {
+    return this.context.engineClient.validateOrderParams(params);
+  }
+
+  /**
+   * Queries the offchain engine to retrieve status of any open orders for the given subaccount
+   * @param params
+   */
+  async getOpenSubaccountOrders(params: GetEngineSubaccountOrdersParams) {
+    return this.context.engineClient.getSubaccountOrders(params);
+  }
+
+  /**
+   * Queries the offchain engine to retrieve status of any open orders for the given subaccount for multiple products
+   * @param params
+   */
+  async getOpenSubaccountMultiProductOrders(
+    params: GetEngineSubaccountProductOrdersParams,
+  ) {
+    return this.context.engineClient.getSubaccountMultiProductOrders(params);
+  }
+
+  /**
+   * Queries the offchain trigger service to list trigger orders. Requires a signature
+   * @param params
+   */
+  async getTriggerOrders(params: GetTriggerOrdersParams) {
+    return this.context.triggerClient.listOrders({
+      ...params,
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+    });
+  }
+
+  /**
+   * Queries indexer to fetch historical orders
+   *
+   * @param params
+   */
+  async getHistoricalOrders(
+    params: GetIndexerOrdersParams,
+  ): Promise<GetIndexerOrdersResponse> {
+    return this.context.indexerClient.getOrders(params);
+  }
+
+  /**
+   * Queries engine to determine maximum order size
+   * @param params
+   */
+  async getMaxOrderSize(params: GetEngineMaxOrderSizeParams) {
+    return this.context.engineClient.getMaxOrderSize(params);
+  }
+
+  /**
+   * Retrieves liquidity per price tick from the engine. The engine will skip price levels that have no liquidity,
+   * so it is not guaranteed that the bids/asks are evenly spaced
+   */
+  async getMarketLiquidity(params: GetEngineMarketLiquidityParams) {
+    return this.context.engineClient.getMarketLiquidity(params);
+  }
+
+  /**
+   * Historical candlesticks from the indexer, use getLatestMarketPrice for the latest orderbook prices
+   *
+   * @param params
+   */
+  async getCandlesticks(params: GetIndexerCandlesticksParams) {
+    return this.context.indexerClient.getCandlesticks(params);
+  }
+
+  /**
+   * Historical candlesticks from Edge, use getLatestMarketPrice for the latest orderbook prices
+   *
+   * @param params
+   */
+  async getEdgeCandlesticks(params: GetIndexerEdgeCandlesticksParams) {
+    return this.context.indexerClient.getEdgeCandlesticks(params);
+  }
+
+  /**
+   * Retrieves the latest off-chain orderbook price from the engine
+   *
+   * @param params
+   */
+  async getLatestMarketPrice(params: GetEngineMarketPriceParams) {
+    return this.context.engineClient.getMarketPrice(params);
+  }
+
+  /**
+   * Retrieves the latest off-chain orderbook price from the engine for multiple markets
+   *
+   * @param params
+   */
+  async getLatestMarketPrices(params: GetEngineMarketPricesParams) {
+    return this.context.engineClient.getMarketPrices(params);
+  }
+
+  /**
+   * Retrieves the latest funding rate for a perp product
+   *
+   * @param params
+   */
+  async getFundingRate(params: GetIndexerFundingRateParams) {
+    return this.context.indexerClient.getFundingRate(params);
+  }
+
+  /**
+   * Retrieves the latest funding rate for multiple perp products
+   *
+   * @param params
+   */
+  async getMultiProductFundingRates(
+    params: GetIndexerMultiProductFundingRatesParams,
+  ) {
+    return this.context.indexerClient.getMultiProductFundingRates(params);
+  }
+
+  /**
+   * Retrieves the historical snapshots for a product from the indexer
+   *
+   * @param params
+   */
+  async getProductSnapshots(params: GetIndexerProductSnapshotsParams) {
+    return this.context.indexerClient.getProductSnapshots(params);
+  }
+
+  /**
+   * Retrieves the historical snapshots for a market from the indexer
+   *
+   * @param params
+   */
+  async getMarketSnapshots(params: GetIndexerMarketSnapshotsParams) {
+    return this.context.indexerClient.getMarketSnapshots(params);
+  }
+
+  /**
+   * Retrieves the historical snapshots for a market from Edge
+   *
+   * @param params
+   */
+  async getEdgeMarketSnapshots(params: GetIndexerEdgeMarketSnapshotsParams) {
+    return this.context.indexerClient.getEdgeMarketSnapshots(params);
+  }
+
+  /**
+   * Retrieves the historical snapshots for multiple products from the indexer
+   *
+   * @param params
+   */
+  async getMultiProductSnapshots(
+    params: GetIndexerMultiProductSnapshotsParams,
+  ) {
+    return this.context.indexerClient.getMultiProductSnapshots(params);
+  }
+}

package/src/apis/market/index.ts

@@ -0,0 +1,7 @@
+import { Mixin } from 'ts-mixer';
+import { MarketExecuteAPI } from './MarketExecuteAPI';
+import { MarketQueryAPI } from './MarketQueryAPI';
+
+export * from './types';
+
+export class MarketAPI extends Mixin(MarketExecuteAPI, MarketQueryAPI) {}

package/src/apis/market/types.ts

@@ -0,0 +1,58 @@
+import {
+  EngineCancelOrdersParams,
+  EngineCancelProductOrdersParams,
+  EngineIsolatedOrderParams,
+  EngineOrderParams,
+  EnginePlaceIsolatedOrderParams,
+  EnginePlaceOrderParams,
+} from '@nadohq/engine-client';
+import {
+  TriggerCancelOrdersParams,
+  TriggerCancelProductOrdersParams,
+  TriggerListOrdersParams,
+  TriggerPlaceOrderParams,
+} from '@nadohq/trigger-client';
+import { OptionalSignatureParams, OptionalSubaccountOwner } from '../types';
+
+type ClientOrderParams<T> = Omit<OptionalSignatureParams<T>, 'order'> & {
+  order: OptionalSubaccountOwner<EngineOrderParams>;
+};
+
+export type PlaceOrderParams = ClientOrderParams<EnginePlaceOrderParams>;
+
+/**
+ * Same as PlaceOrderParams but with isolated fields for isolated margin trading
+ */
+export type PlaceIsolatedOrderParams = Omit<
+  OptionalSignatureParams<EnginePlaceIsolatedOrderParams>,
+  'order'
+> & {
+  order: OptionalSubaccountOwner<EngineIsolatedOrderParams>;
+};
+
+export type CancelOrdersParams = OptionalSignatureParams<
+  OptionalSubaccountOwner<EngineCancelOrdersParams>
+>;
+
+export type CancelProductOrdersParams = OptionalSignatureParams<
+  OptionalSubaccountOwner<EngineCancelProductOrdersParams>
+>;
+
+export interface CancelAndPlaceOrderParams {
+  placeOrder: PlaceOrderParams;
+  cancelOrders: CancelOrdersParams;
+}
+
+export type PlaceTriggerOrderParams =
+  ClientOrderParams<TriggerPlaceOrderParams>;
+
+export type CancelTriggerOrdersParams = OptionalSignatureParams<
+  OptionalSubaccountOwner<TriggerCancelOrdersParams>
+>;
+
+export type CancelTriggerProductOrdersParams = OptionalSignatureParams<
+  OptionalSubaccountOwner<TriggerCancelProductOrdersParams>
+>;
+
+export type GetTriggerOrdersParams =
+  OptionalSignatureParams<TriggerListOrdersParams>;

package/src/apis/perp/PerpExecuteAPI.ts

@@ -0,0 +1,8 @@
+import { SettlePnlParams } from '@nadohq/contracts';
+import { BaseNadoAPI } from '../base';
+
+export class PerpExecuteAPI extends BaseNadoAPI {
+  settlePnl(_params: SettlePnlParams) {
+    throw Error('Not implemented');
+  }
+}

package/src/apis/perp/PerpQueryAPI.ts

@@ -0,0 +1,25 @@
+import {
+  GetIndexerMultiProductPerpPricesParams,
+  GetIndexerPerpPricesParams,
+} from '@nadohq/indexer-client';
+import { BaseNadoAPI } from '../base';
+
+export class PerpQueryAPI extends BaseNadoAPI {
+  /**
+   * Gets the latest index & mark price for a perp product
+   * @param params
+   */
+  async getPerpPrices(params: GetIndexerPerpPricesParams) {
+    return this.context.indexerClient.getPerpPrices(params);
+  }
+
+  /**
+   * Gets the latest index & mark price for multiple perp products
+   * @param params
+   */
+  async getMultiProductPerpPrices(
+    params: GetIndexerMultiProductPerpPricesParams,
+  ) {
+    return this.context.indexerClient.getMultiProductPerpPrices(params);
+  }
+}

package/src/apis/perp/index.ts

@@ -0,0 +1,5 @@
+import { Mixin } from 'ts-mixer';
+import { PerpExecuteAPI } from './PerpExecuteAPI';
+import { PerpQueryAPI } from './PerpQueryAPI';
+
+export class PerpAPI extends Mixin(PerpExecuteAPI, PerpQueryAPI) {}

package/src/apis/spot/BaseSpotAPI.ts

@@ -0,0 +1,30 @@
+import { ContractInstance, ERC20_ABI } from '@nadohq/contracts';
+import { getValidatedAddress } from '@nadohq/utils';
+import { getContract } from 'viem';
+import { BaseNadoAPI } from '../base';
+import { ProductIdOrTokenAddress } from './types';
+
+export class BaseSpotAPI extends BaseNadoAPI {
+  /**
+   * Retrieves the ERC20 token contract for a spot product
+   */
+  async getTokenContractForProduct(
+    params: ProductIdOrTokenAddress,
+  ): Promise<ContractInstance<typeof ERC20_ABI>> {
+    let tokenAddress: string;
+    if ('productId' in params) {
+      const config = await this.context.contracts.spotEngine.read.getConfig([
+        params.productId,
+      ]);
+      tokenAddress = config.token;
+    } else {
+      tokenAddress = params.tokenAddress;
+    }
+
+    return getContract({
+      abi: ERC20_ABI,
+      address: getValidatedAddress(tokenAddress),
+      client: this.context.walletClient ?? this.context.publicClient,
+    });
+  }
+}

package/src/apis/spot/SpotExecuteAPI.ts

@@ -0,0 +1,102 @@
+import {
+  approveDepositAllowance,
+  depositCollateral,
+  DepositCollateralParams,
+  isWriteableContract,
+  MintMockERC20Params,
+  MOCK_ERC20_ABI,
+} from '@nadohq/contracts';
+import { toBigInt, WalletNotProvidedError } from '@nadohq/utils';
+import { BaseSpotAPI } from './BaseSpotAPI';
+import {
+  ApproveAllowanceParams,
+  BurnVlpParams,
+  MintVlpParams,
+  TransferQuoteParams,
+  WithdrawCollateralParams,
+} from './types';
+
+export class SpotExecuteAPI extends BaseSpotAPI {
+  async deposit(params: DepositCollateralParams) {
+    return depositCollateral({
+      endpoint: this.context.contracts.endpoint,
+      subaccountName: params.subaccountName,
+      productId: params.productId,
+      amount: params.amount,
+      referralCode: params.referralCode,
+    });
+  }
+
+  async withdraw(params: WithdrawCollateralParams) {
+    return this.context.engineClient.withdrawCollateral({
+      ...params,
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+    });
+  }
+
+  async approveAllowance(params: ApproveAllowanceParams) {
+    const tokenContract = await this.getTokenContractForProduct(params);
+    if (!isWriteableContract(tokenContract)) {
+      throw new Error(
+        'Token contract does not permit writes. Is a wallet client provided?',
+      );
+    }
+
+    return approveDepositAllowance({
+      amount: params.amount,
+      endpoint: this.context.contracts.endpoint,
+      tokenContract,
+    });
+  }
+
+  /**
+   * Transfers quote between subaccounts under the same wallet.
+   *
+   * @param params
+   */
+  async transferQuote(params: TransferQuoteParams) {
+    return this.context.engineClient.transferQuote({
+      ...params,
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+    });
+  }
+
+  async mintVlp(params: MintVlpParams) {
+    return this.context.engineClient.mintVlp({
+      ...params,
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+    });
+  }
+
+  async burnVlp(params: BurnVlpParams) {
+    return this.context.engineClient.burnVlp({
+      ...params,
+      subaccountOwner: this.getSubaccountOwnerIfNeeded(params),
+      chainId: this.getWalletClientChainIdIfNeeded(params),
+      verifyingAddr: params.verifyingAddr ?? this.getEndpointAddress(),
+    });
+  }
+
+  async _mintMockERC20(params: MintMockERC20Params) {
+    if (!this.context.walletClient) {
+      throw new WalletNotProvidedError();
+    }
+
+    const config = await this.context.contracts.spotEngine.read.getConfig([
+      params.productId,
+    ]);
+
+    return this.context.walletClient.writeContract({
+      abi: MOCK_ERC20_ABI,
+      address: config.token,
+      functionName: 'mint',
+      args: [this.getWalletClientAddress(), toBigInt(params.amount)],
+    });
+  }
+}

package/src/apis/spot/SpotQueryAPI.ts

@@ -0,0 +1,53 @@
+import {
+  GetEngineMaxMintVlpAmountParams,
+  GetEngineMaxWithdrawableParams,
+} from '@nadohq/engine-client';
+import { BigDecimal, getValidatedAddress, toBigDecimal } from '@nadohq/utils';
+import { BaseSpotAPI } from './BaseSpotAPI';
+import { GetTokenAllowanceParams, GetTokenWalletBalanceParams } from './types';
+
+export class SpotQueryAPI extends BaseSpotAPI {
+  /**
+   * Gets the estimated max withdrawable amount for a product
+   * @param params
+   */
+  async getMaxWithdrawable(params: GetEngineMaxWithdrawableParams) {
+    return this.context.engineClient.getMaxWithdrawable(params);
+  }
+
+  /**
+   * Queries engine to determine maximum quote amount for minting VLP.
+   *
+   * @param params
+   */
+  async getMaxMintVlpAmount(params: GetEngineMaxMintVlpAmountParams) {
+    return this.context.engineClient.getMaxMintVlpAmount(params);
+  }
+
+  /**
+   * Helper to get current token balance in the user's wallet (i.e. not in a Nado subaccount)
+   */
+  async getTokenWalletBalance({
+    address,
+    ...rest
+  }: GetTokenWalletBalanceParams): Promise<bigint> {
+    const token = await this.getTokenContractForProduct(rest);
+    return token.read.balanceOf([getValidatedAddress(address)]);
+  }
+
+  /**
+   * Helper to get current token allowance
+   */
+  async getTokenAllowance({
+    address,
+    ...rest
+  }: GetTokenAllowanceParams): Promise<BigDecimal> {
+    const token = await this.getTokenContractForProduct(rest);
+    return toBigDecimal(
+      await token.read.allowance([
+        getValidatedAddress(address),
+        this.getEndpointAddress(),
+      ]),
+    );
+  }
+}

package/src/apis/spot/index.ts

@@ -0,0 +1,10 @@
+import { Mixin } from 'ts-mixer';
+import { SpotExecuteAPI } from './SpotExecuteAPI';
+import { SpotQueryAPI } from './SpotQueryAPI';
+
+/**
+ * Combined Spot trading API providing both execution and query functionality
+ */
+export class SpotAPI extends Mixin(SpotExecuteAPI, SpotQueryAPI) {}
+
+export * from './types';