@nadohq/trigger-client 0.1.0-alpha.3 → 0.1.0-alpha.31

package/src/dataMappers.ts

@@ -3,122 +3,276 @@ import {
   removeDecimals,
   toBigDecimal,
   toIntegerString,
-} from '@nadohq/utils';
+  unpackOrderAppendix,
+} from '@nadohq/shared';
 import {
+  PriceTriggerCriteria,
+  PriceTriggerRequirementType,
+  TimeTriggerCriteria,
   TriggerCriteria,
   TriggerOrder,
   TriggerOrderInfo,
   TriggerOrderStatus,
   TriggerServerOrderInfo,
   TriggerServerOrderStatus,
+  TriggerServerPriceRequirement,
+  TriggerServerPriceTriggerCriteria,
+  TriggerServerTimeTriggerCriteria,
   TriggerServerTriggerCriteria,
+  TriggerServerTwapExecutionStatus,
+  TwapExecutionStatus,
 } from './types';
 
-export function mapTriggerServerOrderStatus(
+/**
+ * Maps client-side trigger criteria to server-side trigger criteria format.
+ * Converts price and time triggers to their respective server representations
+ * with proper decimal scaling and field name transformations.
+ *
+ * @param criteria - The client-side trigger criteria (price or time based)
+ * @returns The server-formatted trigger criteria ready for API transmission
+ */
+export function mapTriggerCriteria(
+  criteria: TriggerCriteria,
+): TriggerServerTriggerCriteria {
+  switch (criteria.type) {
+    case 'price':
+      return {
+        price_trigger: mapPriceTriggerCriteria(criteria.criteria),
+      };
+    case 'time':
+      return {
+        time_trigger: mapTimeTriggerCriteria(criteria.criteria),
+      };
+  }
+}
+
+function mapPriceTriggerCriteria(
+  criteria: PriceTriggerCriteria,
+): TriggerServerPriceTriggerCriteria {
+  const priceValue = toIntegerString(addDecimals(criteria.triggerPrice));
+
+  const price_requirement = ((): TriggerServerPriceRequirement => {
+    switch (criteria.type) {
+      case 'oracle_price_above':
+        return { oracle_price_above: priceValue };
+      case 'oracle_price_below':
+        return { oracle_price_below: priceValue };
+      case 'last_price_above':
+        return { last_price_above: priceValue };
+      case 'last_price_below':
+        return { last_price_below: priceValue };
+      case 'mid_price_above':
+        return { mid_price_above: priceValue };
+      case 'mid_price_below':
+        return { mid_price_below: priceValue };
+    }
+  })();
+
+  return {
+    price_requirement,
+    dependency: criteria.dependency
+      ? {
+          digest: criteria.dependency.digest,
+          on_partial_fill: criteria.dependency.onPartialFill,
+        }
+      : undefined,
+  };
+}
+
+function mapTimeTriggerCriteria(
+  criteria: TimeTriggerCriteria,
+): TriggerServerTimeTriggerCriteria {
+  return {
+    interval: Number(criteria.interval),
+    amounts: criteria.amounts?.map((amount) => toIntegerString(amount)),
+  };
+}
+
+/**
+ * Maps complete server-side trigger order information to client-side format.
+ *
+ * @param info - The complete server-side trigger order information including order, status, and timestamps
+ * @returns The client-side trigger order information with converted values and normalized structure
+ */
+export function mapServerOrderInfo(
+  info: TriggerServerOrderInfo,
+): TriggerOrderInfo {
+  const { order: serverOrder, status, updated_at, placed_at } = info;
+  const order: TriggerOrder = {
+    amount: toBigDecimal(serverOrder.order.amount),
+    expiration: Number(serverOrder.order.expiration),
+    nonce: serverOrder.order.nonce,
+    price: removeDecimals(toBigDecimal(serverOrder.order.priceX18)),
+    digest: serverOrder.digest,
+    productId: serverOrder.product_id,
+    triggerCriteria: mapServerTriggerCriteria(serverOrder.trigger),
+    appendix: unpackOrderAppendix(serverOrder.order.appendix),
+  };
+  return {
+    serverOrder,
+    order,
+    status: mapTriggerServerOrderStatus(status),
+    updatedAt: updated_at,
+    placementTime: placed_at,
+  };
+}
+
+function mapTriggerServerOrderStatus(
   status: TriggerServerOrderStatus,
 ): TriggerOrderStatus {
-  if (status === 'pending') {
+  if (status === 'triggering') {
     return {
-      type: 'pending',
+      type: 'triggering',
+    };
+  } else if (status === 'waiting_price') {
+    return {
+      type: 'waiting_price',
+    };
+  } else if (status === 'waiting_dependency') {
+    return {
+      type: 'waiting_dependency',
     };
   } else if ('cancelled' in status) {
     return {
       type: 'cancelled',
       reason: status.cancelled,
     };
+  } else if ('triggered' in status) {
+    return {
+      type: 'triggered',
+      result: status.triggered,
+    };
   } else if ('internal_error' in status) {
     return {
       type: 'internal_error',
       error: status.internal_error,
     };
-  } else if ('triggered' in status) {
+  } else if ('twap_executing' in status) {
     return {
-      type: 'triggered',
-      result: status.triggered,
+      type: 'twap_executing',
+      currentExecution: status.twap_executing.current_execution,
+      totalExecutions: status.twap_executing.total_executions,
+    };
+  } else if ('twap_completed' in status) {
+    return {
+      type: 'twap_completed',
+      executed: status.twap_completed.executed,
+      total: status.twap_completed.total,
     };
   }
   throw Error(`Unknown trigger order status: ${JSON.stringify(status)}`);
 }
 
-export function mapTriggerCriteria(
-  criteria: TriggerCriteria,
-): TriggerServerTriggerCriteria {
-  const priceValue = toIntegerString(addDecimals(criteria.triggerPrice));
-  switch (criteria.type) {
-    case 'oracle_price_above':
-      return { price_above: priceValue };
-    case 'oracle_price_below':
-      return { price_below: priceValue };
-    case 'last_price_above':
-      return { last_price_above: priceValue };
-    case 'last_price_below':
-      return { last_price_below: priceValue };
-    case 'mid_price_above':
-      return { mid_price_above: priceValue };
-    case 'mid_price_below':
-      return { mid_price_below: priceValue };
-  }
-}
-
-export function mapServerTriggerCriteria(
+function mapServerTriggerCriteria(
   criteria: TriggerServerTriggerCriteria,
 ): TriggerCriteria {
-  if ('price_above' in criteria) {
+  if ('price_trigger' in criteria) {
     return {
-      type: 'oracle_price_above',
-      triggerPrice: removeDecimals(criteria.price_above),
+      type: 'price',
+      criteria: mapServerPriceTriggerCriteria(criteria.price_trigger),
     };
   }
-  if ('price_below' in criteria) {
+  if ('time_trigger' in criteria) {
     return {
-      type: 'oracle_price_below',
-      triggerPrice: removeDecimals(criteria.price_below),
+      type: 'time',
+      criteria: mapServerTimeTriggerCriteria(criteria.time_trigger),
     };
   }
-  if ('last_price_above' in criteria) {
+  throw new Error(`Unknown trigger criteria: ${JSON.stringify(criteria)}`);
+}
+
+function mapServerPriceTriggerCriteria(
+  serverCriteria: TriggerServerPriceTriggerCriteria,
+): PriceTriggerCriteria {
+  const { price_requirement, dependency } = serverCriteria;
+
+  const { type, triggerPrice } = ((): {
+    type: PriceTriggerRequirementType;
+    triggerPrice: string;
+  } => {
+    if ('oracle_price_above' in price_requirement) {
+      return {
+        type: 'oracle_price_above',
+        triggerPrice: price_requirement.oracle_price_above,
+      };
+    } else if ('oracle_price_below' in price_requirement) {
+      return {
+        type: 'oracle_price_below',
+        triggerPrice: price_requirement.oracle_price_below,
+      };
+    } else if ('last_price_above' in price_requirement) {
+      return {
+        type: 'last_price_above',
+        triggerPrice: price_requirement.last_price_above,
+      };
+    } else if ('last_price_below' in price_requirement) {
+      return {
+        type: 'last_price_below',
+        triggerPrice: price_requirement.last_price_below,
+      };
+    } else if ('mid_price_above' in price_requirement) {
+      return {
+        type: 'mid_price_above',
+        triggerPrice: price_requirement.mid_price_above,
+      };
+    } else if ('mid_price_below' in price_requirement) {
+      return {
+        type: 'mid_price_below',
+        triggerPrice: price_requirement.mid_price_below,
+      };
+    } else {
+      throw new Error(
+        `Unknown price requirement: ${JSON.stringify(price_requirement)}`,
+      );
+    }
+  })();
+
+  return {
+    type,
+    triggerPrice: removeDecimals(triggerPrice),
+    dependency: dependency
+      ? {
+          digest: dependency.digest,
+          onPartialFill: dependency.on_partial_fill,
+        }
+      : undefined,
+  };
+}
+
+function mapServerTimeTriggerCriteria(
+  serverCriteria: TriggerServerTimeTriggerCriteria,
+): TimeTriggerCriteria {
+  return {
+    interval: toBigDecimal(serverCriteria.interval),
+    amounts: serverCriteria.amounts?.map((amount: string) =>
+      toBigDecimal(amount),
+    ),
+  };
+}
+
+export function mapTwapExecutionStatus(
+  status: TriggerServerTwapExecutionStatus,
+): TwapExecutionStatus {
+  if (status === 'pending') {
     return {
-      type: 'last_price_above',
-      triggerPrice: removeDecimals(criteria.last_price_above),
+      type: 'pending',
     };
-  }
-  if ('last_price_below' in criteria) {
+  } else if ('executed' in status) {
     return {
-      type: 'last_price_below',
-      triggerPrice: removeDecimals(criteria.last_price_below),
+      type: 'executed',
+      executedTime: status.executed.executed_time,
+      executeResponse: status.executed.execute_response,
     };
-  }
-  if ('mid_price_above' in criteria) {
+  } else if ('failed' in status) {
     return {
-      type: 'mid_price_above',
-      triggerPrice: removeDecimals(criteria.mid_price_above),
+      type: 'failed',
+      error: status.failed,
     };
-  }
-  if ('mid_price_below' in criteria) {
+  } else if ('cancelled' in status) {
     return {
-      type: 'mid_price_below',
-      triggerPrice: removeDecimals(criteria.mid_price_below),
+      type: 'cancelled',
+      reason: status.cancelled,
     };
   }
-  throw new Error(`Unknown trigger criteria: ${JSON.stringify(criteria)}`);
-}
-
-export function mapServerOrderInfo(
-  info: TriggerServerOrderInfo,
-): TriggerOrderInfo {
-  const { order: serverOrder, status, updated_at } = info;
-  const order: TriggerOrder = {
-    amount: toBigDecimal(serverOrder.order.amount),
-    expiration: toBigDecimal(serverOrder.order.expiration),
-    nonce: serverOrder.order.nonce,
-    price: removeDecimals(toBigDecimal(serverOrder.order.priceX18)),
-    digest: serverOrder.digest,
-    productId: serverOrder.product_id,
-    triggerCriteria: mapServerTriggerCriteria(serverOrder.trigger),
-  };
-  return {
-    serverOrder,
-    order,
-    status: mapTriggerServerOrderStatus(status),
-    updatedAt: updated_at,
-  };
+  throw Error(`Unknown TWAP execution status: ${JSON.stringify(status)}`);
 }

package/src/endpoints.ts

@@ -1,7 +1,7 @@
-import { ChainEnv } from '@nadohq/contracts';
+import { ChainEnv } from '@nadohq/shared';
 
 export const TRIGGER_CLIENT_ENDPOINTS: Record<ChainEnv, string> = {
   local: 'http://localhost:80/trigger',
-  arbitrumTestnet: 'https://trigger.sepolia-test.vertexprotocol.com/v1',
   arbitrum: 'https://trigger.prod.vertexprotocol.com/v1',
+  inkTestnet: 'https://trigger.test.nado-backend.xyz/v1',
 };

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from './types';
-export * from './TriggerClient';
 export * from './endpoints';
+export * from './TriggerClient';
+export * from './types';

package/src/types/TriggerServerFailureError.ts

@@ -1,5 +1,5 @@
-import { TriggerServerQueryFailureResponse } from './serverQueryTypes';
 import { EngineServerExecuteFailureResult } from '@nadohq/engine-client';
+import { TriggerServerQueryFailureResponse } from './serverQueryTypes';
 
 export class TriggerServerFailureError extends Error {
   constructor(
@@ -7,6 +7,6 @@ export class TriggerServerFailureError extends Error {
       | TriggerServerQueryFailureResponse
       | EngineServerExecuteFailureResult,
   ) {
-    super();
+    super(`${responseData.error_code}: ${responseData.error}`);
   }
 }

package/src/types/clientModelTypes.ts

@@ -0,0 +1,95 @@
+import { EngineServerExecuteResult } from '@nadohq/engine-client';
+import { BigDecimalish } from '@nadohq/shared';
+
+/*
+Price trigger
+ */
+
+export type PriceTriggerRequirementType =
+  | 'oracle_price_above'
+  | 'oracle_price_below'
+  | 'last_price_above'
+  | 'last_price_below'
+  | 'mid_price_above'
+  | 'mid_price_below';
+
+export interface PriceTriggerDependency {
+  /**
+   * Digest of the order that this trigger depends on.
+   */
+  digest: string;
+  /**
+   * Whether to trigger on partial fills.
+   */
+  onPartialFill: boolean;
+}
+
+export interface PriceTriggerCriteria {
+  type: PriceTriggerRequirementType;
+  triggerPrice: BigDecimalish;
+  dependency?: PriceTriggerDependency;
+}
+
+/*
+Time trigger (for TWAP)
+ */
+
+export interface TimeTriggerCriteria {
+  /**
+   * For TWAP: Trigger interval in seconds
+   */
+  interval: BigDecimalish;
+  /**
+   * For TWAP: By default, trigger service will split up orders as per total amount / interval
+   * If you want to specify the amounts for each interval, you can provide them here.
+   */
+  amounts?: BigDecimalish[];
+}
+
+/**
+ * All possible trigger conditions that can be used to place a trigger order.
+ */
+export type TriggerCriteria =
+  | {
+      type: 'price';
+      criteria: PriceTriggerCriteria;
+    }
+  | {
+      type: 'time';
+      criteria: TimeTriggerCriteria;
+    };
+
+export type TriggerCriteriaType = TriggerCriteria['type'];
+
+export type TriggerOrderStatus =
+  | {
+      type: 'cancelled';
+      reason: string;
+    }
+  | {
+      type: 'triggered';
+      result: EngineServerExecuteResult;
+    }
+  | {
+      type: 'internal_error';
+      error: string;
+    }
+  | {
+      type: 'triggering';
+    }
+  | {
+      type: 'waiting_price';
+    }
+  | {
+      type: 'waiting_dependency';
+    }
+  | {
+      type: 'twap_executing';
+      currentExecution: number;
+      totalExecutions: number;
+    }
+  | {
+      type: 'twap_completed';
+      executed: number;
+      total: number;
+    };

package/src/types/clientTypes.ts

@@ -1,49 +1,28 @@
 import {
+  EngineOrderParams,
+  EngineServerExecuteResult,
+} from '@nadohq/engine-client';
+import {
+  BigDecimal,
   EIP712CancelOrdersParams,
   EIP712CancelProductOrdersParams,
+  OrderAppendix,
   Subaccount,
-} from '@nadohq/contracts';
+} from '@nadohq/shared';
+import { TriggerCriteria, TriggerOrderStatus } from './clientModelTypes';
 import {
-  EngineOrderParams,
-  EngineServerExecuteResult,
-} from '@nadohq/engine-client';
-import { BigDecimal, BigDecimalish } from '@nadohq/utils';
-import { TriggerServerOrder } from './serverQueryTypes';
+  TriggerServerOrder,
+  TriggerServerStatusTypeFilter,
+  TriggerServerTriggerTypeFilter,
+} from './serverQueryTypes';
 
 type WithOptionalNonce<T> = Omit<T, 'nonce'> & { nonce?: string };
 
-export type TriggerCriteriaType =
-  | 'oracle_price_above'
-  | 'oracle_price_below'
-  | 'last_price_above'
-  | 'last_price_below'
-  | 'mid_price_above'
-  | 'mid_price_below';
-
-export type TriggerCriteria = {
-  type: TriggerCriteriaType;
-  triggerPrice: BigDecimalish;
-};
-
-export type TriggerOrderStatus =
-  | {
-      type: 'pending';
-    }
-  | {
-      type: 'cancelled';
-      reason: string;
-    }
-  | {
-      type: 'triggered';
-      result: EngineServerExecuteResult;
-    }
-  | {
-      type: 'internal_error';
-      error: string;
-    };
-
 interface SignatureParams {
-  // Orderbook address for placement, endpoint address for cancellation & listing
+  /**
+   * Address derived from productId for placement (see getOrderVerifyingAddr)
+   * endpoint address for cancellation & listing
+   */
   verifyingAddr: string;
   chainId: number;
 }
@@ -59,10 +38,21 @@ export interface TriggerPlaceOrderParams extends SignatureParams {
   triggerCriteria: TriggerCriteria;
   // If not given, engine defaults to true (leverage/borrow enabled)
   spotLeverage?: boolean;
+  // For isolated orders, this specifies whether margin can be borrowed (i.e. whether the cross account can have a negative USDT balance)
+  borrowMargin?: boolean;
   digest?: string;
   nonce?: string;
 }
 
+export interface TriggerPlaceOrdersParams {
+  orders: TriggerPlaceOrderParams[];
+  /**
+   * If `true`, aborts the batch after the first failed order; if `false`, remaining orders continue to execute.
+   * If not provided, the default value is `false`.
+   */
+  cancelOnFailure?: boolean;
+}
+
 export type TriggerCancelOrdersParams = SignatureParams &
   WithOptionalNonce<EIP712CancelOrdersParams>;
 
@@ -77,14 +67,18 @@ export interface TriggerListOrdersParams extends Subaccount, SignatureParams {
   // In millis, defaults to 90s in the future
   recvTime?: BigDecimal;
   // If not given, defaults to all products
-  productId?: number;
-  // Pending trigger orders only, ignores cancelled & triggered orders
-  pending: boolean;
+  productIds?: number[];
   // In seconds
   maxUpdateTimeInclusive?: number;
   // When provided, the associated trigger orders are returned regardless of other filters
   digests?: string[];
   limit?: number;
+  // Filter by status types
+  statusTypes?: TriggerServerStatusTypeFilter[];
+  // Filter by trigger types
+  triggerTypes?: TriggerServerTriggerTypeFilter[];
+  // Filter by reduce-only orders
+  reduceOnly?: boolean;
 }
 
 export interface TriggerOrder {
@@ -92,9 +86,10 @@ export interface TriggerOrder {
   triggerCriteria: TriggerCriteria;
   price: BigDecimal;
   amount: BigDecimal;
-  expiration: BigDecimal;
+  expiration: number;
   nonce: string;
   digest: string;
+  appendix: OrderAppendix;
 }
 
 export interface TriggerOrderInfo {
@@ -102,8 +97,42 @@ export interface TriggerOrderInfo {
   serverOrder: TriggerServerOrder;
   status: TriggerOrderStatus;
   updatedAt: number;
+  placementTime: number;
 }
 
 export interface TriggerListOrdersResponse {
   orders: TriggerOrderInfo[];
 }
+
+export interface TriggerListTwapExecutionsParams {
+  digest: string;
+}
+
+export type TwapExecutionStatus =
+  | {
+      type: 'pending';
+    }
+  | {
+      type: 'executed';
+      executedTime: number;
+      executeResponse: EngineServerExecuteResult;
+    }
+  | {
+      type: 'failed';
+      error: string;
+    }
+  | {
+      type: 'cancelled';
+      reason: string;
+    };
+
+export interface TwapExecutionInfo {
+  executionId: number;
+  scheduledTime: number;
+  status: TwapExecutionStatus;
+  updatedAt: number;
+}
+
+export interface TriggerListTwapExecutionsResponse {
+  executions: TwapExecutionInfo[];
+}

package/src/types/index.ts

@@ -1,4 +1,6 @@
+export * from './clientModelTypes';
 export * from './clientTypes';
 export * from './serverExecuteTypes';
+export * from './serverModelTypes';
 export * from './serverQueryTypes';
 export * from './TriggerServerFailureError';

package/src/types/serverExecuteTypes.ts

@@ -1,32 +1,10 @@
-import { EIP712OrderValues } from '@nadohq/contracts';
 import {
   EngineServerExecuteFailureResult,
   EngineServerExecuteRequestByType,
   EngineServerExecuteSuccessResult,
 } from '@nadohq/engine-client';
-
-export type TriggerServerTriggerCriteria =
-  // These trigger on fast oracle price
-  | {
-      price_above: string;
-    }
-  | {
-      price_below: string;
-    }
-  // These trigger on last trade price
-  | {
-      last_price_above: string;
-    }
-  | {
-      last_price_below: string;
-    }
-  // These trigger on mid-book price
-  | {
-      mid_price_above: string;
-    }
-  | {
-      mid_price_below: string;
-    };
+import { EIP712OrderValues } from '@nadohq/shared';
+import { TriggerServerTriggerCriteria } from './serverModelTypes';
 
 export interface TriggerServerPlaceOrderParams {
   id: number | null;
@@ -37,6 +15,7 @@ export interface TriggerServerPlaceOrderParams {
   digest: string | null;
   // Trigger service defaults this to true
   spot_leverage: boolean | null;
+  borrow_margin: boolean | null;
 }
 
 export type TriggerServerCancelOrdersParams =
@@ -45,8 +24,14 @@ export type TriggerServerCancelOrdersParams =
 export type TriggerServerCancelProductOrdersParams =
   EngineServerExecuteRequestByType['cancel_product_orders'];
 
+export interface TriggerServerPlaceOrdersParams {
+  orders: TriggerServerPlaceOrderParams[];
+  cancel_on_failure: boolean | null;
+}
+
 export interface TriggerServerExecuteRequestByType {
   place_order: TriggerServerPlaceOrderParams;
+  place_orders: TriggerServerPlaceOrdersParams;
   cancel_orders: TriggerServerCancelOrdersParams;
   cancel_product_orders: TriggerServerCancelProductOrdersParams;
 }