@reyaxyz/common 0.362.0 → 0.363.0

package/src/transactions/sign.ts

@@ -7,13 +7,7 @@ import {
 } from 'ethers';
 import { ContractType, getAddress } from './contractAddresses';
 import { Command } from './action';
-import {
-  Address,
-  ConditionalOrderStatus,
-  ConditionalOrderType,
-  OrdersGatewayOrderType,
-  ReyaChainId,
-} from '../types';
+import { Address, OrderType, ReyaChainId } from '../types';
 
 export type EIP712Signature = {
   v: number;
@@ -177,140 +171,28 @@ export function getReyaDomain(verifyingContract: string) {
   };
 }
 
-const conditionalOrderTypes = {
-  ConditionalOrder: [
-    { name: 'verifyingChainId', type: 'uint256' },
-    { name: 'deadline', type: 'uint256' },
-    { name: 'order', type: 'ConditionalOrderDetails' },
-  ],
-  ConditionalOrderDetails: [
-    { name: 'accountId', type: 'uint128' },
-    { name: 'marketId', type: 'uint128' },
-    { name: 'exchangeId', type: 'uint128' },
-    { name: 'counterpartyAccountIds', type: 'uint128[]' },
-    { name: 'orderType', type: 'uint8' },
-    { name: 'inputs', type: 'bytes' },
-    { name: 'signer', type: 'address' },
-    { name: 'nonce', type: 'uint256' },
-  ],
-};
-
-export function createOrdersGatewayOrderNonce(
-  accountId: number,
-  marketId: number,
-  timestampMs: number,
-): bigint {
-  // Validate the input ranges
-  if (marketId < 0 || marketId >= 2 ** 32)
-    throw new Error('marketId is out of range');
-  if (accountId < 0 || accountId >= 2 ** 128)
-    throw new Error('accountId is out of range');
-  if (timestampMs < 0 || timestampMs >= 2 ** 64)
-    throw new Error('timestamp is out of range');
-
-  const hashUint256 =
-    (BigInt(accountId) << BigInt(98)) |
-    (BigInt(timestampMs) << BigInt(32)) |
-    BigInt(marketId);
-
-  return hashUint256;
-}
-
-type SignOrdersGatewayOrderOutput = {
-  serializedSignature: string;
-  nonce: bigint;
-  signature: EIP712Signature;
-};
-
-export async function signOrdersGatewayOrder(
-  signer: Signer | JsonRpcSigner,
-  reyaChainId: ReyaChainId,
-  accountId: number,
-  marketId: number,
-  exchangeId: number,
-  counterpartyAccountIds: number[],
-  orderType: ConditionalOrderType | OrdersGatewayOrderType,
-  inputs: string,
-  deadline: number,
-  creationTimestampMs: number,
-  customNonce?: bigint,
-): Promise<SignOrdersGatewayOrderOutput> {
-  const nonce =
-    customNonce ??
-    createOrdersGatewayOrderNonce(accountId, marketId, creationTimestampMs);
-
-  const signature = await signReyaTypedData(
-    signer,
-    getAddress(reyaChainId, ContractType.ORDERS_GATEWAY_PROXY),
-    conditionalOrderTypes,
-    {
-      verifyingChainId: reyaChainId,
-      deadline: BigInt(deadline),
-      order: {
-        accountId: accountId,
-        marketId: marketId,
-        exchangeId: exchangeId,
-        counterpartyAccountIds: counterpartyAccountIds,
-        orderType: orderType,
-        inputs: inputs,
-        signer: await signer.getAddress(),
-        nonce: nonce,
-      },
-    },
-  );
-
-  return {
-    serializedSignature: signature.serialized,
-    nonce,
-    signature: convertEthersSignatureToEIP712Signature(signature, deadline),
-  };
-}
-
-export function isConditionalOrderSignatureValid(
-  signerAddress: string,
-  signature: string,
-  reyaChainId: ReyaChainId,
-  accountId: number,
-  marketId: number,
-  exchangeId: number,
-  counterpartyAccountIds: number[],
-  orderType: number,
-  inputs: string,
-  nonce: bigint,
-  deadline: number,
-): boolean {
-  // Encode the data for recovering the address
-  const domain = getReyaDomain(
-    getAddress(reyaChainId, ContractType.CONDITIONAL_ORDERS_PROXY),
-  );
-
-  const value = {
-    verifyingChainId: reyaChainId,
-    deadline: BigInt(deadline),
-    order: {
-      accountId: accountId,
-      marketId: marketId,
-      exchangeId: exchangeId,
-      counterpartyAccountIds: counterpartyAccountIds,
-      orderType: orderType,
-      inputs: inputs,
-      signer: signerAddress,
-      nonce: nonce,
-    },
-  };
-
-  // Recover the address
-  const recoveredAddress = verifyTypedData(
-    domain,
-    conditionalOrderTypes,
-    value,
-    signature,
-  );
-
-  return recoveredAddress.toLowerCase() === signerAddress.toLowerCase();
-}
-
-const orderCancelTypes = {
+// PRO-126 Bug 5 retired the legacy `ConditionalOrderDetails` typehash +
+// `signOrdersGatewayOrder` / `isConditionalOrderSignatureValid` /
+// `createOrdersGatewayOrderNonce` helpers. The on-chain
+// `OrdersGateway.execute` selector that consumed those signatures is
+// gone; every order class now signs the new flat `OrderDetails` schema
+// via `signOrder` further down this file.
+
+// The three cancel-side typed-data schemas below are EXPORTED as the single
+// source of truth for signer AND verifier — common-backend's
+// `recover{OrderCancel,MassCancel,CancelAllAfter}Signer` import them from
+// here (like `orderTypes` for the Order struct). They used to be duplicated
+// module-private consts on each side; any drift (field rename / width /
+// reorder) silently breaks 100% of signature recovery for that request
+// class, so exactly one copy may exist.
+
+/**
+ * EIP-712 typed-data structures for the OrderCancel signature scheme used by
+ * the matching engine for order cancellations. The signer signs over a value
+ * of shape
+ * `{ verifyingChainId, deadline, cancel: { accountId, marketId, orderId, clOrdId, nonce } }`.
+ */
+export const orderCancelTypes = {
   OrderCancel: [
     { name: 'verifyingChainId', type: 'uint64' },
     { name: 'deadline', type: 'uint64' },
@@ -325,7 +207,12 @@ const orderCancelTypes = {
   ],
 };
 
-const massCancelTypes = {
+/**
+ * EIP-712 typed-data structures for the MassCancel signature scheme used by
+ * the matching engine for mass cancellations. The signer signs over a value
+ * of shape `{ verifyingChainId, deadline, massCancel: { accountId, marketId, nonce } }`.
+ */
+export const massCancelTypes = {
   MassCancel: [
     { name: 'verifyingChainId', type: 'uint64' },
     { name: 'deadline', type: 'uint64' },
@@ -338,6 +225,26 @@ const massCancelTypes = {
   ],
 };
 
+/**
+ * EIP-712 typed-data structures for the CancelAllAfter signature scheme used
+ * by the matching engine for the cancel-on-disconnect dead-man's-switch. The
+ * signer signs over a value of shape
+ * `{ verifyingChainId, deadline, cancelAllAfter: { accountId, timeoutMs, nonce } }`.
+ * uint64 throughout, matching the OrderCancel / MassCancel family.
+ */
+export const cancelAllAfterTypes = {
+  CancelAllAfter: [
+    { name: 'verifyingChainId', type: 'uint64' },
+    { name: 'deadline', type: 'uint64' },
+    { name: 'cancelAllAfter', type: 'CancelAllAfterDetails' },
+  ],
+  CancelAllAfterDetails: [
+    { name: 'accountId', type: 'uint64' },
+    { name: 'timeoutMs', type: 'uint64' },
+    { name: 'nonce', type: 'uint64' },
+  ],
+};
+
 type SignCancelOutput = {
   serializedSignature: string;
   nonce: bigint;
@@ -408,16 +315,183 @@ export async function signMassCancel(
   };
 }
 
-export async function signCancelConditionalOrder(
+// -----------------------------------------------------------------------------
+// perpOB: EIP-712 typed data for the flat `Order` / `OrderDetails` struct
+// -----------------------------------------------------------------------------
+// Matches the post-audit on-chain redesign in
+// reya-network/feat/perpOB (orders-gateway/src/libraries/DataTypes.sol +
+// ConditionalOrderHashing.sol). PRO-126 Bug 5 retired the legacy
+// `conditionalOrderTypes` / `signOrdersGatewayOrder` / `isConditionalOrderSignatureValid`
+// surface that this struct replaced — every order class (spot + perp,
+// IOC + GTC + TP + SL) now signs against `OrderDetails` here.
+//
+// Contract: Order envelope + flat OrderDetails inner struct. Two distinct time
+// values are signed:
+//   - envelope `deadline`  -> signature validity, enforced by API at entry
+//   - inner   `expiresAfter` -> order lifetime, enforced on-chain at execution
+// Convention: callers should set `deadline <= expiresAfter` when `expiresAfter > 0`.
+// See reya-api-specs/docs/eip712.md for the canonical description.
+
+export const orderTypes = {
+  Order: [
+    { name: 'verifyingChainId', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+    { name: 'order', type: 'OrderDetails' },
+  ],
+  OrderDetails: [
+    { name: 'accountId', type: 'uint128' },
+    { name: 'marketId', type: 'uint128' },
+    { name: 'exchangeId', type: 'uint128' },
+    { name: 'orderType', type: 'uint8' },
+    { name: 'quantity', type: 'int256' },
+    { name: 'limitPrice', type: 'uint256' },
+    { name: 'triggerPrice', type: 'uint256' },
+    { name: 'timeInForce', type: 'uint8' },
+    { name: 'clientOrderId', type: 'uint64' },
+    { name: 'reduceOnly', type: 'bool' },
+    { name: 'postOnly', type: 'bool' },
+    { name: 'expiresAfter', type: 'uint256' },
+    { name: 'signer', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+  ],
+};
+
+/**
+ * Full-position stop sentinel — `type(int256).max` (2^255 − 1), mirroring
+ * `FULL_POSITION_STOP_SENTINEL` in the OrdersGateway (reya-network #738). A
+ * STOP_LOSS / TAKE_PROFIT signs quantity `±sentinel` (the sign carries the
+ * close side: −sentinel sells out a long, +sentinel buys back a short); the
+ * chain enforces the iff — a stop with any other quantity (including the old
+ * quantity-0 encoding) reverts, and the sentinel magnitude is reserved (a
+ * non-stop signing it reverts). Raw int256 value, NOT E18-scaled. Signer and
+ * verifier must derive it from THIS constant so they can never drift.
+ */
+export const FULL_POSITION_STOP_SENTINEL =
+  (BigInt(1) << BigInt(255)) - BigInt(1);
+
+/** The signed quantity for a full-position stop: sign carries the close side. */
+export function fullPositionStopQuantity(isBuy: boolean): bigint {
+  return isBuy ? FULL_POSITION_STOP_SENTINEL : -FULL_POSITION_STOP_SENTINEL;
+}
+
+export type SignOrderParams = {
+  /** Unified market id: core_id for perp, core_id + 1e10 for spot. */
+  accountId: number;
+  marketId: number;
+  exchangeId: number;
+  orderType: OrderType;
+  /**
+   * Signed: positive = buy/long, negative = sell/short. For STOP_LOSS /
+   * TAKE_PROFIT this must be `fullPositionStopQuantity(isBuy)` — the
+   * ±int256.max full-position sentinel, never a real size and never 0.
+   */
+  quantity: bigint;
+  limitPrice: bigint;
+  /** Must be 0n for Limit; must be non-zero for StopLoss / TakeProfit. */
+  triggerPrice: bigint;
+  /** 0 = GTC, 1 = IOC, 2 = GTT. Signed but not on-chain-enforced. */
+  timeInForce: number;
+  /** Signed but not on-chain-enforced. Off-chain correlation id. */
+  clientOrderId: bigint;
+  reduceOnly: boolean;
+  /**
+   * Maker-only intent, signed into OrderDetails (api-specs 3.0.1 / on-chain
+   * Phase 0). Optional for back-compat: omitted ⇒ signed as `false`, so
+   * existing signers keep producing valid signatures. Must equal the
+   * client's intent for recovery to match.
+   */
+  postOnly?: boolean;
+  /** 0n = good-until-cancelled. On-chain-enforced at execution. */
+  expiresAfter: bigint;
+  nonce: bigint;
+  /** EIP-712 envelope signature deadline (unix seconds). API-enforced at entry. */
+  deadline: number;
+};
+
+export type SignOrderOutput = {
+  serializedSignature: string;
+  signature: EIP712Signature;
+};
+
+export async function signOrder(
   signer: Signer | JsonRpcSigner,
-  orderId: string,
-): Promise<string> {
-  const message = {
-    orderId: orderId,
-    status: ConditionalOrderStatus.CANCELLED,
-    actionType: 'changeStatus',
+  reyaChainId: ReyaChainId,
+  params: SignOrderParams,
+): Promise<SignOrderOutput> {
+  const signature = await signReyaTypedData(
+    signer,
+    getAddress(reyaChainId, ContractType.ORDERS_GATEWAY_PROXY),
+    orderTypes,
+    {
+      verifyingChainId: reyaChainId,
+      deadline: BigInt(params.deadline),
+      order: {
+        accountId: params.accountId,
+        marketId: params.marketId,
+        exchangeId: params.exchangeId,
+        orderType: params.orderType,
+        quantity: params.quantity,
+        limitPrice: params.limitPrice,
+        triggerPrice: params.triggerPrice,
+        timeInForce: params.timeInForce,
+        clientOrderId: params.clientOrderId,
+        reduceOnly: params.reduceOnly,
+        postOnly: params.postOnly ?? false,
+        expiresAfter: params.expiresAfter,
+        signer: await signer.getAddress(),
+        nonce: params.nonce,
+      },
+    },
+  );
+
+  return {
+    serializedSignature: signature.serialized,
+    signature: convertEthersSignatureToEIP712Signature(
+      signature,
+      params.deadline,
+    ),
   };
-  return await signer.signMessage(JSON.stringify(message));
+}
+
+export function isOrderSignatureValid(
+  signerAddress: string,
+  signature: string,
+  reyaChainId: ReyaChainId,
+  params: SignOrderParams,
+): boolean {
+  const domain = getReyaDomain(
+    getAddress(reyaChainId, ContractType.ORDERS_GATEWAY_PROXY),
+  );
+
+  const value = {
+    verifyingChainId: reyaChainId,
+    deadline: BigInt(params.deadline),
+    order: {
+      accountId: params.accountId,
+      marketId: params.marketId,
+      exchangeId: params.exchangeId,
+      orderType: params.orderType,
+      quantity: params.quantity,
+      limitPrice: params.limitPrice,
+      triggerPrice: params.triggerPrice,
+      timeInForce: params.timeInForce,
+      clientOrderId: params.clientOrderId,
+      reduceOnly: params.reduceOnly,
+      postOnly: params.postOnly ?? false,
+      expiresAfter: params.expiresAfter,
+      signer: signerAddress,
+      nonce: params.nonce,
+    },
+  };
+
+  const recoveredAddress = verifyTypedData(
+    domain,
+    orderTypes,
+    value,
+    signature,
+  );
+
+  return recoveredAddress.toLowerCase() === signerAddress.toLowerCase();
 }
 
 export async function signGrantPermission(
@@ -522,6 +596,88 @@ export async function signRevokePermission(
   return convertEthersSignatureToEIP712Signature(signature, deadline);
 }
 
+export async function signMEOrderCancel(
+  signer: Signer | JsonRpcSigner,
+  reyaChainId: ReyaChainId,
+  accountId: number,
+  marketId: number,
+  orderId: bigint,
+  clOrdId: bigint,
+  nonce: bigint,
+  deadline: number,
+): Promise<string> {
+  const signature = await signReyaTypedData(
+    signer,
+    getAddress(reyaChainId, ContractType.ORDERS_GATEWAY_PROXY),
+    orderCancelTypes,
+    {
+      verifyingChainId: reyaChainId,
+      deadline: BigInt(deadline),
+      cancel: {
+        accountId: accountId,
+        marketId: marketId,
+        orderId: orderId,
+        clOrdId: clOrdId,
+        nonce: nonce,
+      },
+    },
+  );
+
+  return signature.serialized;
+}
+
+export async function signMEMassCancel(
+  signer: Signer | JsonRpcSigner,
+  reyaChainId: ReyaChainId,
+  accountId: number,
+  marketId: number,
+  nonce: bigint,
+  deadline: number,
+): Promise<string> {
+  const signature = await signReyaTypedData(
+    signer,
+    getAddress(reyaChainId, ContractType.ORDERS_GATEWAY_PROXY),
+    massCancelTypes,
+    {
+      verifyingChainId: reyaChainId,
+      deadline: BigInt(deadline),
+      massCancel: {
+        accountId: accountId,
+        marketId: marketId,
+        nonce: nonce,
+      },
+    },
+  );
+
+  return signature.serialized;
+}
+
+export async function signMECancelAllAfter(
+  signer: Signer | JsonRpcSigner,
+  reyaChainId: ReyaChainId,
+  accountId: number,
+  timeoutMs: number,
+  nonce: bigint,
+  deadline: number,
+): Promise<string> {
+  const signature = await signReyaTypedData(
+    signer,
+    getAddress(reyaChainId, ContractType.ORDERS_GATEWAY_PROXY),
+    cancelAllAfterTypes,
+    {
+      verifyingChainId: reyaChainId,
+      deadline: BigInt(deadline),
+      cancelAllAfter: {
+        accountId: accountId,
+        timeoutMs: timeoutMs,
+        nonce: nonce,
+      },
+    },
+  );
+
+  return signature.serialized;
+}
+
 export const signManagePermissionBySig = async (
   signer: Signer | JsonRpcSigner,
   signerAddress: string,