replace

Author: benjaminjnoack

src/apps/cb/README.md

@@ -131,6 +131,7 @@ Notes:
 - `cb order get <order_id>`
 - `cb order list [product]`
 - `cb order cancel <order_id>`
+- `cb order replace <order_id>` (re-places a cancelled sell order with the same prices when enough base asset is available)
 - `cb order modify <order_id> [--baseSize <baseSize>] [--limitPrice <limitPrice>] [--stopPrice <stopPrice>] [--takeProfitPrice <takeProfitPrice>]` (supports limit, stop-limit, bracket, and TP/SL orders)
 - `cb order breakeven <order_id> --buyPrice <buyPrice> [--limitPrice <limitPrice>]`
 

src/apps/cb/commands/order-handlers.ts

@@ -2,7 +2,11 @@ import { cancelOrder, getOpenOrders, getOrder } from "../../../shared/coinbase/i
 import { logger, printOrder } from "../../../shared/log/index.js";
 import type { ProductId } from "../../../shared/schemas/shared-primitives.js";
 import type { BreakEvenStopOptions, ModifyOptions } from "./schemas/command-options.js";
-import { placeBreakEvenStopOrder, placeModifyOrder } from "../service/order-service.js";
+import {
+  placeBreakEvenStopOrder,
+  placeModifyOrder,
+  replaceCancelledSellOrder,
+} from "../service/order-service.js";
 
 export async function handleOrderAction(orderId: string): Promise<void> {
   const order = await getOrder(orderId);
@@ -36,3 +40,7 @@ export async function handleBreakEvenStopAction(
 ): Promise<void> {
   await placeBreakEvenStopOrder(orderId, options);
 }
+
+export async function handleReplaceAction(orderId: string): Promise<void> {
+  await replaceCancelledSellOrder(orderId);
+}

src/apps/cb/commands/register/register-orders.ts

@@ -5,6 +5,7 @@ import {
   handleModifyAction,
   handleOrderAction,
   handleOrdersAction,
+  handleReplaceAction,
 } from "../order-handlers.js";
 import { BreakEvenStopOptionsSchema, ModifyOptionsSchema } from "../schemas/command-options.js";
 import {
@@ -34,6 +35,11 @@ export function registerOrderCommands(program: Command) {
     .description("Cancel an open order by order ID")
     .action(withAction("order cancel", parseArg(OrderIdSchema), handleCancelAction));
 
+  order
+    .command("replace <order_id>")
+    .description("Re-place a cancelled sell order with the same prices when funds are available")
+    .action(withAction("order replace", parseArg(OrderIdSchema), handleReplaceAction));
+
   order
     .command("modify <order_id>")
     .description("Modify an existing limit/stop-limit/bracket/TP-SL order")

src/apps/cb/service/order-builders.ts

@@ -233,6 +233,15 @@ export type AttachedTpSlValues = {
   stopPrice: string;
 };
 
+export type ReplaceableSellOrderValues = {
+  orderType: CoinbaseOrder["order_type"];
+  productId: string;
+  baseSize: string;
+  limitPrice: string;
+  stopPrice?: string;
+  postOnly?: boolean;
+};
+
 export function getModifiableOrderValues(order: CoinbaseOrder): ModifiableOrderValues {
   switch (order.order_type) {
     case ORDER_TYPES.LIMIT: {
@@ -278,6 +287,51 @@ export function getAttachedTpSlValues(order: CoinbaseOrder): AttachedTpSlValues
   };
 }
 
+export function getReplaceableSellOrderValues(order: CoinbaseOrder): ReplaceableSellOrderValues {
+  if (order.status !== "CANCELLED") {
+    throw new Error(`Order ${order.order_id} must be CANCELLED before it can be replaced.`);
+  }
+  if (order.side !== ORDER_SIDE.SELL) {
+    throw new Error(`Order ${order.order_id} must be a SELL order before it can be replaced.`);
+  }
+
+  switch (order.order_type) {
+    case ORDER_TYPES.LIMIT: {
+      const config = order.order_configuration.limit_limit_gtc;
+      return {
+        orderType: order.order_type,
+        productId: order.product_id,
+        baseSize: config.base_size,
+        limitPrice: config.limit_price,
+        postOnly: config.post_only,
+      };
+    }
+    case ORDER_TYPES.STOP_LIMIT: {
+      const config = order.order_configuration.stop_limit_stop_limit_gtc;
+      return {
+        orderType: order.order_type,
+        productId: order.product_id,
+        baseSize: config.base_size,
+        limitPrice: config.limit_price,
+        stopPrice: config.stop_price,
+      };
+    }
+    case ORDER_TYPES.BRACKET:
+    case ORDER_TYPES.TAKE_PROFIT_STOP_LOSS: {
+      const config = order.order_configuration.trigger_bracket_gtc;
+      return {
+        orderType: order.order_type,
+        productId: order.product_id,
+        baseSize: config.base_size,
+        limitPrice: config.limit_price,
+        stopPrice: config.stop_trigger_price,
+      };
+    }
+    case ORDER_TYPES.MARKET:
+      throw new Error("Only priced sell orders can be replaced.");
+  }
+}
+
 export function buildModifyOrderValues(
   options: ModifyOptions,
   existing: ModifiableOrderValues,

src/apps/cb/service/order-service.ts

@@ -19,6 +19,7 @@ import {
   getTransactionSummary,
   ORDER_SIDE,
   ORDER_TYPES,
+  requestAccounts,
   requestBestBidAsk,
 } from "../../../shared/coinbase/index.js";
 import type { EditOrderRequest } from "../../../shared/coinbase/schemas/coinbase-rest-schemas.js";
@@ -32,9 +33,18 @@ import {
   buildStopLimitOrderValues,
   getAttachedTpSlValues,
   getModifiableOrderValues,
+  getReplaceableSellOrderValues,
 } from "./order-builders.js";
 import { confirmOrder, confirmOrderChange } from "./order-prompts.js";
 
+function getBaseCurrency(productId: string): string {
+  const [baseCurrency] = productId.split("-");
+  if (!baseCurrency) {
+    throw new Error(`Could not determine base currency for product ${productId}.`);
+  }
+  return baseCurrency;
+}
+
 /**
  * Places a market order after validation and confirmation.
  * @param {string} productId
@@ -325,3 +335,84 @@ export async function placeBreakEvenStopOrder(
     stop_price: stopPrice,
   });
 }
+
+export async function replaceCancelledSellOrder(orderId: string): Promise<void> {
+  const order = await getOrder(orderId);
+  const values = getReplaceableSellOrderValues(order);
+  const accounts = await requestAccounts();
+  const baseCurrency = getBaseCurrency(values.productId);
+  const baseAccount = accounts.find((account) => account.currency === baseCurrency);
+
+  if (!baseAccount) {
+    throw new Error(`Could not find ${baseCurrency} account for ${values.productId}.`);
+  }
+
+  const available = parseFloat(baseAccount.available_balance.value);
+  const required = parseFloat(values.baseSize);
+  if (!Number.isFinite(available)) {
+    throw new Error(`Invalid available balance for ${baseCurrency} account.`);
+  }
+  if (!Number.isFinite(required) || required <= 0) {
+    throw new Error(`Invalid base size on order ${orderId}.`);
+  }
+  if (available < required) {
+    throw new Error(
+      `Insufficient available ${baseCurrency} balance to replace order ${orderId}: `
+      + `need ${values.baseSize}, have ${baseAccount.available_balance.value}.`,
+    );
+  }
+
+  const confirmationPrice = values.stopPrice
+    ? `${values.limitPrice}/${values.stopPrice}`
+    : values.limitPrice;
+  const confirmationValue = values.stopPrice
+    ? `${(required * parseFloat(values.limitPrice)).toFixed(2)}/${(required * parseFloat(values.stopPrice)).toFixed(2)}`
+    : (required * parseFloat(values.limitPrice)).toFixed(2);
+
+  if (
+    !confirmOrder(
+      values.orderType,
+      ORDER_SIDE.SELL,
+      values.productId,
+      values.baseSize,
+      confirmationPrice,
+      confirmationValue,
+    )
+  ) {
+    console.log("Action canceled.");
+    return;
+  }
+
+  switch (values.orderType) {
+    case ORDER_TYPES.LIMIT:
+      await createLimitOrder(
+        values.productId,
+        ORDER_SIDE.SELL,
+        values.baseSize,
+        values.limitPrice,
+        values.postOnly ?? true,
+      );
+      return;
+    case ORDER_TYPES.STOP_LIMIT:
+      await createStopLimitOrder(
+        values.productId,
+        ORDER_SIDE.SELL,
+        values.baseSize,
+        values.limitPrice,
+        values.stopPrice!,
+      );
+      return;
+    case ORDER_TYPES.BRACKET:
+    case ORDER_TYPES.TAKE_PROFIT_STOP_LOSS:
+      await createBracketOrder(
+        values.productId,
+        ORDER_SIDE.SELL,
+        values.baseSize,
+        values.limitPrice,
+        values.stopPrice!,
+      );
+      return;
+    case ORDER_TYPES.MARKET:
+      throw new Error("Only priced sell orders can be replaced.");
+  }
+}

test/src/apps/cb/commands/order-handlers.test.ts

@@ -8,6 +8,7 @@ const {
   getOrderMock,
   cancelOrderMock,
   placeModifyOrderMock,
+  replaceCancelledSellOrderMock,
   printOrderMock,
 } = vi.hoisted(() => ({
   placeBreakEvenStopOrderMock: vi.fn(() => Promise.resolve(undefined)),
@@ -16,6 +17,7 @@ const {
   getOrderMock: vi.fn(() => Promise.resolve({ order_id: "order-1" })),
   cancelOrderMock: vi.fn(() => Promise.resolve(true)),
   placeModifyOrderMock: vi.fn(() => Promise.resolve(undefined)),
+  replaceCancelledSellOrderMock: vi.fn(() => Promise.resolve(undefined)),
   printOrderMock: vi.fn(),
 }));
 
@@ -38,6 +40,7 @@ vi.mock("../../../../../src/shared/log/orders.js", () => ({
 vi.mock("../../../../../src/apps/cb/service/order-service.js", () => ({
   placeBreakEvenStopOrder: placeBreakEvenStopOrderMock,
   placeModifyOrder: placeModifyOrderMock,
+  replaceCancelledSellOrder: replaceCancelledSellOrderMock,
 }));
 
 import {
@@ -46,6 +49,7 @@ import {
   handleModifyAction,
   handleOrderAction,
   handleOrdersAction,
+  handleReplaceAction,
 } from "../../../../../src/apps/cb/commands/order-handlers.js";
 
 describe("orders command handlers", () => {
@@ -115,4 +119,10 @@ describe("orders command handlers", () => {
       limitPrice: "101.50",
     });
   });
+
+  it("delegates replace action to service", async () => {
+    await handleReplaceAction(orderId);
+
+    expect(replaceCancelledSellOrderMock).toHaveBeenCalledWith(orderId);
+  });
 });

test/src/apps/cb/commands/register/orders-topology.test.ts

@@ -8,12 +8,14 @@ const {
   handleModifyActionMock,
   handleOrderActionMock,
   handleOrdersActionMock,
+  handleReplaceActionMock,
 } = vi.hoisted(() => ({
   handleBreakEvenStopActionMock: vi.fn(() => Promise.resolve(undefined)),
   handleCancelActionMock: vi.fn(() => Promise.resolve(undefined)),
   handleModifyActionMock: vi.fn(() => Promise.resolve(undefined)),
   handleOrderActionMock: vi.fn(() => Promise.resolve(undefined)),
   handleOrdersActionMock: vi.fn(() => Promise.resolve(undefined)),
+  handleReplaceActionMock: vi.fn(() => Promise.resolve(undefined)),
 }));
 
 vi.mock("../../../../../../src/apps/cb/commands/order-handlers.js", () => ({
@@ -22,6 +24,7 @@ vi.mock("../../../../../../src/apps/cb/commands/order-handlers.js", () => ({
   handleModifyAction: handleModifyActionMock,
   handleOrderAction: handleOrderActionMock,
   handleOrdersAction: handleOrdersActionMock,
+  handleReplaceAction: handleReplaceActionMock,
 }));
 
 import { registerOrderCommands } from "../../../../../../src/apps/cb/commands/register/register-orders.js";
@@ -40,17 +43,19 @@ describe("order command topology", () => {
     vi.clearAllMocks();
   });
 
-  it("supports nested order get/list/cancel/modify commands", async () => {
+  it("supports nested order get/list/cancel/replace/modify commands", async () => {
     await run(["order", "get", VALID_UUID]);
     await run(["order", "list"]);
     await run(["order", "cancel", VALID_UUID]);
+    await run(["order", "replace", VALID_UUID]);
     await run(["order", "modify", VALID_UUID, "--limitPrice", "101.50"]);
     await run(["order", "modify", VALID_UUID, "--takeProfitPrice", "121.50"]);
     await run(["order", "breakeven", VALID_UUID, "--buyPrice", "100", "--limitPrice", "101.50"]);
 
     expect(handleOrderActionMock).toHaveBeenCalledWith(VALID_UUID);
     expect(handleOrdersActionMock).toHaveBeenCalledWith(null);
     expect(handleCancelActionMock).toHaveBeenCalledWith(VALID_UUID);
+    expect(handleReplaceActionMock).toHaveBeenCalledWith(VALID_UUID);
     expect(handleModifyActionMock).toHaveBeenCalledWith(VALID_UUID, { limitPrice: "101.50" });
     expect(handleModifyActionMock).toHaveBeenCalledWith(VALID_UUID, { takeProfitPrice: "121.50" });
     expect(handleBreakEvenStopActionMock).toHaveBeenCalledWith(VALID_UUID, {
@@ -71,6 +76,7 @@ describe("order command topology", () => {
     expect(handleOrderActionMock).not.toHaveBeenCalled();
     expect(handleOrdersActionMock).not.toHaveBeenCalled();
     expect(handleCancelActionMock).not.toHaveBeenCalled();
+    expect(handleReplaceActionMock).not.toHaveBeenCalled();
     expect(handleModifyActionMock).not.toHaveBeenCalled();
     expect(handleBreakEvenStopActionMock).not.toHaveBeenCalled();
   });