diff --git a/mp3/Client/client.go b/mp3/Client/client.go
index 310cd8e16dc05142237ef64bd32c92139bd20eaf..ca6fc41f258770be0ef09d26b40454be37f95102 100644
--- a/mp3/Client/client.go
+++ b/mp3/Client/client.go
@@ -35,7 +35,7 @@ type Response struct {
 	Message string
 }
 
-var NUM_SERVERS int = 5 // number of servers
+var NUM_SERVERS int = 1 // number of servers
 
 // fills client response channel
 func (client *Client) run_server() {
diff --git a/mp3/Server/server.go b/mp3/Server/server.go
index 55c97ca92d41364eab608b74811ad2afe41b7390..9ee1944b3a4124a0be219bda62d1d472d5dba2e1 100644
--- a/mp3/Server/server.go
+++ b/mp3/Server/server.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net"
 	"os"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -16,14 +17,16 @@ type Server struct {
 	Address             string
 	BranchNameToAddress map[string]string
 	Accounts            map[string]*Account
-	Clients             map[string]net.Conn // connected clients
-	Peers               map[string]net.Conn // connected peers
-	Lock                sync.Mutex          // lock for peer map
+	Clients             map[string]net.Conn     // connected clients [name, socket]
+	ClientEncs          map[string]*gob.Encoder // connected client encoders
+	Peers               map[string]net.Conn     // connected peers [address, socket]
+	PeerEncs            map[string]*gob.Encoder // connected peer encoders
+	Lock                sync.Mutex              // lock for client and peer map
+	PeerConnectedWG     sync.WaitGroup          // wait group for all peers to connect
 	ClientChan          chan Request
-	// PeerChan   chan PeerReque
+	PeerChan            chan Request
 
-	// ClientListener net.Listener
-	// PeerListener   net.Listener
+	TransactionTimestamps map[string]time.Time // timestamp for all the transactions
 }
 
 type WriteEntry struct {
@@ -32,16 +35,20 @@ type WriteEntry struct {
 }
 
 type Account struct {
-	Name                    string
-	Balance                 int
-	CreatedBy               string
-	RTS                     []string
+	Name      string
+	Balance   int
+	CreatedBy string
+	RTS       []time.Time
+
 	TW                      map[string]*WriteEntry // tentative writes
 	WriteTimestampCommitted []time.Time
+	Committed               bool
+	AccountLock             sync.Mutex
 }
 
 type Request struct {
 	ClientName  string
+	PeerName    string
 	Transaction string // type of transaction
 	Branch      string
 	Account     string
@@ -53,28 +60,52 @@ type Response struct {
 	Message string
 }
 
-// func (server *Server) run_server() {
-// 	// request := <-server.ClientChan
-// 	// fmt.Println("Got client message:", request.Transaction, request.Branch, request.Account, request.Amount)
-// 	// enc := gob.NewEncoder(clientConn)
-// 	// response := Response{Result: true, Message: "OK"}
-// 	// enc.Encode(&response)
-// }
+var NUM_SERVERS int = 2 // number of servers
+
+//////////////////////////////
+// CLIENT FUNCTIONS
+//////////////////////////////
 
-// func (server *Server) handle_peer_messages(peerConn net.Conn) {
-// 	request := Request{}
-// 	dec := gob.NewDecoder(peerConn)
+/*
+ * Does: receives and handles transaction, sends to other servers if needed
+ * additional logic for committing and aborting
+ * retrieves from client channel
+ * Spawns: none
+ */
+func (server *Server) run_coordinator() {
+	fmt.Println("Starting coordinator thread")
+	for {
+		request := <-server.ClientChan
+		fmt.Println("Got client message:", request.Transaction, request.Branch, request.Account, request.Amount)
 
-// 	for {
-// 		dec.Decode(&request)
-// 		server.PeerCa <- request
-// 	}
-// }
+		// send transaction to correct server
+		if request.Branch == server.BranchName {
+			// handle transaction
+		} else {
+			// request another server to handle transaction
+			request.PeerName = server.BranchName
+			server.Lock.Lock()
+			address := server.BranchNameToAddress[request.Branch]
+			server.PeerEncs[address].Encode(&request)
+			server.Lock.Unlock()
+		}
 
+		// to send back to client?
+		enc := gob.NewEncoder(server.Clients[request.ClientName])
+		response := Response{Result: true, Message: "OK"}
+		enc.Encode(&response)
+	}
+}
+
+/*
+ * Does: fills client channel
+ * Spawns: none
+ */
 func (server *Server) handle_client_messages(clientConn net.Conn) {
 	fmt.Println("Starting client handler thread")
 	dec := gob.NewDecoder(clientConn)
 
+	// initial decode used to remove
 	request := Request{}
 	dec.Decode(&request)
 	// add to map
@@ -89,31 +120,82 @@ func (server *Server) handle_client_messages(clientConn net.Conn) {
 			fmt.Println("Decode error:", err)
 			return
 		}
-		// fmt.Println("Placing", request.Transaction, "from", request.ClientName)
 		server.ClientChan <- request
 	}
 }
 
-// function that represents coordinator thread
-func (server *Server) run_coordinator() {
-	fmt.Println("Starting coordinator server")
-	for {
-		request := <-server.ClientChan
-		fmt.Println("Got client message:", request.Transaction, request.Branch, request.Account, request.Amount)
-		enc := gob.NewEncoder(server.Clients[request.ClientName])
+// listens for client connection and launches thread to handle client requests
+func (server *Server) listen_to_clients() {
+	ip := strings.Split(server.Address, ":")[0]
+	port, _ := strconv.Atoi(strings.Split(server.Address, ":")[1])
+	address := ip + ":" + strconv.Itoa(port+10)
 
+	input, err := net.Listen("tcp", address)
+	if err != nil {
+		fmt.Println("Listening on server failed")
+	}
+	defer input.Close()
+	for {
+		connection, err := input.Accept()
+		if err != nil {
+			fmt.Println("Error accepting client connection", err)
+			continue
+		}
+		// confirm connection with client
 		response := Response{Result: true, Message: "OK"}
+		enc := gob.NewEncoder(connection)
 		enc.Encode(&response)
+		// starts channel fill thread
+		go server.handle_client_messages(connection)
 	}
 }
 
-// listens for client connection and launches thread to handle client requests
-func (server *Server) connect_to_clients() {
+//////////////////////////////
+// SERVER FUNCTIONS
+//////////////////////////////
+
+/*
+ * Does: receives and handles sent transaction
+ * Spawns: none
+ */
+func (server *Server) run_server() {
+	fmt.Println("Starting peer thread")
+	for {
+		request := <-server.PeerChan
+		fmt.Println("Got peer message:", request.Transaction, request.Branch, request.Account, request.Amount)
+
+		// go server.handle_transaction(request)
+	}
+}
+
+/*
+ * Does: fills peer channel
+ * Spawns: none
+ */
+func (server *Server) handle_peer_messages(peerConn net.Conn) {
+	fmt.Println("Starting peer handler thread")
+	dec := gob.NewDecoder(peerConn)
+
+	for {
+		request := Request{}
+		err := dec.Decode(&request)
+		if err != nil {
+			fmt.Println("Decode error:", err)
+			return
+		}
+		server.PeerChan <- request
+	}
+}
+
+/*
+ * Does: listens for tcp request from peers and accepts connection
+ * Spawns: multiple threads for each peer connection that fills peer channel
+ */
+func (server *Server) listen_to_peers() {
 	input, err := net.Listen("tcp", server.Address)
 	if err != nil {
 		fmt.Println("Listening on server failed")
 	}
-
 	defer input.Close()
 	for {
 		connection, err := input.Accept()
@@ -121,18 +203,19 @@ func (server *Server) connect_to_clients() {
 			fmt.Println("Error accepting client connection", err)
 			continue
 		}
-		// confirm connection with client
-		response := Response{Result: true, Message: "OK"}
-		enc := gob.NewEncoder(connection)
-		enc.Encode(&response)
 
 		// starts channel fill thread
-		go server.handle_client_messages(connection)
+		go server.handle_peer_messages(connection)
 	}
 }
 
-// lsiten to tcp from other servers and handle necessary transactions
+/*
+ * Does: Sends tcp request to all other servers in peer list
+ * Spawns: Nothing
+ */
 func (server *Server) connect_to_peers() {
+	server.PeerConnectedWG.Add(NUM_SERVERS - 1)
+
 	for address := range server.Peers {
 		go func(peerAddr string) {
 			var conn net.Conn
@@ -142,17 +225,23 @@ func (server *Server) connect_to_peers() {
 				if err == nil {
 					break
 				}
-				time.Sleep(2 * time.Second)
+				time.Sleep(1 * time.Second)
 			}
 			server.Lock.Lock()
 			server.Peers[peerAddr] = conn
+			server.PeerEncs[address] = gob.NewEncoder(conn)
+			server.PeerConnectedWG.Done()
 			server.Lock.Unlock()
-			fmt.Println("Connected to peer", peerAddr)
-			// Handle peer communication here if needed
 		}(address)
 	}
+	server.PeerConnectedWG.Wait()
+	fmt.Println("Server Peers:", server.Peers)
 }
 
+//////////////////////////////
+// HELPER FUNCTIONS
+//////////////////////////////
+
 func (server *Server) read_file(config_name string) {
 	config, error := os.Open(config_name)
 	if error != nil {
@@ -163,9 +252,9 @@ func (server *Server) read_file(config_name string) {
 	reader := bufio.NewReader(config)
 
 	// assumption that only ever have 5 servers (no more, no less)
-	for i := 0; i < 1; i++ {
+	for i := 0; i < NUM_SERVERS; i++ {
 		text, serr := reader.ReadString('\n')
-		if serr != nil && i < 0 {
+		if serr != nil && i < NUM_SERVERS-1 {
 			fmt.Println("failed to read config", serr)
 		}
 		substrings := strings.Split(text, " ")
@@ -185,6 +274,24 @@ func (server *Server) read_file(config_name string) {
 	config.Close()
 }
 
+func (server *Server) print_all_balances() {
+	server.Lock.Lock()
+	for _, account := range server.Accounts {
+		if account.Committed && account.Balance > 0 {
+			fmt.Println(server.BranchName+"."+account.Name, "=", account.Balance)
+		}
+	}
+	server.Lock.Unlock()
+}
+
+//////////////////////////////
+// TIMESTAMP ORDERING AND TRANSACTION HANDLING START
+//////////////////////////////
+
+//////////////////////////////
+// START OF PROGRAM
+//////////////////////////////
+
 func main() {
 	// init server
 	server := Server{}
@@ -196,17 +303,19 @@ func main() {
 	server.BranchNameToAddress = make(map[string]string)
 	server.Accounts = make(map[string]*Account)
 	server.Clients = make(map[string]net.Conn)
+	server.ClientEncs = make(map[string]*gob.Encoder)
 	server.Peers = make(map[string]net.Conn)
+	server.PeerEncs = make(map[string]*gob.Encoder)
 	server.ClientChan = make(chan Request, 1000)
+	server.PeerChan = make(chan Request, 1000)
 	server.read_file(configPath)
 
-	fmt.Println("Server State:", server.BranchName, server.Address, server.BranchNameToAddress, server.Accounts, server.Peers)
-
 	go server.run_coordinator()
-	go server.connect_to_clients()
-	// go server.connect_to_peers()
+	go server.listen_to_clients()
 
-	for {
-		continue
-	}
+	go server.run_server()
+	go server.listen_to_peers() // potential race condition with connect
+	go server.connect_to_peers()
+
+	select {}
 }
diff --git a/mp3/client b/mp3/client
deleted file mode 100755
index f781997471f0e2377f37798542f1e3e0c0aa0639..0000000000000000000000000000000000000000
Binary files a/mp3/client and /dev/null differ
diff --git a/mp3/config_test.txt b/mp3/config_test.txt
index a3b8b36bfc6d5c124ac6fbbaba92d019d90d7fed..b940ff0626cedb6cea86636e484fabe6ea6d85b3 100644
--- a/mp3/config_test.txt
+++ b/mp3/config_test.txt
@@ -1,5 +1,2 @@
 A 127.0.0.1 2005
-B 127.0.0.1 2006
-C 127.0.0.1 2007
-D 127.0.0.1 2008
-E 127.0.0.1 2009
\ No newline at end of file
+B 127.0.0.1 2006
\ No newline at end of file