fix: use actual fill price from exchange API for position records

- Remove trader_orders table and OrderSyncManager (never worked correctly)
- Poll GetOrderStatus to get actual avgPrice, executedQty, and commission
- Get entry price from exchange GetPositions API when closing positions
- Pass fee to trader_positions table on close
- Move TraderStats type to position.go

store/decision.go

@@ -287,16 +287,15 @@ func (s *DecisionStore) GetStatistics(traderID string) (*Statistics, error) {
 	}
 	stats.FailedCycles = stats.TotalCycles - stats.SuccessfulCycles
 
-	// Count open positions from trader_orders table
+	// Count from trader_positions table
 	s.db.QueryRow(`
-		SELECT COUNT(*) FROM trader_orders
-		WHERE trader_id = ? AND status = 'FILLED' AND action IN ('open_long', 'open_short')
+		SELECT COUNT(*) FROM trader_positions
+		WHERE trader_id = ?
 	`, traderID).Scan(&stats.TotalOpenPositions)
 
-	// Count close positions from trader_orders table
 	s.db.QueryRow(`
-		SELECT COUNT(*) FROM trader_orders
-		WHERE trader_id = ? AND status = 'FILLED' AND action IN ('close_long', 'close_short', 'auto_close_long', 'auto_close_short')
+		SELECT COUNT(*) FROM trader_positions
+		WHERE trader_id = ? AND status = 'CLOSED'
 	`, traderID).Scan(&stats.TotalClosePositions)
 
 	return stats, nil
@@ -310,15 +309,14 @@ func (s *DecisionStore) GetAllStatistics() (*Statistics, error) {
 	s.db.QueryRow(`SELECT COUNT(*) FROM decision_records WHERE success = 1`).Scan(&stats.SuccessfulCycles)
 	stats.FailedCycles = stats.TotalCycles - stats.SuccessfulCycles
 
-	// Count from trader_orders table
+	// Count from trader_positions table
 	s.db.QueryRow(`
-		SELECT COUNT(*) FROM trader_orders
-		WHERE status = 'FILLED' AND action IN ('open_long', 'open_short')
+		SELECT COUNT(*) FROM trader_positions
 	`).Scan(&stats.TotalOpenPositions)
 
 	s.db.QueryRow(`
-		SELECT COUNT(*) FROM trader_orders
-		WHERE status = 'FILLED' AND action IN ('close_long', 'close_short', 'auto_close_long', 'auto_close_short')
+		SELECT COUNT(*) FROM trader_positions
+		WHERE status = 'CLOSED'
 	`).Scan(&stats.TotalClosePositions)
 
 	return stats, nil

store/order.go

@@ -1,511 +0,0 @@
-package store
-
-import (
-	"database/sql"
-	"fmt"
-	"math"
-	"time"
-)
-
-// TraderOrder trader order record
-type TraderOrder struct {
-	ID            int64     `json:"id"`
-	TraderID      string    `json:"trader_id"`       // Trader ID
-	OrderID       string    `json:"order_id"`        // Exchange order ID
-	ClientOrderID string    `json:"client_order_id"` // Client order ID
-	Symbol        string    `json:"symbol"`          // Trading pair
-	Side          string    `json:"side"`            // BUY/SELL
-	PositionSide  string    `json:"position_side"`   // LONG/SHORT/BOTH
-	Action        string    `json:"action"`          // open_long/close_long/open_short/close_short
-	OrderType     string    `json:"order_type"`      // MARKET/LIMIT
-	Quantity      float64   `json:"quantity"`        // Order quantity
-	Price         float64   `json:"price"`           // Order price
-	AvgPrice      float64   `json:"avg_price"`       // Actual average execution price
-	ExecutedQty   float64   `json:"executed_qty"`    // Executed quantity
-	Leverage      int       `json:"leverage"`        // Leverage multiplier
-	Status        string    `json:"status"`          // NEW/FILLED/CANCELED/EXPIRED
-	Fee           float64   `json:"fee"`             // Fee
-	FeeAsset      string    `json:"fee_asset"`       // Fee asset
-	RealizedPnL   float64   `json:"realized_pnl"`    // Realized PnL (when closing)
-	EntryPrice    float64   `json:"entry_price"`     // Entry price (recorded when closing)
-	CreatedAt     time.Time `json:"created_at"`
-	UpdatedAt     time.Time `json:"updated_at"`
-	FilledAt      time.Time `json:"filled_at"` // Filled time
-}
-
-// TraderStats trading statistics metrics
-type TraderStats struct {
-	TotalTrades    int     `json:"total_trades"`     // Total trades (closed)
-	WinTrades      int     `json:"win_trades"`       // Winning trades
-	LossTrades     int     `json:"loss_trades"`      // Losing trades
-	WinRate        float64 `json:"win_rate"`         // Win rate (%)
-	ProfitFactor   float64 `json:"profit_factor"`    // Profit factor
-	SharpeRatio    float64 `json:"sharpe_ratio"`     // Sharpe ratio
-	TotalPnL       float64 `json:"total_pnl"`        // Total PnL
-	TotalFee       float64 `json:"total_fee"`        // Total fees
-	AvgWin         float64 `json:"avg_win"`          // Average win
-	AvgLoss        float64 `json:"avg_loss"`         // Average loss
-	MaxDrawdownPct float64 `json:"max_drawdown_pct"` // Max drawdown (%)
-}
-
-// CompletedOrder completed order (for AI input)
-type CompletedOrder struct {
-	Symbol      string    `json:"symbol"`       // Trading pair
-	Action      string    `json:"action"`       // close_long/close_short
-	Side        string    `json:"side"`         // long/short
-	Quantity    float64   `json:"quantity"`     // Quantity
-	EntryPrice  float64   `json:"entry_price"`  // Entry price
-	ExitPrice   float64   `json:"exit_price"`   // Exit price
-	RealizedPnL float64   `json:"realized_pnl"` // Realized PnL
-	PnLPct      float64   `json:"pnl_pct"`      // PnL percentage
-	Fee         float64   `json:"fee"`          // Fee
-	Leverage    int       `json:"leverage"`     // Leverage
-	FilledAt    time.Time `json:"filled_at"`    // Filled time
-}
-
-// OrderStore order storage
-type OrderStore struct {
-	db *sql.DB
-}
-
-// NewOrderStore creates order storage instance
-func NewOrderStore(db *sql.DB) *OrderStore {
-	return &OrderStore{db: db}
-}
-
-// InitTables initializes order tables
-func (s *OrderStore) InitTables() error {
-	_, err := s.db.Exec(`
-		CREATE TABLE IF NOT EXISTS trader_orders (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			trader_id TEXT NOT NULL,
-			order_id TEXT NOT NULL,
-			client_order_id TEXT DEFAULT '',
-			symbol TEXT NOT NULL,
-			side TEXT NOT NULL,
-			position_side TEXT DEFAULT '',
-			action TEXT NOT NULL,
-			order_type TEXT DEFAULT 'MARKET',
-			quantity REAL NOT NULL,
-			price REAL DEFAULT 0,
-			avg_price REAL DEFAULT 0,
-			executed_qty REAL DEFAULT 0,
-			leverage INTEGER DEFAULT 1,
-			status TEXT DEFAULT 'NEW',
-			fee REAL DEFAULT 0,
-			fee_asset TEXT DEFAULT 'USDT',
-			realized_pnl REAL DEFAULT 0,
-			entry_price REAL DEFAULT 0,
-			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-			filled_at DATETIME,
-			UNIQUE(trader_id, order_id)
-		)
-	`)
-	if err != nil {
-		return fmt.Errorf("failed to create trader_orders table: %w", err)
-	}
-
-	// Create indexes
-	indices := []string{
-		`CREATE INDEX IF NOT EXISTS idx_trader_orders_trader ON trader_orders(trader_id)`,
-		`CREATE INDEX IF NOT EXISTS idx_trader_orders_status ON trader_orders(trader_id, status)`,
-		`CREATE INDEX IF NOT EXISTS idx_trader_orders_symbol ON trader_orders(trader_id, symbol)`,
-		`CREATE INDEX IF NOT EXISTS idx_trader_orders_filled ON trader_orders(trader_id, filled_at DESC)`,
-	}
-	for _, idx := range indices {
-		if _, err := s.db.Exec(idx); err != nil {
-			return fmt.Errorf("failed to create index: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// Create creates order record
-func (s *OrderStore) Create(order *TraderOrder) error {
-	now := time.Now().Format(time.RFC3339)
-	result, err := s.db.Exec(`
-		INSERT INTO trader_orders (
-			trader_id, order_id, client_order_id, symbol, side, position_side,
-			action, order_type, quantity, price, avg_price, executed_qty,
-			leverage, status, fee, fee_asset, realized_pnl, entry_price,
-			created_at, updated_at
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-	`,
-		order.TraderID, order.OrderID, order.ClientOrderID, order.Symbol,
-		order.Side, order.PositionSide, order.Action, order.OrderType,
-		order.Quantity, order.Price, order.AvgPrice, order.ExecutedQty,
-		order.Leverage, order.Status, order.Fee, order.FeeAsset,
-		order.RealizedPnL, order.EntryPrice, now, now,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to create order record: %w", err)
-	}
-
-	id, _ := result.LastInsertId()
-	order.ID = id
-	return nil
-}
-
-// Update updates order record
-func (s *OrderStore) Update(order *TraderOrder) error {
-	now := time.Now().Format(time.RFC3339)
-	filledAt := ""
-	if !order.FilledAt.IsZero() {
-		filledAt = order.FilledAt.Format(time.RFC3339)
-	}
-
-	_, err := s.db.Exec(`
-		UPDATE trader_orders SET
-			avg_price = ?, executed_qty = ?, status = ?, fee = ?,
-			realized_pnl = ?, entry_price = ?, updated_at = ?, filled_at = ?
-		WHERE trader_id = ? AND order_id = ?
-	`,
-		order.AvgPrice, order.ExecutedQty, order.Status, order.Fee,
-		order.RealizedPnL, order.EntryPrice, now, filledAt,
-		order.TraderID, order.OrderID,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to update order record: %w", err)
-	}
-	return nil
-}
-
-// GetByOrderID gets order by order ID
-func (s *OrderStore) GetByOrderID(traderID, orderID string) (*TraderOrder, error) {
-	var order TraderOrder
-	var createdAt, updatedAt, filledAt sql.NullString
-
-	err := s.db.QueryRow(`
-		SELECT id, trader_id, order_id, client_order_id, symbol, side, position_side,
-			action, order_type, quantity, price, avg_price, executed_qty,
-			leverage, status, fee, fee_asset, realized_pnl, entry_price,
-			created_at, updated_at, filled_at
-		FROM trader_orders WHERE trader_id = ? AND order_id = ?
-	`, traderID, orderID).Scan(
-		&order.ID, &order.TraderID, &order.OrderID, &order.ClientOrderID,
-		&order.Symbol, &order.Side, &order.PositionSide, &order.Action,
-		&order.OrderType, &order.Quantity, &order.Price, &order.AvgPrice,
-		&order.ExecutedQty, &order.Leverage, &order.Status, &order.Fee,
-		&order.FeeAsset, &order.RealizedPnL, &order.EntryPrice,
-		&createdAt, &updatedAt, &filledAt,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	if createdAt.Valid {
-		order.CreatedAt, _ = time.Parse(time.RFC3339, createdAt.String)
-	}
-	if updatedAt.Valid {
-		order.UpdatedAt, _ = time.Parse(time.RFC3339, updatedAt.String)
-	}
-	if filledAt.Valid {
-		order.FilledAt, _ = time.Parse(time.RFC3339, filledAt.String)
-	}
-
-	return &order, nil
-}
-
-// GetLatestOpenOrder gets the latest open order for a symbol (for calculating close PnL)
-func (s *OrderStore) GetLatestOpenOrder(traderID, symbol, side string) (*TraderOrder, error) {
-	// side: long -> find open_long, short -> find open_short
-	action := "open_long"
-	if side == "short" {
-		action = "open_short"
-	}
-
-	var order TraderOrder
-	var createdAt, updatedAt, filledAt sql.NullString
-
-	err := s.db.QueryRow(`
-		SELECT id, trader_id, order_id, client_order_id, symbol, side, position_side,
-			action, order_type, quantity, price, avg_price, executed_qty,
-			leverage, status, fee, fee_asset, realized_pnl, entry_price,
-			created_at, updated_at, filled_at
-		FROM trader_orders
-		WHERE trader_id = ? AND symbol = ? AND action = ? AND status = 'FILLED'
-		ORDER BY filled_at DESC LIMIT 1
-	`, traderID, symbol, action).Scan(
-		&order.ID, &order.TraderID, &order.OrderID, &order.ClientOrderID,
-		&order.Symbol, &order.Side, &order.PositionSide, &order.Action,
-		&order.OrderType, &order.Quantity, &order.Price, &order.AvgPrice,
-		&order.ExecutedQty, &order.Leverage, &order.Status, &order.Fee,
-		&order.FeeAsset, &order.RealizedPnL, &order.EntryPrice,
-		&createdAt, &updatedAt, &filledAt,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	if createdAt.Valid {
-		order.CreatedAt, _ = time.Parse(time.RFC3339, createdAt.String)
-	}
-	if updatedAt.Valid {
-		order.UpdatedAt, _ = time.Parse(time.RFC3339, updatedAt.String)
-	}
-	if filledAt.Valid {
-		order.FilledAt, _ = time.Parse(time.RFC3339, filledAt.String)
-	}
-
-	return &order, nil
-}
-
-// GetRecentCompletedOrders gets recent completed close orders
-func (s *OrderStore) GetRecentCompletedOrders(traderID string, limit int) ([]CompletedOrder, error) {
-	rows, err := s.db.Query(`
-		SELECT symbol, action, side, executed_qty, entry_price, avg_price,
-			realized_pnl, fee, leverage, filled_at
-		FROM trader_orders
-		WHERE trader_id = ? AND status = 'FILLED'
-			AND (action = 'close_long' OR action = 'close_short')
-		ORDER BY filled_at DESC
-		LIMIT ?
-	`, traderID, limit)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query completed orders: %w", err)
-	}
-	defer rows.Close()
-
-	var orders []CompletedOrder
-	for rows.Next() {
-		var o CompletedOrder
-		var filledAt sql.NullString
-		var side sql.NullString
-
-		err := rows.Scan(
-			&o.Symbol, &o.Action, &side, &o.Quantity, &o.EntryPrice, &o.ExitPrice,
-			&o.RealizedPnL, &o.Fee, &o.Leverage, &filledAt,
-		)
-		if err != nil {
-			continue
-		}
-
-		// Infer side from action
-		if o.Action == "close_long" {
-			o.Side = "long"
-		} else if o.Action == "close_short" {
-			o.Side = "short"
-		} else if side.Valid {
-			o.Side = side.String
-		}
-
-		// Calculate PnL percentage
-		if o.EntryPrice > 0 {
-			if o.Side == "long" {
-				o.PnLPct = (o.ExitPrice - o.EntryPrice) / o.EntryPrice * 100 * float64(o.Leverage)
-			} else {
-				o.PnLPct = (o.EntryPrice - o.ExitPrice) / o.EntryPrice * 100 * float64(o.Leverage)
-			}
-		}
-
-		if filledAt.Valid {
-			o.FilledAt, _ = time.Parse(time.RFC3339, filledAt.String)
-		}
-
-		orders = append(orders, o)
-	}
-
-	return orders, nil
-}
-
-// GetTraderStats gets trading statistics metrics
-func (s *OrderStore) GetTraderStats(traderID string) (*TraderStats, error) {
-	stats := &TraderStats{}
-
-	// Query all completed close orders
-	rows, err := s.db.Query(`
-		SELECT realized_pnl, fee, filled_at
-		FROM trader_orders
-		WHERE trader_id = ? AND status = 'FILLED'
-			AND (action = 'close_long' OR action = 'close_short')
-		ORDER BY filled_at ASC
-	`, traderID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query order statistics: %w", err)
-	}
-	defer rows.Close()
-
-	var pnls []float64
-	var totalWin, totalLoss float64
-
-	for rows.Next() {
-		var pnl, fee float64
-		var filledAt sql.NullString
-		if err := rows.Scan(&pnl, &fee, &filledAt); err != nil {
-			continue
-		}
-
-		stats.TotalTrades++
-		stats.TotalPnL += pnl
-		stats.TotalFee += fee
-		pnls = append(pnls, pnl)
-
-		if pnl > 0 {
-			stats.WinTrades++
-			totalWin += pnl
-		} else if pnl < 0 {
-			stats.LossTrades++
-			totalLoss += math.Abs(pnl)
-		}
-	}
-
-	// Calculate win rate
-	if stats.TotalTrades > 0 {
-		stats.WinRate = float64(stats.WinTrades) / float64(stats.TotalTrades) * 100
-	}
-
-	// Calculate profit factor
-	if totalLoss > 0 {
-		stats.ProfitFactor = totalWin / totalLoss
-	}
-
-	// Calculate average win/loss
-	if stats.WinTrades > 0 {
-		stats.AvgWin = totalWin / float64(stats.WinTrades)
-	}
-	if stats.LossTrades > 0 {
-		stats.AvgLoss = totalLoss / float64(stats.LossTrades)
-	}
-
-	// Calculate Sharpe ratio (using PnL sequence)
-	if len(pnls) > 1 {
-		stats.SharpeRatio = calculateSharpeRatio(pnls)
-	}
-
-	// Calculate max drawdown
-	if len(pnls) > 0 {
-		stats.MaxDrawdownPct = calculateMaxDrawdown(pnls)
-	}
-
-	return stats, nil
-}
-
-// calculateSharpeRatio calculates Sharpe ratio
-func calculateSharpeRatio(pnls []float64) float64 {
-	if len(pnls) < 2 {
-		return 0
-	}
-
-	// Calculate average return
-	var sum float64
-	for _, pnl := range pnls {
-		sum += pnl
-	}
-	mean := sum / float64(len(pnls))
-
-	// Calculate standard deviation
-	var variance float64
-	for _, pnl := range pnls {
-		variance += (pnl - mean) * (pnl - mean)
-	}
-	stdDev := math.Sqrt(variance / float64(len(pnls)-1))
-
-	if stdDev == 0 {
-		return 0
-	}
-
-	// Sharpe ratio = average return / standard deviation
-	return mean / stdDev
-}
-
-// calculateMaxDrawdown calculates max drawdown
-func calculateMaxDrawdown(pnls []float64) float64 {
-	if len(pnls) == 0 {
-		return 0
-	}
-
-	// Calculate cumulative equity curve
-	var cumulative float64
-	var peak float64
-	var maxDD float64
-
-	for _, pnl := range pnls {
-		cumulative += pnl
-		if cumulative > peak {
-			peak = cumulative
-		}
-		if peak > 0 {
-			dd := (peak - cumulative) / peak * 100
-			if dd > maxDD {
-				maxDD = dd
-			}
-		}
-	}
-
-	return maxDD
-}
-
-// GetPendingOrders gets pending orders (for polling)
-func (s *OrderStore) GetPendingOrders(traderID string) ([]*TraderOrder, error) {
-	rows, err := s.db.Query(`
-		SELECT id, trader_id, order_id, client_order_id, symbol, side, position_side,
-			action, order_type, quantity, price, avg_price, executed_qty,
-			leverage, status, fee, fee_asset, realized_pnl, entry_price,
-			created_at, updated_at, filled_at
-		FROM trader_orders
-		WHERE trader_id = ? AND status = 'NEW'
-		ORDER BY created_at ASC
-	`, traderID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query pending orders: %w", err)
-	}
-	defer rows.Close()
-
-	return s.scanOrders(rows)
-}
-
-// GetAllPendingOrders gets all pending orders (for global sync)
-func (s *OrderStore) GetAllPendingOrders() ([]*TraderOrder, error) {
-	rows, err := s.db.Query(`
-		SELECT id, trader_id, order_id, client_order_id, symbol, side, position_side,
-			action, order_type, quantity, price, avg_price, executed_qty,
-			leverage, status, fee, fee_asset, realized_pnl, entry_price,
-			created_at, updated_at, filled_at
-		FROM trader_orders
-		WHERE status = 'NEW'
-		ORDER BY trader_id, created_at ASC
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query pending orders: %w", err)
-	}
-	defer rows.Close()
-
-	return s.scanOrders(rows)
-}
-
-// scanOrders scans order rows to structs
-func (s *OrderStore) scanOrders(rows *sql.Rows) ([]*TraderOrder, error) {
-	var orders []*TraderOrder
-	for rows.Next() {
-		var order TraderOrder
-		var createdAt, updatedAt, filledAt sql.NullString
-
-		err := rows.Scan(
-			&order.ID, &order.TraderID, &order.OrderID, &order.ClientOrderID,
-			&order.Symbol, &order.Side, &order.PositionSide, &order.Action,
-			&order.OrderType, &order.Quantity, &order.Price, &order.AvgPrice,
-			&order.ExecutedQty, &order.Leverage, &order.Status, &order.Fee,
-			&order.FeeAsset, &order.RealizedPnL, &order.EntryPrice,
-			&createdAt, &updatedAt, &filledAt,
-		)
-		if err != nil {
-			continue
-		}
-
-		if createdAt.Valid {
-			order.CreatedAt, _ = time.Parse(time.RFC3339, createdAt.String)
-		}
-		if updatedAt.Valid {
-			order.UpdatedAt, _ = time.Parse(time.RFC3339, updatedAt.String)
-		}
-		if filledAt.Valid {
-			order.FilledAt, _ = time.Parse(time.RFC3339, filledAt.String)
-		}
-
-		orders = append(orders, &order)
-	}
-
-	return orders, nil
-}

store/position.go

@@ -7,6 +7,21 @@ import (
 	"time"
 )
 
+// TraderStats trading statistics metrics
+type TraderStats struct {
+	TotalTrades    int     `json:"total_trades"`     // Total trades (closed)
+	WinTrades      int     `json:"win_trades"`       // Winning trades
+	LossTrades     int     `json:"loss_trades"`      // Losing trades
+	WinRate        float64 `json:"win_rate"`         // Win rate (%)
+	ProfitFactor   float64 `json:"profit_factor"`    // Profit factor
+	SharpeRatio    float64 `json:"sharpe_ratio"`     // Sharpe ratio
+	TotalPnL       float64 `json:"total_pnl"`        // Total PnL
+	TotalFee       float64 `json:"total_fee"`        // Total fees
+	AvgWin         float64 `json:"avg_win"`          // Average win
+	AvgLoss        float64 `json:"avg_loss"`         // Average loss
+	MaxDrawdownPct float64 `json:"max_drawdown_pct"` // Max drawdown (%)
+}
+
 // TraderPosition position record (complete open/close position tracking)
 type TraderPosition struct {
 	ID           int64      `json:"id"`

store/store.go

@@ -22,7 +22,6 @@ type Store struct {
 	trader   *TraderStore
 	decision *DecisionStore
 	backtest *BacktestStore
-	order    *OrderStore
 	position *PositionStore
 	strategy *StrategyStore
 	equity   *EquityStore
@@ -135,9 +134,6 @@ func (s *Store) initTables() error {
 	if err := s.Backtest().initTables(); err != nil {
 		return fmt.Errorf("failed to initialize backtest tables: %w", err)
 	}
-	if err := s.Order().InitTables(); err != nil {
-		return fmt.Errorf("failed to initialize order tables: %w", err)
-	}
 	if err := s.Position().InitTables(); err != nil {
 		return fmt.Errorf("failed to initialize position tables: %w", err)
 	}
@@ -241,16 +237,6 @@ func (s *Store) Backtest() *BacktestStore {
 	return s.backtest
 }
 
-// Order gets order storage
-func (s *Store) Order() *OrderStore {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.order == nil {
-		s.order = NewOrderStore(s.db)
-	}
-	return s.order
-}
-
 // Position gets position storage
 func (s *Store) Position() *PositionStore {
 	s.mu.Lock()