OME Tests

cmd/darknode/darknode.go

@@ -221,7 +221,7 @@ func main() {
 		gen := ome.NewComputationGenerator(config.Address, store.SomerOrderFragmentStore())
 		matcher := ome.NewMatcher(store.SomerComputationStore(), smpcer)
 		confirmer := ome.NewConfirmer(store.SomerComputationStore(), &contractBinder, 5*time.Second, 2)
-		settler := ome.NewSettler(store.SomerComputationStore(), smpcer, &contractBinder)
+		settler := ome.NewSettler(store.SomerComputationStore(), smpcer, &contractBinder, 1)
 		ome := ome.NewOme(config.Address, gen, matcher, confirmer, settler, store.SomerComputationStore(), orderbook, smpcer, epoch)
 
 		dispatch.CoBegin(func() {

ome/ome_test.go

@@ -64,7 +64,7 @@ var _ = Describe("Ome", func() {
 			Expect(err).ShouldNot(HaveOccurred())
 			matcher = NewMatcher(storer, smpcer)
 			confirmer = NewConfirmer(storer, contract, PollInterval, Depth)
-			settler = NewSettler(storer, smpcer, contract)
+			settler = NewSettler(storer, smpcer, contract, 0)
 		})
 
 		AfterEach(func() {

ome/settler.go

@@ -23,19 +23,21 @@ type Settler interface {
 }
 
 type settler struct {
-	computationStore ComputationStorer
-	smpcer           smpc.Smpcer
-	contract         ContractBinder
+	computationStore    ComputationStorer
+	smpcer              smpc.Smpcer
+	contract            ContractBinder
+	minimumSettleVolume float64
 }
 
 // NewSettler returns a Settler that settles orders by first using an
 // smpc.Smpcer to join all of the composing order.Fragments, and then submits
 // them to an Ethereum contract.
-func NewSettler(computationStore ComputationStorer, smpcer smpc.Smpcer, contract ContractBinder) Settler {
+func NewSettler(computationStore ComputationStorer, smpcer smpc.Smpcer, contract ContractBinder, minimumSettleVolume float64) Settler {
 	return &settler{
-		computationStore: computationStore,
-		smpcer:           smpcer,
-		contract:         contract,
+		computationStore:    computationStore,
+		smpcer:              smpcer,
+		contract:            contract,
+		minimumSettleVolume: minimumSettleVolume,
 	}
 }
 
@@ -125,7 +127,7 @@ func (settler *settler) settleOrderMatch(com Computation, buy, sell order.Order)
 	// Leave the orders if volume is too low and there is no profit for
 	// submitting such orders. Note: minimum volume is set to 1 ETH.
 	settleVolume := volumeInEth(buy, sell)
-	if settleVolume < 1 {
+	if settleVolume < settler.minimumSettleVolume {
 		log.Printf("[info] (settle) cannot execute settlement buy = %v, sell = %v: volume = %f ETH too low", buy.ID, sell.ID, settleVolume)
 		return
 	}

ome/settler_test.go

@@ -30,7 +30,7 @@ var _ = Describe("Settler", func() {
 			storers[i] = storer.SomerComputationStore()
 			smpcers[i] = testutils.NewAlwaysMatchSmpc()
 			contracts[i] = newOmeBinder()
-			settles[i] = NewSettler(storers[i], smpcers[i], contracts[i])
+			settles[i] = NewSettler(storers[i], smpcers[i], contracts[i], 0)
 		}
 	})
 
@@ -40,7 +40,7 @@ var _ = Describe("Settler", func() {
 		}
 	})
 
-	/* Context("when a computation has been resolved to a match and been confirmed ", func() {
+	Context("when a computation has been resolved to a match and been confirmed ", func() {
 		It("should be able to reconstruct the order and settle it.", func() {
 			buyFragments, err := testutils.RandomBuyOrderFragments(int64(NumberOfNodes), int64(2*(NumberOfNodes+1)/3))
 			Expect(err).ShouldNot(HaveOccurred())
@@ -59,5 +59,5 @@ var _ = Describe("Settler", func() {
 				Expect(contracts[i].SettleCounts()).Should(Equal(1))
 			}
 		})
-	}) */
+	})
 })

smpc/joiner_test.go

@@ -91,7 +91,7 @@ var _ = Describe("Joiner", func() {
 			})
 		})
 
-		/* Context("when inserting computed joins", func() {
+		Context("when inserting computed joins", func() {
 			It("should pass the computed values to the callback", func() {
 				joins := generateMatchedJoins(n, k)
 				called := int64(0)
@@ -117,7 +117,7 @@ var _ = Describe("Joiner", func() {
 					}
 				}
 			})
-		}) */
+		})
 	})
 
 	Context("when marshaling and unmarshaling joins", func() {

testutils/rand_order.go

@@ -68,8 +68,10 @@ func RandomOrderMatch() (order.Order, order.Order) {
 		order.TokensDGXREN,
 	}[rand.Intn(4)]
 
-	buy := order.NewOrder(order.ParityBuy, order.TypeLimit, time.Now().Add(1*time.Hour), order.SettlementRenEx, tokens, rand.Uint64(), rand.Uint64(), 0, uint64(rand.Int63()))
-	sell := order.NewOrder(order.ParitySell, order.TypeLimit, time.Now().Add(1*time.Hour), order.SettlementRenEx, tokens, rand.Uint64(), rand.Uint64(), 0, uint64(rand.Int63()))
+	price := rand.Uint64()
+	volume := rand.Uint64()
+	buy := order.NewOrder(order.ParityBuy, order.TypeLimit, time.Now().Add(1*time.Hour), order.SettlementRenEx, tokens, price, volume, 0, uint64(rand.Int63()))
+	sell := order.NewOrder(order.ParitySell, order.TypeLimit, time.Now().Add(1*time.Hour), order.SettlementRenEx, tokens, price, volume, 0, uint64(rand.Int63()))
 	return buy, sell
 }