diff --git a/.gitignore b/.gitignore
index e7295d0..3a0506a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ vendor
 bin
 .exe
 dist/
+loadtest_metrics
\ No newline at end of file
diff --git a/Makefile b/Makefile
index ac2c5bc..6d59dde 100644
--- a/Makefile
+++ b/Makefile
@@ -22,4 +22,4 @@ build-linux:
 	GOOS=linux GOARCH=amd64 go build -v -o ./bin/qf .
 
 build-docker: clean build-linux
-	docker build -t quickfixgo/qf:latest .
\ No newline at end of file
+	docker build -t quickfixgo/qf:latest .
diff --git a/cmd/readmetrics/readmetrics.go b/cmd/readmetrics/readmetrics.go
new file mode 100644
index 0000000..ffa33b8
--- /dev/null
+++ b/cmd/readmetrics/readmetrics.go
@@ -0,0 +1,327 @@
+package readmetrics
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// LogEntry represents the structure of a log entry parsed from the raw log.
+type LogEntry struct {
+	MessageType string            `json:"message_type"` // Type of message (e.g., "D", "8").
+	Timestamp   string            `json:"timestamp"`    // Timestamp of the log entry.
+	Fields      map[string]string `json:"fields"`       // Additional fields in the log.
+}
+
+// LogMetricsEntry stores parsed information for latency and throughput calculations.
+type LogMetricsEntry struct {
+	timestamp time.Time // Timestamp of the message.
+	msgType   string    // Type of message (e.g., "D", "8").
+	clOrdID   string    // Client Order ID.
+}
+
+// Execute processes the log file, calculates metrics, and saves them to output files.
+func Execute(logFilePath, outputFilePath, tmpDir string) error {
+	// Get the current working directory
+	dir, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("error getting working directory: %v", err)
+	}
+
+	// Open the log file
+	logFile, err := os.Open(filepath.Join(dir, logFilePath))
+	if err != nil {
+		return fmt.Errorf("error opening log file: %v", err)
+	}
+	defer logFile.Close()
+
+	// Prepare a scanner to read the log file line by line
+	scanner := bufio.NewScanner(logFile)
+	entries := make([]LogEntry, 0)
+
+	// Read each line in the log file and parse relevant entries
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		// Filter lines that are message type "D" or "8"
+		if strings.Contains(line, "35=D") || strings.Contains(line, "35=8") {
+			entry := LogEntry{
+				Fields: make(map[string]string),
+			}
+
+			// Split the line by spaces and process the parts
+			parts := strings.Split(line, " ")
+			if len(parts) > 2 {
+				// Extract message type and timestamp
+				entry.MessageType = strings.Split(parts[2], "\u0001")[0]
+				entry.Timestamp = parts[1]
+
+				// Extract fields (key-value pairs) from the log
+				for _, part := range parts {
+					if strings.Contains(part, "=") {
+						keyValue := strings.SplitN(part, "=", 2)
+						if len(keyValue) == 2 {
+							entry.Fields[keyValue[0]] = keyValue[1]
+						}
+					}
+				}
+			}
+
+			entries = append(entries, entry) // Add the entry to the list
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("error reading log file: %v", err)
+	}
+
+	// Save the parsed entries to a JSON file
+	if err := saveToJSON(entries, outputFilePath); err != nil {
+		return fmt.Errorf("error saving to JSON: %v", err)
+	}
+
+	// Calculate latencies and save them
+	if err := CalculateLatenciesToFile(logFilePath, tmpDir); err != nil {
+		return fmt.Errorf("error calculating latencies: %v", err)
+	}
+
+	// Calculate success rates for orders
+	filledCount, newOrderCount, successRate, err := countFilledOrders(logFilePath)
+	if err != nil {
+		return fmt.Errorf("error calculating success percentages: %v", err)
+	}
+
+	// Write the calculated metrics to file
+	if err := writeMetricsToFile(tmpDir, filledCount, newOrderCount, successRate); err != nil {
+		return fmt.Errorf("error writing metrics to file: %v", err)
+	}
+
+	fmt.Printf("Raw Data saved to %s\n", outputFilePath)
+	return nil
+}
+
+// saveToJSON saves the parsed log entries to a JSON file.
+func saveToJSON(entries []LogEntry, outputFilePath string) error {
+	// Marshal entries into JSON format
+	jsonData, err := json.MarshalIndent(entries, "", "  ")
+	if err != nil {
+		return fmt.Errorf("error converting to JSON: %v", err)
+	}
+
+	// Get the current working directory to create the output file path
+	dir, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("error getting working directory: %v", err)
+	}
+
+	// Create and open the output file
+	outputFile, err := os.Create(filepath.Join(dir, outputFilePath))
+	if err != nil {
+		return fmt.Errorf("error creating output file: %v", err)
+	}
+	defer outputFile.Close()
+
+	// Write the JSON data to the file
+	_, err = outputFile.Write(jsonData)
+	if err != nil {
+		return fmt.Errorf("error writing to output file: %v", err)
+	}
+
+	return nil
+}
+
+// parseFIXMessage parses a single FIX message and returns the relevant data.
+func parseFIXMessage(line string) (LogMetricsEntry, error) {
+	// Split the line by the FIX field delimiter
+	fields := strings.Split(line, "
")
+	msg := LogMetricsEntry{}
+
+	// Parse the timestamp from the first 26 characters of the line
+	timestampStr := line[:26]
+	timestamp, err := time.Parse("2006/01/02 15:04:05.000000", timestampStr)
+	if err != nil {
+		return msg, err
+	}
+	msg.timestamp = timestamp
+
+	// Extract message type and client order ID
+	for _, field := range fields {
+		if strings.HasPrefix(field, "35=") {
+			msg.msgType = strings.TrimPrefix(field, "35=")
+		} else if strings.HasPrefix(field, "11=") {
+			msg.clOrdID = strings.TrimPrefix(field, "11=")
+		}
+	}
+	return msg, nil
+}
+
+// CalculateLatenciesToFile calculates the latencies between orders and saves the results to files.
+func CalculateLatenciesToFile(logFilePath, tmpDir string) error {
+	// Open the log file for reading
+	file, err := os.Open(logFilePath)
+	if err != nil {
+		return fmt.Errorf("error opening file: %v", err)
+	}
+	defer file.Close()
+
+	// Initialize variables for storing latency data
+	dMessages := make(map[string]LogMetricsEntry)
+	latencies := []int64{}
+	throughputCounts := make(map[time.Time]int)
+
+	// Read each line of the log and calculate latencies
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		msg, err := parseFIXMessage(line)
+		if err != nil {
+			fmt.Println("Error parsing line:", err)
+			continue
+		}
+
+		// Track order creation ("D") messages and calculate latency for execution ("8") messages
+		if msg.msgType == "D" {
+			dMessages[msg.clOrdID] = msg
+			minute := msg.timestamp.Truncate(time.Minute)
+			throughputCounts[minute]++
+		} else if msg.msgType == "8" && msg.clOrdID != "" {
+			if dMsg, found := dMessages[msg.clOrdID]; found {
+				latency := msg.timestamp.Sub(dMsg.timestamp).Milliseconds()
+				latencies = append(latencies, latency)
+				delete(dMessages, msg.clOrdID)
+			}
+		}
+	}
+
+	// Handle any errors encountered during scanning
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("error reading file: %v", err)
+	}
+
+	// Save latencies to a file
+	latencyFile, err := os.Create(filepath.Join(tmpDir, "latencies.txt"))
+	if err != nil {
+		return fmt.Errorf("error creating latencies file: %v", err)
+	}
+	defer latencyFile.Close()
+
+	writer := bufio.NewWriter(latencyFile)
+	for index, latency := range latencies {
+		_, err := writer.WriteString(fmt.Sprintf("Latency %d: %d ms\n", index+1, latency))
+		if err != nil {
+			return fmt.Errorf("error writing to latencies file: %v", err)
+		}
+	}
+
+	// Calculate average latency
+	averageLatency := float64(0)
+	if len(latencies) > 0 {
+		for _, latency := range latencies {
+			averageLatency += float64(latency)
+		}
+		averageLatency /= float64(len(latencies))
+	}
+
+	// Save the metrics (average latency, throughput) to file
+	metricsFile, err := os.Create(filepath.Join(tmpDir, "metrics.txt"))
+	if err != nil {
+		return fmt.Errorf("error creating metrics file: %v", err)
+	}
+	defer metricsFile.Close()
+
+	metricsWriter := bufio.NewWriter(metricsFile)
+	_, err = metricsWriter.WriteString(fmt.Sprintf("Average Latency: %.2f ms\n", averageLatency))
+	if err != nil {
+		return fmt.Errorf("error writing average latency to metrics file: %v", err)
+	}
+
+	// Write throughput data
+	for minute, count := range throughputCounts {
+		throughputStr := fmt.Sprintf("Minute: %s, Throughput: %d orders/min\n", minute.Format("2006-01-02 15:04"), count)
+		_, err := metricsWriter.WriteString(throughputStr)
+		if err != nil {
+			return fmt.Errorf("error writing throughput to metrics file: %v", err)
+		}
+	}
+
+	writer.Flush()
+	metricsWriter.Flush()
+
+	return nil
+}
+
+// countFilledOrders counts the number of filled and new orders and calculates the success rate.
+func countFilledOrders(logFilePath string) (int, int, float64, error) {
+	// Open the log file for scanning
+	file, err := os.Open(logFilePath)
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("failed to open log file: %v", err)
+	}
+	defer file.Close()
+
+	var filledCount, newOrderCount int
+
+	// Scan the file line by line
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		// Count new orders (type "D")
+		if strings.Contains(line, "35=D") {
+			newOrderCount++
+		}
+
+		// Count filled orders (150=F)
+		if strings.Contains(line, "150=F") {
+			filledCount++
+		}
+	}
+
+	// Handle any errors encountered during scanning
+	if err := scanner.Err(); err != nil {
+		return 0, 0, 0, fmt.Errorf("failed to scan log file: %v", err)
+	}
+
+	// Calculate the success rate
+	var successRate float64
+	if newOrderCount > 0 {
+		successRate = float64(filledCount) / float64(newOrderCount) * 100
+	}
+
+	return filledCount, newOrderCount, successRate, nil
+}
+
+// writeMetricsToFile appends metrics data (new orders, filled orders, success rate) to a file.
+func writeMetricsToFile(tmpDir string, filledCount, newOrderCount int, successRate float64) error {
+	// Open the metrics file for appending
+	metricsFile, err := os.OpenFile(filepath.Join(tmpDir, "metrics.txt"), os.O_APPEND|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("error opening metrics file: %v", err)
+	}
+	defer metricsFile.Close()
+
+	metricsWriter := bufio.NewWriter(metricsFile)
+
+	// Write the metrics data (new orders, filled orders, success rate) to the file
+	_, err = metricsWriter.WriteString(fmt.Sprintf("Total New Orders: %v\n", newOrderCount))
+	if err != nil {
+		return fmt.Errorf("error writing new orders count to metrics file: %v", err)
+	}
+
+	_, err = metricsWriter.WriteString(fmt.Sprintf("Total Orders Successfully Filled: %v\n", filledCount))
+	if err != nil {
+		return fmt.Errorf("error writing filled orders count to metrics file: %v", err)
+	}
+
+	_, err = metricsWriter.WriteString(fmt.Sprintf("Success Rate: %.2f%%\n", successRate))
+	if err != nil {
+		return fmt.Errorf("error writing success rate to metrics file: %v", err)
+	}
+
+	// Flush the buffered writer to ensure data is written to file
+	return metricsWriter.Flush()
+}
diff --git a/cmd/readmetrics/readmetrics_test.go b/cmd/readmetrics/readmetrics_test.go
new file mode 100644
index 0000000..418d697
--- /dev/null
+++ b/cmd/readmetrics/readmetrics_test.go
@@ -0,0 +1,54 @@
+package readmetrics
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Mock function to simulate reading from a fixed logfile and generating expected latencies
+func TestCalculateLatenciesToFile(t *testing.T) {
+	// Prepare paths for log and temp directory
+	logFilePath := "test_data/test.log"
+	tmpDir := "test_data"
+
+	// Ensure the tmpDir exists or create it for this test
+	err := os.MkdirAll(tmpDir, os.ModePerm)
+	require.NoError(t, err)
+
+	// Call the function under test
+	err = CalculateLatenciesToFile(logFilePath, tmpDir)
+	require.NoError(t, err)
+
+	// Read the generated latencies.txt file
+	latenciesFilePath := filepath.Join(tmpDir, "latencies.txt")
+	latenciesData, err := os.ReadFile(latenciesFilePath)
+	require.NoError(t, err)
+
+	// Define the expected latencies based on the mock data
+	// Latency 1: Time difference between first D message and first 8 message
+	// Latency 2: Time difference between second D message and second 8 message
+	expectedLatencies := []string{
+		"Latency 1: 151 ms\n",
+		"Latency 2: 156 ms\n",
+	}
+
+	// Assert that the latencies file contains the expected latencies
+	for i, expected := range expectedLatencies {
+		assert.Contains(t, string(latenciesData), expected, "Missing or incorrect latency at index %d", i+1)
+	}
+
+	// Read the generated metrics.txt file to ensure it contains the expected average latency and throughput
+	metricsFilePath := filepath.Join(tmpDir, "metrics.txt")
+	metricsData, err := os.ReadFile(metricsFilePath)
+	require.NoError(t, err)
+
+	// Verify that the average latency is present and matches the expected value
+	assert.Contains(t, string(metricsData), "Average Latency: 153.50 ms\n", "Average latency is incorrect")
+
+	// Verify that the throughput data is correct
+	assert.Contains(t, string(metricsData), "Minute: 2024-11-06 13:48, Throughput: 2 orders/min", "Throughput data is incorrect")
+}
diff --git a/cmd/readmetrics/test_data/test.log b/cmd/readmetrics/test_data/test.log
new file mode 100644
index 0000000..eab2316
--- /dev/null
+++ b/cmd/readmetrics/test_data/test.log
@@ -0,0 +1,12 @@
+2024/11/06 13:47:56.002111 8=FIX.4.4
9=282
35=A
34=1
49=test_order
52=20241106-13:47:56.000
56=test_target
96=c986f9e97370bfa6d15ec1a7667ba8c9aca9ccae7c9a047844fc4e71a8f0195b2fceb97dcfcbb997c3de93c897d716402be1bb17569b2c2eeee3d35db9daff0d
98=0
108=30
141=Y
554=4044a57206f7494b8692079e720aa911f3234e4d61079db28d36a405ae3630cb
10=003

+2024/11/06 13:47:56.252103 8=FIX.4.4
9=81
35=A
34=1
49=test_target
52=20241106-13:47:56.210
56=test_order
98=0
108=30
141=Y
10=125

+2024/11/06 13:48:13.861610 8=FIX.4.4
9=157
35=D
34=2
49=test_order
52=20241106-13:48:13.861
56=test_target
11=111111111
21=1
38=0.0190
40=2
44=60000.00000
54=2
55=BTC-USD
59=4
60=20241106-13:48:13.861
10=086

+2024/11/06 13:48:13.862631 8=FIX.4.4
9=157
35=D
34=3
49=test_order
52=20241106-13:48:13.862
56=test_target
11=222222222
21=1
38=0.0150
40=2
44=60000.00000
54=2
55=BTC-USD
59=4
60=20241106-13:48:13.862
10=078

+2024/11/06 13:48:14.012654 8=FIX.4.4
9=272
35=8
34=2
49=test_target
52=20241106-13:48:13.979
56=test_order
1=default
6=0.0000
11=111111111
14=0.00000000
17=11111112-4444-4444-4444-111111111111
31=0.0000
32=0.00000000
37=11111111-2222-3333-4444-555555555555
38=0.02
39=A
40=2
54=2
55=BTC-USD
58=
150=A
151=0.01900000
10=050

+2024/11/06 13:48:14.019403 8=FIX.4.4
9=272
35=8
34=3
49=test_target
52=20241106-13:48:13.987
56=test_order
1=default
6=0.0000
11=222222222
14=0.00000000
17=11111113-4444-4444-4444-111111111111
31=0.0000
32=0.00000000
37=22222222-3333-4444-5555-666666666666
38=0.02
39=A
40=2
54=2
55=BTC-USD
58=
150=A
151=0.01500000
10=228

+2024/11/06 13:48:14.033887 8=FIX.4.4
9=272
35=8
34=4
49=test_target
52=20241106-13:48:13.999
56=test_order
1=default
6=0.0000
11=111111111
14=0.00000000
17=11111114-4444-4444-4444-111111111111
31=0.0000
32=0.00000000
37=11111111-2222-3333-4444-555555555555
38=0.02
39=0
40=2
54=2
55=BTC-USD
58=
150=0
151=0.01900000
10=143

+2024/11/06 13:48:14.043048 8=FIX.4.4
9=280
35=8
34=5
49=test_target
52=20241106-13:48:14.009
56=test_order
1=default
6=73940.6300
11=111111111
14=0.01900000
17=11111115-4444-4444-4444-111111111111
31=73940.6300
32=0.01900000
37=11111111-2222-3333-4444-555555555555
38=0.02
39=2
40=2
54=2
55=BTC-USD
58=
150=F
151=0.00000000
10=097

+2024/11/06 13:48:14.052181 8=FIX.4.4
9=272
35=8
34=6
49=test_target
52=20241106-13:48:14.018
56=test_order
1=default
6=0.0000
11=222222222
14=0.00000000
17=11111116-4444-4444-4444-111111111111
31=0.0000
32=0.00000000
37=22222222-3333-4444-5555-666666666666
38=0.02
39=0
40=2
54=2
55=BTC-USD
58=
150=0
151=0.01500000
10=192

+2024/11/06 13:48:14.060262 8=FIX.4.4
9=280
35=8
34=7
49=test_target
52=20241106-13:48:14.027
56=test_order
1=default
6=73941.0700
11=222222222
14=0.01500000
17=11111117-4444-4444-4444-111111111111
31=73941.0700
32=0.01500000
37=22222222-3333-4444-5555-666666666666
38=0.02
39=2
40=2
54=2
55=BTC-USD
58=
150=F
151=0.00000000
10=135

+2024/11/06 13:48:18.238506 8=FIX.4.4
9=63
35=5
34=4
49=test_order
52=20241106-13:48:18.238
56=test_target
10=055

+2024/11/06 13:48:18.305700 8=FIX.4.4
9=63
35=5
34=8
49=test_target
52=20241106-13:48:18.270
56=test_order
10=055

\ No newline at end of file
diff --git a/cmd/tradeclient/internal/console.go b/cmd/tradeclient/internal/console.go
index 8db8de1..072b722 100644
--- a/cmd/tradeclient/internal/console.go
+++ b/cmd/tradeclient/internal/console.go
@@ -18,6 +18,7 @@ package internal
 import (
 	"bufio"
 	"fmt"
+	"math/rand"
 	"time"
 
 	"github.com/quickfixgo/enum"
@@ -91,8 +92,10 @@ func QueryAction() (string, error) {
 	fmt.Println()
 	fmt.Println("1) Enter Order")
 	fmt.Println("2) Cancel Order")
-	fmt.Println("3) Request Market Test")
-	fmt.Println("4) Quit")
+	fmt.Println("3) Request Market Data")
+	fmt.Println("4) Run Load Test")
+	fmt.Println("5) Read metrics")
+	fmt.Println("6) Quit")
 	fmt.Print("Action: ")
 	scanner := bufio.NewScanner(os.Stdin)
 	scanner.Scan()
@@ -100,36 +103,39 @@ func QueryAction() (string, error) {
 }
 
 func queryVersion() (string, error) {
-	fmt.Println()
-	fmt.Println("1) FIX.4.0")
-	fmt.Println("2) FIX.4.1")
-	fmt.Println("3) FIX.4.2")
-	fmt.Println("4) FIX.4.3")
-	fmt.Println("5) FIX.4.4")
-	fmt.Println("6) FIXT.1.1 (FIX.5.0)")
-	fmt.Print("BeginString: ")
-
-	scanner := bufio.NewScanner(os.Stdin)
-	if !scanner.Scan() {
-		return "", scanner.Err()
-	}
+	/*
+		fmt.Println()
+		fmt.Println("1) FIX.4.0")
+		fmt.Println("2) FIX.4.1")
+		fmt.Println("3) FIX.4.2")
+		fmt.Println("4) FIX.4.3")
+		fmt.Println("5) FIX.4.4")
+		fmt.Println("6) FIXT.1.1 (FIX.5.0)")
+		fmt.Print("BeginString: ")
+
+		scanner := bufio.NewScanner(os.Stdin)
+		if !scanner.Scan() {
+			return "", scanner.Err()
+		}
 
-	switch scanner.Text() {
-	case "1":
-		return quickfix.BeginStringFIX40, nil
-	case "2":
-		return quickfix.BeginStringFIX41, nil
-	case "3":
-		return quickfix.BeginStringFIX42, nil
-	case "4":
-		return quickfix.BeginStringFIX43, nil
-	case "5":
-		return quickfix.BeginStringFIX44, nil
-	case "6":
-		return quickfix.BeginStringFIXT11, nil
-	}
+		switch scanner.Text() {
+		case "1":
+			return quickfix.BeginStringFIX40, nil
+		case "2":
+			return quickfix.BeginStringFIX41, nil
+		case "3":
+			return quickfix.BeginStringFIX42, nil
+		case "4":
+			return quickfix.BeginStringFIX43, nil
+		case "5":
+			return quickfix.BeginStringFIX44, nil
+		case "6":
+			return quickfix.BeginStringFIXT11, nil
+		}
 
-	return "", fmt.Errorf("unknown BeginString choice: %v", scanner.Text())
+		return "", fmt.Errorf("unknown BeginString choice: %v", scanner.Text())
+	*/
+	return quickfix.BeginStringFIX44, nil
 }
 
 func queryClOrdID() field.ClOrdIDField {
@@ -245,13 +251,24 @@ type header interface {
 }
 
 func queryHeader(h header) {
-	h.Set(querySenderCompID())
-	h.Set(queryTargetCompID())
-	if ok := queryConfirm("Use a TargetSubID"); !ok {
-		return
-	}
+	/*
+		h.Set(querySenderCompID())
+		h.Set(queryTargetCompID())
+		if ok := queryConfirm("Use a TargetSubID"); !ok {
+			return
+		}
 
-	h.Set(queryTargetSubID())
+		h.Set(queryTargetSubID())
+	*/
+	//h.Set(field.NewSenderCompID(senderCompId))
+	//h.Set(field.NewTargetCompID(targetCompId))
+	h.Set(field.NewSenderCompID("CLIENT1_Order"))
+	h.Set(field.NewTargetCompID("ANCHOR"))
+}
+
+func setHeader(h header, senderCompId string, targetCompId string) {
+	h.Set(field.NewSenderCompID(senderCompId))
+	h.Set(field.NewTargetCompID(targetCompId))
 }
 
 func queryNewOrderSingle40() fix40nos.NewOrderSingle {
@@ -269,7 +286,7 @@ func queryNewOrderSingle40() fix40nos.NewOrderSingle {
 	}
 
 	order.Set(queryTimeInForce())
-	queryHeader(order.Header.Header)
+	queryHeader(order.Header)
 
 	return order
 }
@@ -340,26 +357,32 @@ func queryNewOrderSingle43() (msg *quickfix.Message) {
 	return
 }
 
-func queryNewOrderSingle44() (msg *quickfix.Message) {
-	var ordType field.OrdTypeField
-	order := fix44nos.New(queryClOrdID(), querySide(), field.NewTransactTime(time.Now()), queryOrdType(&ordType))
+func queryNewOrderSingle44(senderCompId, targetCompId, side, symbol, qty, price string) (msg *quickfix.Message) {
+	var ordType = enum.OrdType_LIMIT
+	order := fix44nos.New(field.NewClOrdID(strconv.Itoa(time.Now().Nanosecond())),
+		field.NewSide(enum.Side(side)),
+		field.NewTransactTime(time.Now()),
+		field.NewOrdType(ordType))
 	order.SetHandlInst("1")
-	order.Set(querySymbol())
-	order.Set(queryOrderQty())
-
-	switch ordType.Value() {
-	case enum.OrdType_LIMIT, enum.OrdType_STOP_LIMIT:
-		order.Set(queryPrice())
-	}
-
-	switch ordType.Value() {
-	case enum.OrdType_STOP, enum.OrdType_STOP_LIMIT:
+	order.Set(field.NewSymbol(symbol))
+	ordqty, _ := decimal.NewFromString(qty)
+	order.Set(field.NewOrderQty(ordqty, 4))
+	order.Set(field.NewTimeInForce(enum.TimeInForce_FILL_OR_KILL))
+
+	switch ordType {
+	case enum.OrdType_LIMIT:
+		px, _ := decimal.NewFromString(price)
+		order.Set(field.NewPrice(px, 5))
+	case enum.OrdType_STOP_LIMIT:
+		px, _ := decimal.NewFromString("3000.00")
+		order.Set(field.NewPrice(px, 5))
 		order.Set(queryStopPx())
+	case enum.OrdType_STOP:
+
 	}
 
-	order.Set(queryTimeInForce())
 	msg = order.ToMessage()
-	queryHeader(&msg.Header)
+	setHeader(&msg.Header, senderCompId, targetCompId)
 
 	return
 }
@@ -475,21 +498,25 @@ func queryMarketDataRequest43() fix43mdr.MarketDataRequest {
 	return request
 }
 
-func queryMarketDataRequest44() fix44mdr.MarketDataRequest {
-	request := fix44mdr.New(field.NewMDReqID("MARKETDATAID"),
-		field.NewSubscriptionRequestType(enum.SubscriptionRequestType_SNAPSHOT),
+func queryMarketDataRequest44(senderCompId, targetCompId string) fix44mdr.MarketDataRequest {
+	request := fix44mdr.New(field.NewMDReqID(strconv.Itoa(time.Now().Nanosecond())),
+		field.NewSubscriptionRequestType(enum.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES),
 		field.NewMarketDepth(0),
 	)
+	request.SetMDUpdateType(enum.MDUpdateType_INCREMENTAL_REFRESH)
 
 	entryTypes := fix44mdr.NewNoMDEntryTypesRepeatingGroup()
+	//noOfMDEntryTypes := entryTypes.Add()
 	entryTypes.Add().SetMDEntryType(enum.MDEntryType_BID)
+	entryTypes.Add().SetMDEntryType(enum.MDEntryType_OFFER)
 	request.SetNoMDEntryTypes(entryTypes)
 
 	relatedSym := fix44mdr.NewNoRelatedSymRepeatingGroup()
-	relatedSym.Add().SetSymbol("LNUX")
+	// relatedSym.Add().SetSymbol("ETH-USD")
+	relatedSym.Add().SetSymbol("BTC-USD")
 	request.SetNoRelatedSym(relatedSym)
 
-	queryHeader(request.Header)
+	setHeader(request.Header, senderCompId, targetCompId)
 	return request
 }
 
@@ -511,18 +538,19 @@ func queryMarketDataRequest50() fix50mdr.MarketDataRequest {
 	return request
 }
 
-func QueryEnterOrder() (err error) {
+func QueryEnterOrder(senderCompId, targetCompId string) (err error) {
 	defer func() {
 		if e := recover(); e != nil {
 			err = e.(error)
 		}
 	}()
 
-	var beginString string
-	beginString, err = queryVersion()
-	if err != nil {
-		return err
-	}
+	var beginString string = "FIX.4.4"
+	/*
+		beginString, err = queryVersion()
+		if err != nil {
+			return err
+		}*/
 
 	var order quickfix.Messagable
 	switch beginString {
@@ -539,8 +567,26 @@ func QueryEnterOrder() (err error) {
 		order = queryNewOrderSingle43()
 
 	case quickfix.BeginStringFIX44:
-		order = queryNewOrderSingle44()
+		symbol := "BTC-USD"
+		price := "60"
+		var side, qty string
+
+		midsize := 0.01
+		for i := range 1 {
+			if i%2 == 0 {
+				side = "2"
+				qty = fmt.Sprintf("%f", midsize+float64(rand.Intn(10))/1000.0)
+			} else {
+				side = "2"
+				qty = fmt.Sprintf("%f", midsize-float64(rand.Intn(10))/1000.0)
+			}
+			//fmt.Printf("qty=%v,symbol=%s\n", qty,symbol)
+			order = queryNewOrderSingle44(senderCompId, targetCompId, side, symbol, qty, price)
+			quickfix.Send(order)
+			time.Sleep(1000 * time.Millisecond)
+		}
 
+		return
 	case quickfix.BeginStringFIXT11:
 		order = queryNewOrderSingle50()
 	}
@@ -589,7 +635,7 @@ func QueryCancelOrder() (err error) {
 	return
 }
 
-func QueryMarketDataRequest() error {
+func QueryMarketDataRequest(senderCompId, targetCompId string) error {
 	beginString, err := queryVersion()
 	if err != nil {
 		return err
@@ -604,18 +650,19 @@ func QueryMarketDataRequest() error {
 		req = queryMarketDataRequest43()
 
 	case quickfix.BeginStringFIX44:
-		req = queryMarketDataRequest44()
+		req = queryMarketDataRequest44(senderCompId, targetCompId)
 
 	case quickfix.BeginStringFIXT11:
 		req = queryMarketDataRequest50()
 
 	default:
-		return fmt.Errorf("No test for version %v", beginString)
+		return fmt.Errorf("no test for version %v", beginString)
 	}
 
-	if queryConfirm("Send MarketDataRequest") {
-		return quickfix.Send(req)
-	}
+	//if queryConfirm("Send MarketDataRequest") {
+	fmt.Println("quickfix.Send(req)=>")
+	return quickfix.Send(req)
+	//}
 
-	return nil
+	//return nil
 }
diff --git a/cmd/tradeclient/loadtest/README.md b/cmd/tradeclient/loadtest/README.md
new file mode 100644
index 0000000..74e606f
--- /dev/null
+++ b/cmd/tradeclient/loadtest/README.md
@@ -0,0 +1,32 @@
+
+# Load Test for TradeClient
+
+## Overview
+This load test evaluates the performance of the TradeClient by simulating the submission of multiple orders in a specified time frame. The primary focus is to measure the success/failure percentage of the orders processed, while performance analysis will be derived from log files.
+
+## Types of Tests Running
+- **Load Test**:  Simulates the submission of a high volume of orders at configurable rates.
+
+## How to Run the Tests
+1. **Build the TradeClient**:
+   - Use one of the following commands:
+     ```make build```
+     or
+     ```make clean build```
+
+2. **Run the TradeClient**:
+   - Execute the following command:
+     ```./bin/qf tradeclient```
+
+3. **Select Load Test**:
+   - You will be prompted with the following options:
+      1) Enter Order
+      2) Cancel Order
+      3) Request Market Data
+      4) Run Load Test
+      5) Read metrics
+      6) Quit
+   - Choose **4** to initiate the load test.
+
+## Outputs
+   - Log files will be generated in the tmp folder. To view calculated metrics based on these logs, select 5 from the menu (Read Metrics).
diff --git a/cmd/tradeclient/loadtest/loadtest.go b/cmd/tradeclient/loadtest/loadtest.go
new file mode 100644
index 0000000..597fe38
--- /dev/null
+++ b/cmd/tradeclient/loadtest/loadtest.go
@@ -0,0 +1,42 @@
+package loadtest
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/quickfixgo/examples/cmd/tradeclient/internal"
+)
+
+// LoadTestConfig holds configuration for the load test.
+type LoadTestConfig struct {
+	OrdersPerSecond int // Rate of orders per second
+	TotalOrders     int // Total number of orders to send
+	SenderCompID    string
+	TargetCompID    string
+}
+
+// sends orders based on the provided configuration.
+func RunLoadTest(cfg LoadTestConfig) {
+	var wg sync.WaitGroup
+
+	// send orders at the specified rate
+	for i := 0; i < cfg.TotalOrders; i++ {
+		wg.Add(1)
+		go func(orderID int) {
+			defer wg.Done()
+			err := internal.QueryEnterOrder(cfg.SenderCompID, cfg.TargetCompID)
+			if err != nil {
+				fmt.Printf("Order %d failed: %v\n", orderID, err)
+			}
+		}(i)
+
+		// Delay to maintain order rate
+		time.Sleep(time.Second / time.Duration(cfg.OrdersPerSecond))
+	}
+
+	// Wait for all goroutines to complete
+	wg.Wait()
+
+	fmt.Println("Load test finished, all orders have been processed.")
+}
diff --git a/cmd/tradeclient/tradeclient.go b/cmd/tradeclient/tradeclient.go
index 9f17d53..033956a 100644
--- a/cmd/tradeclient/tradeclient.go
+++ b/cmd/tradeclient/tradeclient.go
@@ -17,16 +17,24 @@ package tradeclient
 
 import (
 	"bytes"
+	"crypto/ed25519"
+	"encoding/hex"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"path"
+	"strconv"
+	"time"
 
+	"github.com/quickfixgo/examples/cmd/readmetrics"
 	"github.com/quickfixgo/examples/cmd/tradeclient/internal"
+	"github.com/quickfixgo/examples/cmd/tradeclient/loadtest"
 	"github.com/quickfixgo/examples/cmd/utils"
-	"github.com/spf13/cobra"
-
+	"github.com/quickfixgo/field"
+	"github.com/quickfixgo/fix44/logon"
 	"github.com/quickfixgo/quickfix"
+	"github.com/spf13/cobra"
 )
 
 // TradeClient implements the quickfix.Application interface
@@ -34,31 +42,104 @@ type TradeClient struct {
 }
 
 // OnCreate implemented as part of Application interface
-func (e TradeClient) OnCreate(sessionID quickfix.SessionID) {}
+func (e TradeClient) OnCreate(sessionID quickfix.SessionID) {
+	// fmt.Printf("initiator session Id: %s\n", sessionID)
+}
 
 // OnLogon implemented as part of Application interface
 func (e TradeClient) OnLogon(sessionID quickfix.SessionID) {}
 
 // OnLogout implemented as part of Application interface
-func (e TradeClient) OnLogout(sessionID quickfix.SessionID) {}
+func (e TradeClient) OnLogout(sessionID quickfix.SessionID) {
+	// fmt.Printf("OnLogout: %s\n", sessionID)
+}
 
 // FromAdmin implemented as part of Application interface
 func (e TradeClient) FromAdmin(msg *quickfix.Message, sessionID quickfix.SessionID) (reject quickfix.MessageRejectError) {
+	// utils.PrintInfo(fmt.Sprintf("FromAdmin: %s\n", msg.String()))
 	return nil
 }
 
+const (
+	FIX_SEP = "\u0001"
+
+	Publickey = "a"
+
+	Privatekey = "b"
+
+	APIKey = "4b"
+	// Constants for file paths
+	LogFilePath    = "tmp/FIX.4.4-CUST2_Order-ANCHORAGE.messages.current.log"
+	OutputFilePath = "tmp/log_data.json"
+	TmpDir         = "tmp/"
+)
+
 // ToAdmin implemented as part of Application interface
-func (e TradeClient) ToAdmin(msg *quickfix.Message, sessionID quickfix.SessionID) {}
+func (e TradeClient) ToAdmin(msg *quickfix.Message, sessionID quickfix.SessionID) {
+	msgType, err := msg.MsgType()
+	if err != nil {
+		println("wrong message type")
+	}
+
+	if msgType == "A" {
+		msg.Body.Set(field.NewPassword(APIKey))
+		signature, err := e.sign(msg)
+		if err != nil {
+			println("error in signing the message")
+		}
+		msg.Body.Set(field.NewRawData(signature))
+	}
+
+	// utils.PrintInfo(fmt.Sprintf("ToAdmin: %s", msg.String()))
+}
+
+func (e TradeClient) sign(logonmsg *quickfix.Message) (string, error) {
+	msg := logon.FromMessage(logonmsg)
+
+	sendingTime, err := msg.GetSendingTime()
+	if err != nil {
+		println("error in getting SendingTime from the logon")
+		return "", &quickfix.RejectLogon{Text: "invalid SendingTime"}
+	}
+
+	seqNum, err := msg.GetMsgSeqNum()
+	if err != nil {
+		println("error in getting MsgSeqNum from the logon")
+		return "", &quickfix.RejectLogon{Text: "invalid MsgSeqNum"}
+	}
+
+	senderCompID, err := msg.GetSenderCompID()
+	if err != nil {
+		println("error in getting SenderCompID from the logon")
+		return "", &quickfix.RejectLogon{Text: "invalid SenderCompID"}
+	}
+
+	targetCompID, err := msg.GetTargetCompID()
+	if err != nil {
+		println("error in getting TargetCompID from the logon")
+		return "", &quickfix.RejectLogon{Text: "invalid TargetCompID"}
+	}
+
+	msgToSign := sendingTime.Format("20060102-15:04:05.000") + FIX_SEP +
+		strconv.Itoa(seqNum) + FIX_SEP +
+		senderCompID + FIX_SEP +
+		targetCompID
+
+	privateKeyBytes, _ := hex.DecodeString(Privatekey)
+	ed25519PrivateKey := ed25519.PrivateKey(privateKeyBytes)
+	signature := ed25519.Sign(ed25519PrivateKey, []byte(msgToSign))
+	return hex.EncodeToString(signature), nil
+}
 
 // ToApp implemented as part of Application interface
 func (e TradeClient) ToApp(msg *quickfix.Message, sessionID quickfix.SessionID) (err error) {
-	utils.PrintInfo(fmt.Sprintf("Sending: %s", msg.String()))
+	// utils.PrintInfo(fmt.Sprintf("Sending: %s", msg.String()))
 	return
 }
 
 // FromApp implemented as part of Application interface. This is the callback for all Application level messages from the counter party.
 func (e TradeClient) FromApp(msg *quickfix.Message, sessionID quickfix.SessionID) (reject quickfix.MessageRejectError) {
-	utils.PrintInfo(fmt.Sprintf("FromApp: %s", msg.String()))
+	// utils.PrintInfo(fmt.Sprintf("FromApp: %s", msg.String()))
 	return
 }
 
@@ -144,15 +225,94 @@ Loop:
 
 		switch action {
 		case "1":
-			err = internal.QueryEnterOrder()
+			err = internal.QueryEnterOrder("CUST2_Order", "ANCHORAGE")
 
 		case "2":
 			err = internal.QueryCancelOrder()
 
 		case "3":
-			err = internal.QueryMarketDataRequest()
+			err = internal.QueryMarketDataRequest("CUST2_Marketdata", "ANCHORAGE")
 
 		case "4":
+			// Prompt the user for orders per second
+			var ordersPerSecond int
+			fmt.Print("Enter orders per second: ")
+			_, err := fmt.Scanf("%d", &ordersPerSecond)
+			if err != nil {
+				utils.PrintBad("Invalid input for orders per second")
+				break
+			}
+
+			// Prompt the user for total number of orders
+			var totalOrders int
+			fmt.Print("Enter total number of orders: ")
+			_, err = fmt.Scanf("%d", &totalOrders)
+			if err != nil {
+				utils.PrintBad("Invalid input for total orders")
+				break
+			}
+
+			// Ask if the user wants to set a cadency
+			var setCadency string
+			fmt.Print("Do you want to set a cadency for the load test? (yes/no): ")
+			_, err = fmt.Scanf("%s", &setCadency)
+			if err != nil {
+				utils.PrintBad("Invalid input for cadency choice")
+				break
+			}
+
+			// Create load test configuration
+			loadTestConfig := loadtest.LoadTestConfig{
+				OrdersPerSecond: ordersPerSecond,
+				TotalOrders:     totalOrders,
+				SenderCompID:    "CUST2_Order",
+				TargetCompID:    "ANCHORAGE",
+			}
+
+			if setCadency == "yes" {
+				// Prompt the user for cadency
+				var cadencyInput string
+				fmt.Print("Enter the cadency (e.g., '10m' for 10 minutes, '1d' for every day, '3d' for every 3 days): ")
+				_, err = fmt.Scanf("%s", &cadencyInput)
+				if err != nil {
+					utils.PrintBad("Invalid input for cadency")
+					break
+				}
+
+				// Parse the cadency input into a time.Duration
+				interval, err := time.ParseDuration(cadencyInput)
+				if err != nil {
+					utils.PrintBad("Invalid cadency format")
+					break
+				}
+
+				// Run the load test at the specified interval
+				fmt.Printf("Starting load test every %v...\n", interval)
+
+				// Loop to run the load test at the specified interval
+				for {
+					// Run the load test
+					loadtest.RunLoadTest(loadTestConfig)
+
+					// Wait for the next interval
+					fmt.Printf("Waiting for next load test after %v...\n", interval)
+					time.Sleep(interval)
+				}
+			} else if setCadency == "no" {
+				// Run once without cadency
+				loadtest.RunLoadTest(loadTestConfig)
+			} else {
+				utils.PrintBad("Invalid input for cadency choice")
+			}
+
+		case "5":
+			// Call readmetrics after the load test
+			err := readmetrics.Execute(LogFilePath, OutputFilePath, TmpDir)
+			if err != nil {
+				log.Fatalf("Error executing readmetrics: %v", err)
+			}
+
+		case "6":
 			//quit
 			break Loop
 
diff --git a/config/tradeclient.cfg b/config/tradeclient.cfg
index 52737fc..38bf9ab 100644
--- a/config/tradeclient.cfg
+++ b/config/tradeclient.cfg
@@ -1,27 +1,40 @@
 [DEFAULT]
-SocketConnectHost=127.0.0.1
-SocketConnectPort=5001
+SocketConnectHost=localhost
 HeartBtInt=30
-SenderCompID=TW
-TargetCompID=ISLD
 ResetOnLogon=Y
 FileLogPath=tmp
+#SocketPrivateKeyFile=config/client0.key
+#SocketCertificateFile=config/client0.crt
+#SocketCAFile=config/ca.crt
 
-[SESSION]
-BeginString=FIX.4.0
+#[SESSION]
+#BeginString=FIX.4.0
 
-[SESSION]
-BeginString=FIX.4.1
+#[SESSION]
+#BeginString=FIX.4.1
 
-[SESSION]
-BeginString=FIX.4.2
+#[SESSION]
+#BeginString=FIX.4.2
 
-[SESSION]
-BeginString=FIX.4.3
+#[SESSION]
+#BeginString=FIX.4.3
 
 [SESSION]
+SocketConnectPort=5002
 BeginString=FIX.4.4
+#SenderCompID=CUST1_Marketdata
+SenderCompID=CUST2_Marketdata
+#SenderCompID=CLIENT1_MD
+TargetCompID=ANCHORAGE
 
 [SESSION]
-BeginString=FIXT.1.1
-DefaultApplVerID=7
+SocketConnectPort=5001
+BeginString=FIX.4.4
+#SenderCompID=CUST1_Order
+SenderCompID=CUST2_Order
+#SenderCompID=CLIENT1_Order
+TargetCompID=ANCHORAGE
+
+#[SESSION]
+#BeginString=FIXT.1.1
+#DefaultApplVerID=7
diff --git a/go.mod b/go.mod
index 1cfecdc..b469ab5 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/quickfixgo/examples
 
-go 1.21
+go 1.23.1
 
 require (
 	github.com/fatih/color v1.16.0
@@ -17,18 +17,24 @@ require (
 	github.com/quickfixgo/tag v0.1.0
 	github.com/shopspring/decimal v1.3.1
 	github.com/spf13/cobra v1.8.0
+	github.com/stretchr/testify v1.9.0
 )
 
 require (
 	github.com/armon/go-proxyproto v0.1.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/quickfixgo/fixt11 v0.1.0 // indirect
 	github.com/rivo/uniseg v0.4.4 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
 	golang.org/x/net v0.18.0 // indirect
 	golang.org/x/sys v0.14.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 4e86b54..ab459de 100644
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,7 @@
 github.com/armon/go-proxyproto v0.1.0 h1:TWWcSsjco7o2itn6r25/5AqKBiWmsiuzsUDLT/MTl7k=
 github.com/armon/go-proxyproto v0.1.0/go.mod h1:Xj90dce2VKbHzRAeiVQAMBtj4M5oidoXJ8lmgyW21mw=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
@@ -9,6 +10,10 @@ github.com/gosuri/uitable v0.0.4 h1:IG2xLKRvErL3uhY6e1BylFzG+aJiwQviDDTfOKeKTpY=
 github.com/gosuri/uitable v0.0.4/go.mod h1:tKR86bXuXPZazfOTG1FIzvjIdXzd0mo4Vtn16vt0PJo=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
@@ -16,6 +21,7 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -45,6 +51,8 @@ github.com/quickfixgo/tag v0.1.0/go.mod h1:l/drB1eO3PwN9JQTDC9Vt2EqOcaXk3kGJ+eeC
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
 github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
@@ -52,10 +60,10 @@ github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
 github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/net v0.18.0 h1:mIYleuAkSbHh0tCv7RvjL3F6ZVbLjq4+R7zbOn3Kokg=
 golang.org/x/net v0.18.0/go.mod h1:/czyP5RqHAH4odGYxBJ1qz0+CE5WZ+2j1YgoEo8F2jQ=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -63,5 +71,7 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
 golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=