[오르자] 유저들의 지정가 주문은 어떻게 관리할까?

        브라우저
          ↓ POST /api/orders
        ORZA 서버
          ↓ Firestore 트랜잭션
        사용자 주문 문서 + 워커 인덱스
          ↓
        ORZA Worker의 가격 스트림
          ↓ 조건 충족
        체결 트랜잭션
          ↓
        포지션·거래 내역·잔고·주문 상태 갱신

        // lib/trading/service.ts의 createOrder 흐름
        const limitPrice = input.orderType === "limit"
          ? assertPositive("limitPrice", input.limitPrice)
          : undefined

        const orderStatus = input.orderType === "market"
          ? "filled"
          : "pending"

        const order = {
          userId: uid,
          accountId,
          symbol,
          direction: input.direction,
          orderType: input.orderType,
          status: orderStatus,
          limitPrice,
          quantity: normalizedQuantity,
          notional,
          leverage,
          margin,
          fee,
          createdAt: ts,
          updatedAt: ts,
        }

        users/{uid}/orders/{orderId}
        users/{uid}/state/current.orders.{orderId}
        workerPendingLimitOrders/{uid}_{accountId}_{orderId}

        const marketable =
          marketPrice != null &&
          (input.direction === "up"
            ? marketPrice <= limitPrice
            : marketPrice >= limitPrice)

        if (marketable) {
          fillPrice = await fetchExecutionPrice(symbol, input.direction)
          orderStatus = "filled"
        }

        // components/perp-terminal/advanced-terminal.tsx
        const parsedAmount = parsePositiveNumber(amount)
        const parsedLimitPrice = parsePositiveNumber(limitPrice)
        const orderPrice = orderKind === "market"
          ? referenceMark
          : parsedLimitPrice
        const notional = parsedAmount * orderPrice
        const marginRequired = reduceOnly
          ? 0
          : notional / effectiveLeverage

        if (orderKind === "limit" && parsedLimitPrice <= 0) {
          setStatusMsg({
            kind: "error",
            text: "Enter a valid limit price.",
          })
          return
        }

        // 프론트엔드 → ORZA paper API
        await placePaperOrder({
          leverage,
          orderKind,
          price: orderPrice,
          quantity: orderAmount,
          side,
          symbol: marketSymbol,
        })

        async function placePaperOrder(input) {
          await paperJson("order", {
            direction: input.side === "long" ? "up" : "down",
            limitPrice: input.orderKind === "limit"
              ? input.price
              : undefined,
            orderType: input.orderKind,
            quantity: input.quantity,
            leverage: input.leverage,
            symbol: input.symbol,
          })
        }

        주문창 입력
          → 금액·증거금·입력값 미리 계산
          → POST /api/dex/paper/order
          → 서버가 pending 또는 filled 확정
          → paper/state 재조회
          → 주문 목록·차트 주문선·포지션 화면 갱신

        async function replaceOrder(order, nextPrice) {
          const remaining = Math.max(order.amount - order.filled, 0)
          await cancelPaperOrder(order)
          await placePaperOrder({
            leverage,
            orderKind: "limit",
            price: nextPrice,
            quantity: remaining,
            side: order.side === "buy" ? "long" : "short",
            symbol: order.symbol,
          })
        }

        // orza-worker/src/positionIndex.ts
        db()
          .collection("workerPendingLimitOrders")
          .onSnapshot((snap) => {
            for (const change of snap.docChanges()) {
              const order = change.doc.data()

              if (change.type === "removed") {
                deleteOpenOrder(order.orderId)
              } else {
                addIndexedOpenOrder(change.doc.id, order)
              }
            }
          })

        BTCUSDT → [주문 A, 주문 B, 주문 C]
        ETHUSDT → [주문 D, 주문 E]

        // orza-worker/src/index.ts
        function evaluateCandidates(symbol: string, price: number) {
          for (const order of getOpenOrderCandidates(symbol)) {
            if (!order.limitPrice) continue

            // 롱 진입: 가격이 지정가 이하로 하락
            // 숏 진입: 가격이 지정가 이상으로 상승
            const hit = order.direction === "up"
              ? price <= order.limitPrice
              : price >= order.limitPrice

            if (hit) executeOpenOrder(order)
          }
        }

        await db().runTransaction(async (tx) => {
          const orderSnap = await tx.get(orderRef)
          if (!orderSnap.exists) return

          const freshOrder = orderSnap.data()
          if (freshOrder.status !== "pending") return
          if (freshOrder.orderType !== "limit") return

          const fillPrice = freshOrder.limitPrice

          tx.update(orderRef, {
            status: "filled",
            fillPrice,
            updatedAt: ts,
          })
          tx.delete(workerPendingLimitOrderRef(uid, orderRef.id))
          deleteStateOrder(tx, uid, orderRef.id, ts)

          // 포지션·거래 내역·잔고·수수료를 같은 트랜잭션에서 반영
          tx.set(positionRef, positionData)
          tx.set(tradeRef, tradeData)
          tx.set(accountRef, nextAccount)
        })

        // cancelOrder의 핵심 흐름
        if (order.status !== "pending") {
          throw new ApiError(409, "conflict", "대기 중인 주문만 취소할 수 있어요.")
        }

        tx.update(orderRef, { status: "canceled", updatedAt: ts })
        deleteWorkerPendingLimitOrderIndex(tx, uid, orderRef.id)
        deleteStateOrder(tx, uid, orderRef.id, ts)

        tx.set(accountRef, {
          ...account,
          cash: cash0 + order.margin + order.fee,
          updatedAt: ts,
        })

        주문 생성
          → Firestore에 pending 주문 저장
          → 증거금·수수료 잠금
          → workerPendingLimitOrders 인덱스 등록
          → 종목별 Map에서 감시
          → 가격 조건 충족
          → 트랜잭션으로 pending 재확인
          → filled + 포지션 + 거래 내역 반영
          → 워커 인덱스 삭제