orderbook: Implement initial linked list (#643)

* Exchanges: Initial implementation after rebase of depth (WIP) * orderbook/buffer: convert and couple orderbook interaction functionality from buffer to orderbook linked list - Use single point reference for orderbook depth * buffer/orderbook: conversion continued (WIP) * exchange: buffer/linkedlist handover (WIP) * Added some tests for yesterday * linkedList: added more testing and trying to figure out broken things * Started tying everything in * continuous integration and testing * orderbook: expanded tests * go mod tidy * Add in different synchornisation levels for protocols Add in timer for the streaming system to reduce updates to datahandler Add in more test code as I integrate more exchanges * Depth: Add tests, add length check to call linked list updating, add in constructor. Linked List: Improve tests, add in checks for zero liquidity on books. Node: Added in cleaner POC, add in contructor. Buffer: Fixed tests, checked benchmarks. * orderbook: reinstate dispatch calls * Addr glorious & madcozbad nits * fix functionality and add tests * Address linterinos * remove label * expanded comment * fix races and and bitmex test * reinstate go routine for alerting changes * rm line :D * fix more tests * Addr glorious nits * rm glorious field * depth: defer unlock to stop deadlock * orderbook: remove unused vars * buffer: fix test to what it should be * nits: madcosbad addr * nits: glorious nits * linkedlist: remove unused params * orderbook: shift time call to outside of push to inline, add in case for update inster price for zero liquidity, nits * orderbook: nits addressed * engine: change stream -> websocket convention and remove unused function * nits: glorious nits * Websocket Buffer: Add verbosity switch * linked list: Add comment * linked list: fix spelling * nits: glorious nits * orderbook: Adds in test and explicit time type with constructor, fix nits * linter * spelling: removed the dere fence * depth: Update alerting mechanism to a more battle tested state * depth: spelling * nits: glorious nits * linked list: match cases * buffer: fix linter issue * golangci: increase timeout by 30 seconds * nodes: update atomic checks * spelling: fix * node: add in commentary * exchanges/syncer: add function to switch over to REST when websocket functionality is not available for a specific asset type * linter: exchange linter issues * syncer: Add in warning * nits: glorious nits * AssetWebsocketSupport: unexport map * Nits: Adrr * rm letter * exchanges: Orderbook verification change for naming, deprecate checksum bypass as it has the potential to obfuscate errors that are at the tail end of the book, add in verification for websocket stream updates * general: fix spelling remove breakpoint * nits: fix more glorious nits until more are found * orderbook: fix tests * orderbook: fix wait tests and add in more checks * nits: addr * orderbook: remove dispatch reference * linkedlist: consolidate bid/ask functions * linked lisdt: remove words * fix spelling
2026-05-19 23:16:48 +00:00 · 2021-04-23 15:16:01 +10:00
parent 9973523f1e
commit 7b718700f7
81 changed files with 4546 additions and 1592 deletions
--- a/exchanges/stream/buffer/buffer_test.go
+++ b/exchanges/stream/buffer/buffer_test.go
@@ -26,26 +26,27 @@ const (
 	exchangeName = "exchangeTest"
 )

-func createSnapshot() (obl *Orderbook, asks, bids []orderbook.Item, err error) {
-	var snapShot1 orderbook.Base
-	snapShot1.ExchangeName = exchangeName
-	asks = []orderbook.Item{
-		{Price: 4000, Amount: 1, ID: 6},
+func createSnapshot() (holder *Orderbook, asks, bids orderbook.Items, err error) {
+	asks = orderbook.Items{{Price: 4000, Amount: 1, ID: 6}}
+	bids = orderbook.Items{{Price: 4000, Amount: 1, ID: 6}}
+
+	book := &orderbook.Base{
+		Exchange:         exchangeName,
+		Asks:             asks,
+		Bids:             bids,
+		Asset:            asset.Spot,
+		Pair:             cp,
+		PriceDuplication: true,
 	}
-	bids = []orderbook.Item{
-		{Price: 4000, Amount: 1, ID: 6},
-	}
-	snapShot1.Asks = asks
-	snapShot1.Bids = bids
-	snapShot1.AssetType = asset.Spot
-	snapShot1.Pair = cp
-	snapShot1.NotAggregated = true
-	obl = &Orderbook{
+
+	newBook := make(map[currency.Code]map[currency.Code]map[asset.Item]*orderbookHolder)
+
+	holder = &Orderbook{
 		exchangeName: exchangeName,
 		dataHandler:  make(chan interface{}, 100),
-		ob:           make(map[currency.Code]map[currency.Code]map[asset.Item]*orderbookHolder),
+		ob:           newBook,
 	}
-	err = obl.LoadSnapshot(&snapShot1)
+	err = holder.LoadSnapshot(book)
 	return
 }

@@ -108,20 +109,13 @@ func BenchmarkUpdateAsksByPrice(b *testing.B) {

 // BenchmarkBufferPerformance demonstrates buffer more performant than multi
 // process calls
+// 4219518	       287 ns/op	     176 B/op	       1 allocs/op
 func BenchmarkBufferPerformance(b *testing.B) {
-	obl, asks, bids, err := createSnapshot()
+	holder, asks, bids, err := createSnapshot()
 	if err != nil {
 		b.Fatal(err)
 	}
-	obl.bufferEnabled = true
-	// This is to ensure we do not send in zero orderbook info to our main book
-	// in orderbook.go, orderbooks should not be zero even after an update.
-	dummyItem := orderbook.Item{
-		Amount: 1333337,
-		Price:  1337.1337,
-		ID:     1337,
-	}
-	obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids = append(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids, dummyItem)
+	holder.bufferEnabled = true
 	update := &Update{
 		Bids:       bids,
 		Asks:       asks,
@@ -134,7 +128,7 @@ func BenchmarkBufferPerformance(b *testing.B) {
 		randomIndex := rand.Intn(4) // nolint:gosec // no need to import crypo/rand for testing
 		update.Asks = itemArray[randomIndex]
 		update.Bids = itemArray[randomIndex]
-		err = obl.Update(update)
+		err = holder.Update(update)
 		if err != nil {
 			b.Fatal(err)
 		}
@@ -142,21 +136,14 @@ func BenchmarkBufferPerformance(b *testing.B) {
 }

 // BenchmarkBufferSortingPerformance benchmark
+// 2693391	       467 ns/op	     208 B/op	       2 allocs/op
 func BenchmarkBufferSortingPerformance(b *testing.B) {
-	obl, asks, bids, err := createSnapshot()
+	holder, asks, bids, err := createSnapshot()
 	if err != nil {
 		b.Fatal(err)
 	}
-	obl.bufferEnabled = true
-	obl.sortBuffer = true
-	// This is to ensure we do not send in zero orderbook info to our main book
-	// in orderbook.go, orderbooks should not be zero even after an update.
-	dummyItem := orderbook.Item{
-		Amount: 1333337,
-		Price:  1337.1337,
-		ID:     1337,
-	}
-	obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids = append(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids, dummyItem)
+	holder.bufferEnabled = true
+	holder.sortBuffer = true
 	update := &Update{
 		Bids:       bids,
 		Asks:       asks,
@@ -169,7 +156,7 @@ func BenchmarkBufferSortingPerformance(b *testing.B) {
 		randomIndex := rand.Intn(4) // nolint:gosec // no need to import crypo/rand for testing
 		update.Asks = itemArray[randomIndex]
 		update.Bids = itemArray[randomIndex]
-		err = obl.Update(update)
+		err = holder.Update(update)
 		if err != nil {
 			b.Fatal(err)
 		}
@@ -177,22 +164,15 @@ func BenchmarkBufferSortingPerformance(b *testing.B) {
 }

 // BenchmarkBufferSortingPerformance benchmark
+// 1000000	      1019 ns/op	     208 B/op	       2 allocs/op
 func BenchmarkBufferSortingByIDPerformance(b *testing.B) {
-	obl, asks, bids, err := createSnapshot()
+	holder, asks, bids, err := createSnapshot()
 	if err != nil {
 		b.Fatal(err)
 	}
-	obl.bufferEnabled = true
-	obl.sortBuffer = true
-	obl.sortBufferByUpdateIDs = true
-	// This is to ensure we do not send in zero orderbook info to our main book
-	// in orderbook.go, orderbooks should not be zero even after an update.
-	dummyItem := orderbook.Item{
-		Amount: 1333337,
-		Price:  1337.1337,
-		ID:     1337,
-	}
-	obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids = append(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids, dummyItem)
+	holder.bufferEnabled = true
+	holder.sortBuffer = true
+	holder.sortBufferByUpdateIDs = true
 	update := &Update{
 		Bids:       bids,
 		Asks:       asks,
@@ -205,28 +185,21 @@ func BenchmarkBufferSortingByIDPerformance(b *testing.B) {
 		randomIndex := rand.Intn(4) // nolint:gosec // no need to import crypo/rand for testing
 		update.Asks = itemArray[randomIndex]
 		update.Bids = itemArray[randomIndex]
-		err = obl.Update(update)
+		err = holder.Update(update)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }

-// BenchmarkNoBufferPerformance demonstrates orderbook process less performant
+// BenchmarkNoBufferPerformance demonstrates orderbook process more performant
 // than buffer
+// 9516966	       141 ns/op	       0 B/op	       0 allocs/op
 func BenchmarkNoBufferPerformance(b *testing.B) {
 	obl, asks, bids, err := createSnapshot()
 	if err != nil {
 		b.Fatal(err)
 	}
-	// This is to ensure we do not send in zero orderbook info to our main book
-	// in orderbook.go, orderbooks should not be zero even after an update.
-	dummyItem := orderbook.Item{
-		Amount: 1333337,
-		Price:  1337.1337,
-		ID:     1337,
-	}
-	obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids = append(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids, dummyItem)
 	update := &Update{
 		Bids:       bids,
 		Asks:       asks,
@@ -247,13 +220,13 @@ func BenchmarkNoBufferPerformance(b *testing.B) {
 }

 func TestUpdates(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Error(err)
 	}

-	holder := obl.ob[cp.Base][cp.Quote][asset.Spot]
-	holder.updateByPrice(&Update{
+	book := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	book.updateByPrice(&Update{
 		Bids:       itemArray[5],
 		Asks:       itemArray[5],
 		Pair:       cp,
@@ -264,7 +237,7 @@ func TestUpdates(t *testing.T) {
 		t.Error(err)
 	}

-	holder.updateByPrice(&Update{
+	book.updateByPrice(&Update{
 		Bids:       itemArray[0],
 		Asks:       itemArray[0],
 		Pair:       cp,
@@ -275,23 +248,23 @@ func TestUpdates(t *testing.T) {
 		t.Error(err)
 	}

-	if len(holder.ob.Asks) != 3 {
+	if book.ob.GetAskLength() != 3 {
 		t.Error("Did not update")
 	}
 }

 // TestHittingTheBuffer logic test
 func TestHittingTheBuffer(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Fatal(err)
 	}
-	obl.bufferEnabled = true
-	obl.obBufferLimit = 5
+	holder.bufferEnabled = true
+	holder.obBufferLimit = 5
 	for i := range itemArray {
 		asks := itemArray[i]
 		bids := itemArray[i]
-		err = obl.Update(&Update{
+		err = holder.Update(&Update{
 			Bids:       bids,
 			Asks:       asks,
 			Pair:       cp,
@@ -302,67 +275,67 @@ func TestHittingTheBuffer(t *testing.T) {
 			t.Fatal(err)
 		}
 	}
-	if len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks) != 3 {
-		t.Errorf("expected 3 entries, received: %v",
-			len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks))
+
+	book := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	if book.ob.GetAskLength() != 3 {
+		t.Errorf("expected 3 entries, received: %v", book.ob.GetAskLength())
 	}
-	if len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids) != 3 {
-		t.Errorf("expected 3 entries, received: %v",
-			len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids))
+	if book.ob.GetBidLength() != 3 {
+		t.Errorf("expected 3 entries, received: %v", book.ob.GetBidLength())
 	}
 }

 // TestInsertWithIDs logic test
 func TestInsertWithIDs(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Fatal(err)
 	}
-	obl.bufferEnabled = true
-	obl.updateEntriesByID = true
-	obl.obBufferLimit = 5
+	holder.bufferEnabled = true
+	holder.updateEntriesByID = true
+	holder.obBufferLimit = 5
 	for i := range itemArray {
 		asks := itemArray[i]
 		if asks[0].Amount <= 0 {
 			continue
 		}
 		bids := itemArray[i]
-		err = obl.Update(&Update{
+		err = holder.Update(&Update{
 			Bids:       bids,
 			Asks:       asks,
 			Pair:       cp,
 			UpdateTime: time.Now(),
 			Asset:      asset.Spot,
-			Action:     "insert",
+			Action:     UpdateInsert,
 		})
 		if err != nil {
 			t.Fatal(err)
 		}
 	}
-	if len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks) != 6 {
-		t.Errorf("expected 6 entries, received: %v",
-			len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks))
+
+	book := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	if book.ob.GetAskLength() != 6 {
+		t.Errorf("expected 5 entries, received: %v", book.ob.GetAskLength())
 	}
-	if len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids) != 6 {
-		t.Errorf("expected 6 entries, received: %v",
-			len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids))
+	if book.ob.GetBidLength() != 6 {
+		t.Errorf("expected 5 entries, received: %v", book.ob.GetBidLength())
 	}
 }

 // TestSortIDs logic test
 func TestSortIDs(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Fatal(err)
 	}
-	obl.bufferEnabled = true
-	obl.sortBufferByUpdateIDs = true
-	obl.sortBuffer = true
-	obl.obBufferLimit = 5
+	holder.bufferEnabled = true
+	holder.sortBufferByUpdateIDs = true
+	holder.sortBuffer = true
+	holder.obBufferLimit = 5
 	for i := range itemArray {
 		asks := itemArray[i]
 		bids := itemArray[i]
-		err = obl.Update(&Update{
+		err = holder.Update(&Update{
 			Bids:     bids,
 			Asks:     asks,
 			Pair:     cp,
@@ -373,19 +346,18 @@ func TestSortIDs(t *testing.T) {
 			t.Fatal(err)
 		}
 	}
-	if len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks) != 3 {
-		t.Errorf("expected 3 entries, received: %v",
-			len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks))
+	book := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	if book.ob.GetAskLength() != 3 {
+		t.Errorf("expected 3 entries, received: %v", book.ob.GetAskLength())
 	}
-	if len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids) != 3 {
-		t.Errorf("expected 3 entries, received: %v",
-			len(obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Bids))
+	if book.ob.GetAskLength() != 3 {
+		t.Errorf("expected 3 entries, received: %v", book.ob.GetAskLength())
 	}
 }

 // TestOutOfOrderIDs logic test
 func TestOutOfOrderIDs(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -394,12 +366,12 @@ func TestOutOfOrderIDs(t *testing.T) {
 		t.Errorf("expected sorted price to be 3000, received: %v",
 			itemArray[1][0].Price)
 	}
-	obl.bufferEnabled = true
-	obl.sortBuffer = true
-	obl.obBufferLimit = 5
+	holder.bufferEnabled = true
+	holder.sortBuffer = true
+	holder.obBufferLimit = 5
 	for i := range itemArray {
 		asks := itemArray[i]
-		err = obl.Update(&Update{
+		err = holder.Update(&Update{
 			Asks:     asks,
 			Pair:     cp,
 			UpdateID: outOFOrderIDs[i],
@@ -409,15 +381,16 @@ func TestOutOfOrderIDs(t *testing.T) {
 			t.Fatal(err)
 		}
 	}
+	book := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	cpy := book.ob.Retrieve()
 	// Index 1 since index 0 is price 7000
-	if obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks[1].Price != 2000 {
-		t.Errorf("expected sorted price to be 3000, received: %v",
-			obl.ob[cp.Base][cp.Quote][asset.Spot].ob.Asks[1].Price)
+	if cpy.Asks[1].Price != 2000 {
+		t.Errorf("expected sorted price to be 2000, received: %v", cpy.Asks[1].Price)
 	}
 }

 func TestOrderbookLastUpdateID(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -428,7 +401,7 @@ func TestOrderbookLastUpdateID(t *testing.T) {

 	for i := range itemArray {
 		asks := itemArray[i]
-		err = obl.Update(&Update{
+		err = holder.Update(&Update{
 			Asks:     asks,
 			Pair:     cp,
 			UpdateID: int64(i) + 1,
@@ -439,7 +412,10 @@ func TestOrderbookLastUpdateID(t *testing.T) {
 		}
 	}

-	ob := obl.GetOrderbook(cp, asset.Spot)
+	ob, err := holder.GetOrderbook(cp, asset.Spot)
+	if err != nil {
+		t.Fatal(err)
+	}
 	if exp := len(itemArray); ob.LastUpdateID != int64(exp) {
 		t.Errorf("expected last update id to be %d, received: %v", exp, ob.LastUpdateID)
 	}
@@ -447,7 +423,7 @@ func TestOrderbookLastUpdateID(t *testing.T) {

 // TestRunUpdateWithoutSnapshot logic test
 func TestRunUpdateWithoutSnapshot(t *testing.T) {
-	var obl Orderbook
+	var holder Orderbook
 	var snapShot1 orderbook.Base
 	asks := []orderbook.Item{
 		{Price: 4000, Amount: 1, ID: 8},
@@ -458,21 +434,18 @@ func TestRunUpdateWithoutSnapshot(t *testing.T) {
 	}
 	snapShot1.Asks = asks
 	snapShot1.Bids = bids
-	snapShot1.AssetType = asset.Spot
+	snapShot1.Asset = asset.Spot
 	snapShot1.Pair = cp
-	obl.exchangeName = exchangeName
-	err := obl.Update(&Update{
+	holder.exchangeName = exchangeName
+	err := holder.Update(&Update{
 		Bids:       bids,
 		Asks:       asks,
 		Pair:       cp,
 		UpdateTime: time.Now(),
 		Asset:      asset.Spot,
 	})
-	if err == nil {
-		t.Fatal("expected an error running update with no snapshot loaded")
-	}
-	if err.Error() != "ob.Base could not be found for Exchange exchangeTest CurrencyPair: BTCUSD AssetType: spot" {
-		t.Fatal(err)
+	if !errors.Is(err, errDepthNotFound) {
+		t.Fatalf("expected %v but received %v", errDepthNotFound, err)
 	}
 }

@@ -482,7 +455,7 @@ func TestRunUpdateWithoutAnyUpdates(t *testing.T) {
 	var snapShot1 orderbook.Base
 	snapShot1.Asks = []orderbook.Item{}
 	snapShot1.Bids = []orderbook.Item{}
-	snapShot1.AssetType = asset.Spot
+	snapShot1.Asset = asset.Spot
 	snapShot1.Pair = cp
 	obl.exchangeName = exchangeName
 	err := obl.Update(&Update{
@@ -492,11 +465,8 @@ func TestRunUpdateWithoutAnyUpdates(t *testing.T) {
 		UpdateTime: time.Now(),
 		Asset:      asset.Spot,
 	})
-	if err == nil {
-		t.Fatal("expected an error running update with no snapshot loaded")
-	}
-	if err.Error() != "websocket orderbook buffer error: update bid/ask targets cannot be nil" {
-		t.Fatal("expected nil asks and bids error")
+	if !errors.Is(err, errUpdateNoTargets) {
+		t.Fatalf("expected %v but received %v", errUpdateNoTargets, err)
 	}
 }

@@ -506,9 +476,9 @@ func TestRunSnapshotWithNoData(t *testing.T) {
 	obl.ob = make(map[currency.Code]map[currency.Code]map[asset.Item]*orderbookHolder)
 	obl.dataHandler = make(chan interface{}, 1)
 	var snapShot1 orderbook.Base
-	snapShot1.AssetType = asset.Spot
+	snapShot1.Asset = asset.Spot
 	snapShot1.Pair = cp
-	snapShot1.ExchangeName = "test"
+	snapShot1.Exchange = "test"
 	obl.exchangeName = "test"
 	err := obl.LoadSnapshot(&snapShot1)
 	if err != nil {
@@ -522,7 +492,7 @@ func TestLoadSnapshot(t *testing.T) {
 	obl.dataHandler = make(chan interface{}, 100)
 	obl.ob = make(map[currency.Code]map[currency.Code]map[asset.Item]*orderbookHolder)
 	var snapShot1 orderbook.Base
-	snapShot1.ExchangeName = "SnapshotWithOverride"
+	snapShot1.Exchange = "SnapshotWithOverride"
 	asks := []orderbook.Item{
 		{Price: 4000, Amount: 1, ID: 8},
 	}
@@ -531,7 +501,7 @@ func TestLoadSnapshot(t *testing.T) {
 	}
 	snapShot1.Asks = asks
 	snapShot1.Bids = bids
-	snapShot1.AssetType = asset.Spot
+	snapShot1.Asset = asset.Spot
 	snapShot1.Pair = cp
 	err := obl.LoadSnapshot(&snapShot1)
 	if err != nil {
@@ -556,11 +526,11 @@ func TestFlushbuffer(t *testing.T) {

 // TestInsertingSnapShots logic test
 func TestInsertingSnapShots(t *testing.T) {
-	var obl Orderbook
-	obl.dataHandler = make(chan interface{}, 100)
-	obl.ob = make(map[currency.Code]map[currency.Code]map[asset.Item]*orderbookHolder)
+	var holder Orderbook
+	holder.dataHandler = make(chan interface{}, 100)
+	holder.ob = make(map[currency.Code]map[currency.Code]map[asset.Item]*orderbookHolder)
 	var snapShot1 orderbook.Base
-	snapShot1.ExchangeName = "WSORDERBOOKTEST1"
+	snapShot1.Exchange = "WSORDERBOOKTEST1"
 	asks := []orderbook.Item{
 		{Price: 6000, Amount: 1, ID: 1},
 		{Price: 6001, Amount: 0.5, ID: 2},
@@ -591,14 +561,14 @@ func TestInsertingSnapShots(t *testing.T) {

 	snapShot1.Asks = asks
 	snapShot1.Bids = bids
-	snapShot1.AssetType = asset.Spot
+	snapShot1.Asset = asset.Spot
 	snapShot1.Pair = cp
-	err := obl.LoadSnapshot(&snapShot1)
+	err := holder.LoadSnapshot(&snapShot1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var snapShot2 orderbook.Base
-	snapShot2.ExchangeName = "WSORDERBOOKTEST2"
+	snapShot2.Exchange = "WSORDERBOOKTEST2"
 	asks = []orderbook.Item{
 		{Price: 51, Amount: 1, ID: 1},
 		{Price: 52, Amount: 0.5, ID: 2},
@@ -627,19 +597,21 @@ func TestInsertingSnapShots(t *testing.T) {
 		{Price: 39, Amount: 7, ID: 22},
 	}

-	snapShot2.Asks = orderbook.SortAsks(asks)
-	snapShot2.Bids = orderbook.SortBids(bids)
-	snapShot2.AssetType = asset.Spot
+	snapShot2.Asks = asks
+	snapShot2.Asks.SortAsks()
+	snapShot2.Bids = bids
+	snapShot2.Bids.SortBids()
+	snapShot2.Asset = asset.Spot
 	snapShot2.Pair, err = currency.NewPairFromString("LTCUSD")
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = obl.LoadSnapshot(&snapShot2)
+	err = holder.LoadSnapshot(&snapShot2)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var snapShot3 orderbook.Base
-	snapShot3.ExchangeName = "WSORDERBOOKTEST3"
+	snapShot3.Exchange = "WSORDERBOOKTEST3"
 	asks = []orderbook.Item{
 		{Price: 511, Amount: 1, ID: 1},
 		{Price: 52, Amount: 0.5, ID: 2},
@@ -668,74 +640,88 @@ func TestInsertingSnapShots(t *testing.T) {
 		{Price: 39, Amount: 7, ID: 22},
 	}

-	snapShot3.Asks = orderbook.SortAsks(asks)
-	snapShot3.Bids = orderbook.SortBids(bids)
-	snapShot3.AssetType = "FUTURES"
+	snapShot3.Asks = asks
+	snapShot3.Asks.SortAsks()
+	snapShot3.Bids = bids
+	snapShot3.Bids.SortBids()
+	snapShot3.Asset = asset.Futures
 	snapShot3.Pair, err = currency.NewPairFromString("LTCUSD")
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = obl.LoadSnapshot(&snapShot3)
+	err = holder.LoadSnapshot(&snapShot3)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if obl.ob[snapShot1.Pair.Base][snapShot1.Pair.Quote][snapShot1.AssetType].ob.Asks[0] != snapShot1.Asks[0] {
+	ob, err := holder.GetOrderbook(snapShot1.Pair, snapShot1.Asset)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ob.Asks[0] != snapShot1.Asks[0] {
 		t.Errorf("loaded data mismatch. Expected %v, received %v",
 			snapShot1.Asks[0],
-			obl.ob[snapShot1.Pair.Base][snapShot1.Pair.Quote][snapShot1.AssetType].ob.Asks[0])
+			ob.Asks[0])
 	}
-	if obl.ob[snapShot2.Pair.Base][snapShot1.Pair.Quote][snapShot2.AssetType].ob.Asks[0] != snapShot2.Asks[0] {
+	ob, err = holder.GetOrderbook(snapShot2.Pair, snapShot2.Asset)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ob.Asks[0] != snapShot2.Asks[0] {
 		t.Errorf("loaded data mismatch. Expected %v, received %v",
 			snapShot2.Asks[0],
-			obl.ob[snapShot2.Pair.Base][snapShot1.Pair.Quote][snapShot2.AssetType].ob.Asks[0])
+			ob.Asks[0])
 	}
-	if obl.ob[snapShot3.Pair.Base][snapShot1.Pair.Quote][snapShot3.AssetType].ob.Asks[0] != snapShot3.Asks[0] {
+	ob, err = holder.GetOrderbook(snapShot3.Pair, snapShot3.Asset)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ob.Asks[0] != snapShot3.Asks[0] {
 		t.Errorf("loaded data mismatch. Expected %v, received %v",
 			snapShot3.Asks[0],
-			obl.ob[snapShot3.Pair.Base][snapShot1.Pair.Quote][snapShot3.AssetType].ob.Asks[0])
+			ob.Asks[0])
 	}
 }

 func TestGetOrderbook(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Fatal(err)
 	}
-	ob := obl.GetOrderbook(cp, asset.Spot)
-	bufferOb := obl.ob[cp.Base][cp.Quote][asset.Spot]
-	if bufferOb.ob == ob {
-		t.Error("orderbooks should be separate in pointer value and not linked to orderbook package")
+	ob, err := holder.GetOrderbook(cp, asset.Spot)
+	if err != nil {
+		t.Fatal(err)
 	}
-
-	if len(bufferOb.ob.Asks) != len(ob.Asks) ||
-		len(bufferOb.ob.Bids) != len(ob.Bids) ||
-		bufferOb.ob.AssetType != ob.AssetType ||
-		bufferOb.ob.ExchangeName != ob.ExchangeName ||
-		bufferOb.ob.LastUpdateID != ob.LastUpdateID ||
-		bufferOb.ob.NotAggregated != ob.NotAggregated ||
-		bufferOb.ob.Pair != ob.Pair {
+	bufferOb := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	b := bufferOb.ob.Retrieve()
+	if bufferOb.ob.GetAskLength() != len(ob.Asks) ||
+		bufferOb.ob.GetBidLength() != len(ob.Bids) ||
+		b.Asset != ob.Asset ||
+		b.Exchange != ob.Exchange ||
+		b.LastUpdateID != ob.LastUpdateID ||
+		b.PriceDuplication != ob.PriceDuplication ||
+		b.Pair != ob.Pair {
 		t.Fatal("data on both books should be the same")
 	}
 }

 func TestSetup(t *testing.T) {
 	w := Orderbook{}
-	err := w.Setup(0, false, false, false, false, "", nil)
-	if err == nil || !errors.Is(err, errUnsetExchangeName) {
+	err := w.Setup(0, false, false, false, false, true, "", nil)
+	if !errors.Is(err, errUnsetExchangeName) {
 		t.Fatalf("expected error %v but received %v", errUnsetExchangeName, err)
 	}

-	err = w.Setup(0, false, false, false, false, "test", nil)
-	if err == nil || !errors.Is(err, errUnsetDataHandler) {
+	err = w.Setup(0, false, false, false, false, false, "test", nil)
+	if !errors.Is(err, errUnsetDataHandler) {
 		t.Fatalf("expected error %v but received %v", errUnsetDataHandler, err)
 	}

-	err = w.Setup(0, true, false, false, false, "test", make(chan interface{}))
-	if err == nil || !errors.Is(err, errIssueBufferEnabledButNoLimit) {
+	err = w.Setup(0, true, false, false, false, true, "test", make(chan interface{}))
+	if !errors.Is(err, errIssueBufferEnabledButNoLimit) {
 		t.Fatalf("expected error %v but received %v", errIssueBufferEnabledButNoLimit, err)
 	}

-	err = w.Setup(1337, true, true, true, true, "test", make(chan interface{}))
+	err = w.Setup(1337, true, true, true, true, false, "test", make(chan interface{}))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -752,25 +738,25 @@ func TestSetup(t *testing.T) {
 func TestValidate(t *testing.T) {
 	w := Orderbook{}
 	err := w.validate(nil)
-	if err == nil || !errors.Is(err, errUpdateIsNil) {
+	if !errors.Is(err, errUpdateIsNil) {
 		t.Fatalf("expected error %v but received %v", errUpdateIsNil, err)
 	}

 	err = w.validate(&Update{})
-	if err == nil || !errors.Is(err, errUpdateNoTargets) {
+	if !errors.Is(err, errUpdateNoTargets) {
 		t.Fatalf("expected error %v but received %v", errUpdateNoTargets, err)
 	}
 }

 func TestEnsureMultipleUpdatesViaPrice(t *testing.T) {
-	obl, _, _, err := createSnapshot()
+	holder, _, _, err := createSnapshot()
 	if err != nil {
 		t.Error(err)
 	}

 	asks := bidAskGenerator()
-	holder := obl.ob[cp.Base][cp.Quote][asset.Spot]
-	holder.updateByPrice(&Update{
+	book := holder.ob[cp.Base][cp.Quote][asset.Spot]
+	book.updateByPrice(&Update{
 		Bids:       asks,
 		Asks:       asks,
 		Pair:       cp,
@@ -781,69 +767,12 @@ func TestEnsureMultipleUpdatesViaPrice(t *testing.T) {
 		t.Error(err)
 	}

-	if len(holder.ob.Asks) <= 3 {
+	if book.ob.GetAskLength() <= 3 {
 		t.Errorf("Insufficient updates")
 	}
 }

-func TestInsertItem(t *testing.T) {
-	update := []orderbook.Item{{Price: 4}}
-
-	// Correctly aligned
-	asks := []orderbook.Item{
-		{
-			Price: 1,
-		},
-		{
-			Price: 2,
-		},
-		{
-			Price: 3,
-		},
-		{
-			Price: 5,
-		},
-		{
-			Price: 6,
-		},
-		{
-			Price: 7,
-		},
-	}
-
-	insertUpdatesAsk(update, &asks)
-	if asks[3].Price != 4 {
-		t.Fatal("incorrect insertion")
-	}
-
-	bids := []orderbook.Item{
-		{
-			Price: 7,
-		},
-		{
-			Price: 6,
-		},
-		{
-			Price: 5,
-		},
-		{
-			Price: 3,
-		},
-		{
-			Price: 2,
-		},
-		{
-			Price: 1,
-		},
-	}
-
-	insertUpdatesBid(update, &bids)
-	if asks[3].Price != 4 {
-		t.Fatal("incorrect insertion")
-	}
-}
-
-func deploySliceOrdered(size int) []orderbook.Item {
+func deploySliceOrdered(size int) orderbook.Items {
 	rand.Seed(time.Now().UnixNano())
 	var items []orderbook.Item
 	for i := 0; i < size; i++ {
@@ -857,14 +786,16 @@ func TestUpdateByIDAndAction(t *testing.T) {

 	asks := deploySliceOrdered(100)
 	bids := append(asks[:0:0], asks...)
-	orderbook.Reverse(bids)
+	bids.Reverse()

-	book := &orderbook.Base{
-		Bids: append(bids[:0:0], bids...),
-		Asks: append(asks[:0:0], asks...),
+	book, err := orderbook.DeployDepth("test", cp, asset.Spot)
+	if err != nil {
+		t.Fatal(err)
 	}

-	err := book.Verify()
+	book.LoadSnapshot(append(bids[:0:0], bids...), append(asks[:0:0], asks...))
+
+	err = book.Retrieve().Verify()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -894,14 +825,16 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		Action: UpdateInsert,
 		Bids: []orderbook.Item{
 			{
-				Price: 0,
-				ID:    1337,
+				Price:  0,
+				ID:     1337,
+				Amount: 1,
 			},
 		},
 		Asks: []orderbook.Item{
 			{
-				Price: 100,
-				ID:    1337,
+				Price:  100,
+				ID:     1337,
+				Amount: 1,
 			},
 		},
 	})
@@ -909,10 +842,12 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		t.Fatal(err)
 	}

-	if book.Bids[len(book.Bids)-1].Price != 0 {
+	cpy := book.Retrieve()
+
+	if cpy.Bids[len(cpy.Bids)-1].Price != 0 {
 		t.Fatal("did not append bid item")
 	}
-	if book.Asks[len(book.Asks)-1].Price != 100 {
+	if cpy.Asks[len(cpy.Asks)-1].Price != 100 {
 		t.Fatal("did not append ask item")
 	}

@@ -938,11 +873,13 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		t.Fatal(err)
 	}

-	if book.Bids[len(book.Bids)-1].Amount != 100 {
-		t.Fatal("did not update bid amount")
+	cpy = book.Retrieve()
+
+	if cpy.Bids[len(cpy.Bids)-1].Amount != 100 {
+		t.Fatal("did not update bid amount", cpy.Bids[len(cpy.Bids)-1].Amount)
 	}

-	if book.Asks[len(book.Asks)-1].Amount != 100 {
+	if cpy.Asks[len(cpy.Asks)-1].Amount != 100 {
 		t.Fatal("did not update ask amount")
 	}

@@ -968,16 +905,17 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		t.Fatal(err)
 	}

-	if book.Bids[0].Amount != 99 && book.Bids[0].Price != 100 {
+	cpy = book.Retrieve()
+
+	if cpy.Bids[0].Amount != 99 && cpy.Bids[0].Price != 100 {
 		t.Fatal("did not adjust bid item placement and details")
 	}

-	if book.Asks[0].Amount != 99 && book.Asks[0].Amount != 0 {
+	if cpy.Asks[0].Amount != 99 && cpy.Asks[0].Amount != 0 {
 		t.Fatal("did not adjust ask item placement and details")
 	}

-	book.Bids = append(bids[:0:0], bids...) // nolint:gocritic
-	book.Asks = append(asks[:0:0], asks...) // nolint:gocritic
+	book.LoadSnapshot(append(bids[:0:0], bids...), append(bids[:0:0], bids...)) // nolint:gocritic

 	// Delete - not found
 	err = holder.updateByIDAndAction(&Update{
@@ -1018,7 +956,7 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		t.Fatal(err)
 	}

-	if len(book.Asks) != 99 {
+	if book.GetAskLength() != 99 {
 		t.Fatal("element not deleted")
 	}

@@ -1033,7 +971,7 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		t.Fatal("error cannot be nil")
 	}

-	update := book.Asks[0]
+	update := book.Retrieve().Asks[0]
 	update.Amount = 1337

 	err = holder.updateByIDAndAction(&Update{
@@ -1046,20 +984,20 @@ func TestUpdateByIDAndAction(t *testing.T) {
 		t.Fatal(err)
 	}

-	if book.Asks[0].Amount != 1337 {
+	if book.Retrieve().Asks[0].Amount != 1337 {
 		t.Fatal("element not updated")
 	}
 }

 func TestFlushOrderbook(t *testing.T) {
 	w := &Orderbook{}
-	err := w.Setup(5, false, false, false, false, "test", make(chan interface{}, 2))
+	err := w.Setup(5, false, false, false, false, false, "test", make(chan interface{}, 2))
 	if err != nil {
 		t.Fatal(err)
 	}

 	var snapShot1 orderbook.Base
-	snapShot1.ExchangeName = "Snapshooooot"
+	snapShot1.Exchange = "Snapshooooot"
 	asks := []orderbook.Item{
 		{Price: 4000, Amount: 1, ID: 8},
 	}
@@ -1068,7 +1006,7 @@ func TestFlushOrderbook(t *testing.T) {
 	}
 	snapShot1.Asks = asks
 	snapShot1.Bids = bids
-	snapShot1.AssetType = asset.Spot
+	snapShot1.Asset = asset.Spot
 	snapShot1.Pair = cp

 	err = w.FlushOrderbook(cp, asset.Spot)
@@ -1076,14 +1014,9 @@ func TestFlushOrderbook(t *testing.T) {
 		t.Fatal("book not loaded error cannot be nil")
 	}

-	o := w.GetOrderbook(cp, asset.Spot)
-	if o != nil {
-		t.Fatal("book not loaded, this should not happen")
-	}
-
-	err = w.LoadSnapshot(&snapShot1)
-	if err != nil {
-		t.Fatal(err)
+	_, err = w.GetOrderbook(cp, asset.Spot)
+	if !errors.Is(err, errDepthNotFound) {
+		t.Fatalf("expected: %v but received: %v", errDepthNotFound, err)
 	}

 	err = w.LoadSnapshot(&snapShot1)
@@ -1096,12 +1029,12 @@ func TestFlushOrderbook(t *testing.T) {
 		t.Fatal(err)
 	}

-	o = w.GetOrderbook(cp, asset.Spot)
-	if o == nil {
-		t.Fatal("cannot get book")
+	o, err := w.GetOrderbook(cp, asset.Spot)
+	if err != nil {
+		t.Fatal(err)
 	}

-	if o.Bids != nil && o.Asks != nil {
+	if len(o.Bids) != 0 || len(o.Asks) != 0 {
 		t.Fatal("orderbook items not flushed")
 	}
 }