feat: update new order schema

app.compose.yml

@@ -23,27 +23,27 @@ services:
       - "5080:5080"
     volumes:
       - dexon_openobserve_data:/data
-  api:
-    image: dexon-api
-    container_name: dexon-api
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - 12345:12345
-    volumes:
-      - ./.env:/app/.env
-    environment:
-      POSTGRES_URL: postgresql://postgres:postgres@timescaledb:5432/dexon?sslmode=disable
-    depends_on:
-      - timescaledb
-      - openobserve
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:12345/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 5
-    restart: always
+#  api:
+#    image: dexon-api
+#    container_name: dexon-api
+#    build:
+#      context: .
+#      dockerfile: Dockerfile
+#    ports:
+#      - 12345:12345
+#    volumes:
+#      - ./.env:/app/.env
+#    environment:
+#      POSTGRES_URL: postgresql://postgres:postgres@timescaledb:5432/dexon?sslmode=disable
+#    depends_on:
+#      - timescaledb
+#      - openobserve
+#    healthcheck:
+#      test: ["CMD", "curl", "-f", "http://localhost:12345/health"]
+#      interval: 30s
+#      timeout: 10s
+#      retries: 5
+#    restart: always
 
 volumes:
   dexon_timescaledb_data:

internal/orders/services/order.go

@@ -6,7 +6,6 @@ import (
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/jinzhu/copier"
 	"github.com/zuni-lab/dexon-service/pkg/db"
-	"slices"
 	"time"
 )
 
@@ -16,12 +15,7 @@ type ListOrdersByWalletQuery struct {
 	Offset int32  `query:"offset" validate:"gte=0"`
 }
 
-type ListOrdersByWalletResponseItem struct {
-	db.Order
-	Children []db.Order `json:"children"`
-}
-
-func ListOrderByWallet(ctx context.Context, query ListOrdersByWalletQuery) ([]ListOrdersByWalletResponseItem, error) {
+func ListOrderByWallet(ctx context.Context, query ListOrdersByWalletQuery) ([]db.Order, error) {
 	var params db.GetOrdersByWalletParams
 	if err := copier.Copy(&params, &query); err != nil {
 		return nil, err
@@ -32,64 +26,40 @@ func ListOrderByWallet(ctx context.Context, query ListOrdersByWalletQuery) ([]Li
 		return nil, err
 	}
 
-	var (
-		item ListOrdersByWalletResponseItem
-		res  = []ListOrdersByWalletResponseItem{}
-	)
-	for _, order := range orders {
-		if idx := slices.IndexFunc(res, func(item ListOrdersByWalletResponseItem) bool {
-			return item.ID == order.ID
-		}); idx != -1 {
-			res[idx].Children = append(res[idx].Children, order.Order)
-		}
-
-		err = copier.Copy(&item, &order)
-		if err != nil {
-			return nil, err
-		}
-		res = append(res, item)
-	}
-
-	return res, nil
+	return orders, nil
 }
 
 type CreateOrderBody struct {
 	Wallet        string       `json:"wallet" validate:"eth_addr"`
-	Token0        string       `json:"token0" validate:"eth_addr"`
-	Token1        string       `json:"token1" validate:"eth_addr"`
+	PoolIDs       []string     `json:"poolIds" validate:"min=1,dive,eth_addr"`
 	Side          db.OrderSide `json:"side" validate:"oneof=BUY SELL"`
 	Type          db.OrderType `json:"type" validate:"oneof=MARKET LIMIT STOP TWAP"`
 	Price         string       `json:"price" validate:"numeric,gt=0"`
 	Amount        string       `json:"amount" validate:"numeric,gt=0"`
-	TwapTotalTime *int32       `json:"twap_total_time" validate:"omitempty,gt=0"`
+	TwapTotalTime *int32       `json:"twapTotalTime" validate:"omitempty,gt=0"`
+	Slippage      float64      `json:"slippage" validate:"gte=0"`
 }
 
 func CreateOrder(ctx context.Context, body CreateOrderBody) (*db.Order, error) {
-	var (
-		pool   db.Pool
-		params db.InsertOrderParams
-	)
-
+	var params db.InsertOrderParams
 	if err := copier.Copy(&params, &body); err != nil {
 		return nil, err
 	}
 
-	pool, err := db.DB.GetPoolByToken(ctx, db.GetPoolByTokenParams{
-		Token0ID: body.Token0,
-		Token1ID: body.Token1,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	params.PoolID = pool.ID
 	if params.Type == db.OrderTypeMARKET {
 		params.Status = db.OrderStatusFILLED
 		_ = params.FilledAt.Scan(time.Now())
 	} else {
 		params.Status = db.OrderStatusPENDING
 	}
 
+	pools, err := db.DB.GetPoolsByIDs(ctx, body.PoolIDs)
+	if err != nil {
+		return nil, err
+	} else if len(pools) != len(body.PoolIDs) {
+		return nil, errors.New("invalid pool ids")
+	}
+
 	order, err := db.DB.InsertOrder(ctx, params)
 	if err != nil {
 		return nil, err
@@ -99,16 +69,24 @@ func CreateOrder(ctx context.Context, body CreateOrderBody) (*db.Order, error) {
 }
 
 func FillPartialOrder(ctx context.Context, parent db.Order, price, amount string) (*db.Order, error) {
-	var params db.InsertOrderParams
-	if err := copier.Copy(&params, &parent); err != nil {
-		return nil, err
+	params := db.InsertOrderParams{
+		PoolIds:                  parent.PoolIds,
+		Wallet:                   parent.Wallet,
+		Status:                   db.OrderStatusFILLED,
+		Side:                     parent.Side,
+		Type:                     db.OrderTypeTWAP,
+		Amount:                   parent.Amount,
+		Slippage:                 parent.Slippage,
+		TwapIntervalSeconds:      parent.TwapIntervalSeconds,
+		TwapExecutedTimes:        parent.TwapExecutedTimes,
+		TwapCurrentExecutedTimes: parent.TwapCurrentExecutedTimes,
+		TwapMinPrice:             parent.TwapMinPrice,
+		TwapMaxPrice:             parent.TwapMaxPrice,
 	}
-
 	_ = params.ParentID.Scan(parent.ID)
-	_ = params.FilledAt.Scan(time.Now())
 	_ = params.Price.Scan(price)
 	_ = params.Amount.Scan(amount)
-	params.Status = db.OrderStatusFILLED
+	_ = params.FilledAt.Scan(time.Now())
 
 	order, err := db.DB.InsertOrder(ctx, params)
 	if err != nil {
@@ -137,11 +115,16 @@ func MatchOrder(ctx context.Context, price string) (*db.Order, error) {
 	}
 	if order.Type == db.OrderTypeLIMIT ||
 		order.Type == db.OrderTypeSTOP ||
-		order.Type == db.OrderTypeTWAP && order.TwapAmount.Int.Cmp(order.Amount.Int) == 0 {
+		order.Type == db.OrderTypeTWAP && order.TwapCurrentExecutedTimes.Int32+1 == order.TwapExecutedTimes.Int32 {
 		_ = params.FilledAt.Scan(time.Now())
 		params.Status = db.OrderStatusFILLED
+
+		if order.Type == db.OrderTypeTWAP {
+			order.TwapCurrentExecutedTimes.Int32 = order.TwapExecutedTimes.Int32
+		}
 	} else if order.Type == db.OrderTypeTWAP {
 		params.Status = db.OrderStatusPARTIALFILLED
+		// TODO: create child order
 	} else {
 		return nil, errors.New("invalid order")
 	}

pkg/db/migration/000003_update_orders_table.down.sql

@@ -0,0 +1,15 @@
+ALTER TABLE orders
+DROP COLUMN pool_ids,
+    ADD COLUMN pool_id VARCHAR(42) NOT NULL,
+    DROP COLUMN slippage,
+    DROP COLUMN twap_interval_seconds,
+    DROP COLUMN twap_executed_times,
+    DROP COLUMN twap_current_executed_times,
+    DROP COLUMN twap_min_price,
+    DROP COLUMN twap_max_price,
+    DROP COLUMN deadline,
+    DROP COLUMN rejected_at;
+    DROP COLUMN signature;
+
+ALTER TABLE orders
+    ADD CONSTRAINT orders_pool_id_fkey FOREIGN KEY (pool_id) REFERENCES pools(id) ON DELETE CASCADE;

pkg/db/migration/000003_update_orders_table.up.sql

@@ -0,0 +1,15 @@
+ALTER TABLE orders
+DROP CONSTRAINT orders_pool_id_fkey;
+
+ALTER TABLE orders
+DROP COLUMN pool_id,
+    ADD COLUMN pool_ids VARCHAR(42)[] NOT NULL,
+    ADD COLUMN slippage DOUBLE PRECISION,
+    ADD COLUMN twap_interval_seconds INT,
+    ADD COLUMN twap_executed_times INT,
+    ADD COLUMN twap_current_executed_times INT,
+    ADD COLUMN twap_min_price NUMERIC(78,18),
+    ADD COLUMN twap_max_price NUMERIC(78,18),
+    ADD COLUMN deadline TIMESTAMP,
+    ADD COLUMN rejected_at TIMESTAMP,
+    ADD COLUMN signature VARCHAR(256);