swap, uint256: unify variable types, pt. 1

swap/api.go

@@ -3,6 +3,7 @@ package swap
 import (
 	"encoding/json"
 	"fmt"
+	"math/big"
 
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/rpc"
@@ -23,7 +24,7 @@ func (s *Swap) APIs() []rpc.API {
 }
 
 type swapAPI interface {
-	AvailableBalance() (uint64, error)
+	AvailableBalance() (*Uint256, error)
 	PeerBalance(peer enode.ID) (int64, error)
 	Balances() (map[enode.ID]int64, error)
 	PeerCheques(peer enode.ID) (PeerCheques, error)
@@ -52,22 +53,22 @@ func NewAPI(s *Swap) *API {
 }
 
 // AvailableBalance returns the total balance of the chequebook against which new cheques can be written
-func (s *Swap) AvailableBalance() (uint64, error) {
+func (s *Swap) AvailableBalance() (*Uint256, error) {
 	// get the LiquidBalance of the chequebook
-	liquidBalance, err := s.contract.LiquidBalance(nil)
+	contractLiquidBalance, err := s.contract.LiquidBalance(nil)
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 
 	// get all cheques
 	cheques, err := s.Cheques()
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 
 	// Compute the total worth of cheques sent and how much of of this is cashed
-	var sentChequesWorth uint64
-	var cashedChequesWorth uint64
+	sentChequesWorth := new(big.Int)
+	cashedChequesWorth := new(big.Int)
 	for _, peerCheques := range cheques {
 		var sentCheque *Cheque
 		if peerCheques.PendingCheque != nil {
@@ -77,14 +78,19 @@ func (s *Swap) AvailableBalance() (uint64, error) {
 		} else {
 			continue
 		}
-		sentChequesWorth += sentCheque.ChequeParams.CumulativePayout
+		cumulativePayout := sentCheque.ChequeParams.CumulativePayout.Value()
+		sentChequesWorth.Add(sentChequesWorth, &cumulativePayout)
 		paidOut, err := s.contract.PaidOut(nil, sentCheque.ChequeParams.Beneficiary)
 		if err != nil {
-			return 0, err
+			return nil, err
 		}
-		cashedChequesWorth += paidOut.Uint64()
+		cashedChequesWorth.Add(cashedChequesWorth, paidOut)
 	}
-	return liquidBalance.Uint64() + cashedChequesWorth - sentChequesWorth, nil
+
+	totalChequesWorth := new(big.Int).Sub(cashedChequesWorth, sentChequesWorth)
+	tentativeLiquidBalance := new(big.Int).Add(contractLiquidBalance, totalChequesWorth)
+
+	return NewUint256().Set(*tentativeLiquidBalance)
 }
 
 // PeerBalance returns the balance for a given peer

swap/cheque.go

@@ -19,7 +19,6 @@ package swap
 import (
 	"bytes"
 	"crypto/ecdsa"
-	"encoding/binary"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -31,7 +30,10 @@ func (cheque *ChequeParams) encodeForSignature() []byte {
 	cumulativePayoutBytes := make([]byte, 32)
 	// we need to write the last 8 bytes as we write a uint64 into a 32-byte array
 	// encoded in BigEndian because EVM uses BigEndian encoding
-	binary.BigEndian.PutUint64(cumulativePayoutBytes[24:], cheque.CumulativePayout)
+	cumulativePayout := cheque.CumulativePayout.Value()
+	chequePayoutBytes := (&cumulativePayout).Bytes()
+	copy(cumulativePayoutBytes[32-len(chequePayoutBytes):], chequePayoutBytes)
+
 	// construct the actual cheque
 	input := cheque.Contract.Bytes()
 	input = append(input, cheque.Beneficiary.Bytes()...)
@@ -94,7 +96,7 @@ func (cheque *Cheque) Equal(other *Cheque) bool {
 		return false
 	}
 
-	if cheque.CumulativePayout != other.CumulativePayout {
+	if !cheque.CumulativePayout.Equals(other.CumulativePayout) {
 		return false
 	}
 
@@ -130,24 +132,24 @@ func (cheque *Cheque) verifyChequeProperties(p *Peer, expectedBeneficiary common
 
 // verifyChequeAgainstLast verifies that the amount is higher than in the previous cheque and the increase is as expected
 // returns the actual amount received in this cheque
-func (cheque *Cheque) verifyChequeAgainstLast(lastCheque *Cheque, expectedAmount uint64) (uint64, error) {
-	actualAmount := cheque.CumulativePayout
+func (cheque *Cheque) verifyChequeAgainstLast(lastCheque *Cheque, expectedAmount *Uint256) (*Uint256, error) {
+	actualAmount := NewUint256().Copy(cheque.CumulativePayout)
 
 	if lastCheque != nil {
-		if cheque.CumulativePayout <= lastCheque.CumulativePayout {
-			return 0, fmt.Errorf("wrong cheque parameters: expected cumulative payout larger than %d, was: %d", lastCheque.CumulativePayout, cheque.CumulativePayout)
+		if cheque.CumulativePayout.Cmp(lastCheque.CumulativePayout) < 1 {
+			return nil, fmt.Errorf("wrong cheque parameters: expected cumulative payout larger than %v, was: %v", lastCheque.CumulativePayout, cheque.CumulativePayout)
 		}
 
-		actualAmount -= lastCheque.CumulativePayout
+		actualAmount.Sub(actualAmount, lastCheque.CumulativePayout)
 	}
 
-	if expectedAmount != actualAmount {
-		return 0, fmt.Errorf("unexpected amount for honey, expected %d was %d", expectedAmount, actualAmount)
+	if !expectedAmount.Equals(actualAmount) {
+		return nil, fmt.Errorf("unexpected amount for honey, expected %v was %v", expectedAmount, actualAmount)
 	}
 
 	return actualAmount, nil
 }
 
 func (cheque *Cheque) String() string {
-	return fmt.Sprintf("Contract: %x Beneficiary: %x CumulativePayout: %d Honey: %d", cheque.Contract, cheque.Beneficiary, cheque.CumulativePayout, cheque.Honey)
+	return fmt.Sprintf("Contract: %x Beneficiary: %x CumulativePayout: %v Honey: %d", cheque.Contract, cheque.Beneficiary, cheque.CumulativePayout, cheque.Honey)
 }

swap/peer.go

@@ -116,12 +116,12 @@ func (p *Peer) setPendingCheque(cheque *Cheque) error {
 
 // getLastSentCumulativePayout returns the cumulative payout of the last sent cheque or 0 if there is none
 // the caller is expected to hold p.lock
-func (p *Peer) getLastSentCumulativePayout() uint64 {
+func (p *Peer) getLastSentCumulativePayout() *Uint256 {
 	lastCheque := p.getLastSentCheque()
 	if lastCheque != nil {
 		return lastCheque.CumulativePayout
 	}
-	return 0
+	return NewUint256()
 }
 
 // the caller is expected to hold p.lock
@@ -162,16 +162,21 @@ func (p *Peer) createCheque() (*Cheque, error) {
 	// the balance should be negative here, we take the absolute value:
 	honey := uint64(-p.getBalance())
 
-	amount, err := p.swap.honeyPriceOracle.GetPrice(honey)
+	price, err := p.swap.honeyPriceOracle.GetPrice(honey)
 	if err != nil {
 		return nil, fmt.Errorf("error getting price from oracle: %v", err)
 	}
+	castedPrice := Uint64ToUint256(price)
 
-	total := p.getLastSentCumulativePayout()
+	cumulativePayout := p.getLastSentCumulativePayout()
+	newCumulativePayout, err := NewUint256().Add(cumulativePayout, castedPrice)
+	if err != nil {
+		return nil, err
+	}
 
 	cheque = &Cheque{
 		ChequeParams: ChequeParams{
-			CumulativePayout: total + amount,
+			CumulativePayout: newCumulativePayout,
 			Contract:         p.swap.GetParams().ContractAddress,
 			Beneficiary:      p.beneficiary,
 		},

swap/protocol_test.go

@@ -245,9 +245,10 @@ func TestEmitCheque(t *testing.T) {
 	// gasPrice on testBackend == 1
 	// estimated gas costs == 50000
 	// cheque should be sent if the accumulated amount of uncashed cheques is worth more than 100000
-	balance := uint64(100001)
+	balance := Uint64ToUint256(100001)
+	balanceValue := balance.Value()
 
-	if err := testDeploy(context.Background(), debitorSwap, big.NewInt(int64(balance))); err != nil {
+	if err := testDeploy(context.Background(), debitorSwap, &balanceValue); err != nil {
 		t.Fatal(err)
 	}
 
@@ -260,7 +261,7 @@ func TestEmitCheque(t *testing.T) {
 
 	debitor := creditorSwap.getPeer(protocolTester.Nodes[0].ID())
 	// set balance artificially
-	if err = debitor.setBalance(int64(balance)); err != nil {
+	if err = debitor.setBalance(balanceValue.Int64()); err != nil {
 		t.Fatal(err)
 	}
 
@@ -275,7 +276,7 @@ func TestEmitCheque(t *testing.T) {
 			Beneficiary:      creditorSwap.owner.address,
 			CumulativePayout: balance,
 		},
-		Honey: balance,
+		Honey: balanceValue.Uint64(),
 	}
 	cheque.Signature, err = cheque.Sign(debitorSwap.owner.privateKey)
 	if err != nil {
@@ -380,8 +381,8 @@ func TestTriggerPaymentThreshold(t *testing.T) {
 		t.Fatal("Expected pending cheque")
 	}
 
-	if pending.CumulativePayout != expectedAmount {
-		t.Fatalf("Expected cheque cumulative payout to be %d, but is %d", expectedAmount, pending.CumulativePayout)
+	if !pending.CumulativePayout.Equals(Uint64ToUint256(expectedAmount)) {
+		t.Fatalf("Expected cheque cumulative payout to be %d, but is %v", expectedAmount, pending.CumulativePayout)
 	}
 
 	if pending.Honey != expectedAmount {

swap/simulations_test.go

@@ -368,11 +368,11 @@ func TestPingPongChequeSimulation(t *testing.T) {
 	}
 
 	expected := uint64(maxCheques) / 2 * (DefaultPaymentThreshold + 1)
-	if ch1.CumulativePayout != expected {
-		t.Fatalf("expected cumulative payout to be %d, but is %d", expected, ch1.CumulativePayout)
+	if !ch1.CumulativePayout.Equals(Uint64ToUint256(expected)) {
+		t.Fatalf("expected cumulative payout to be %d, but is %v", expected, ch1.CumulativePayout)
 	}
-	if ch2.CumulativePayout != expected {
-		t.Fatalf("expected cumulative payout to be %d, but is %d", expected, ch2.CumulativePayout)
+	if !ch2.CumulativePayout.Equals(Uint64ToUint256(expected)) {
+		t.Fatalf("expected cumulative payout to be %d, but is %v", expected, ch2.CumulativePayout)
 	}
 
 	log.Info("Simulation ended")
@@ -502,15 +502,15 @@ func TestMultiChequeSimulation(t *testing.T) {
 	}
 
 	// both cheques (at issuer and beneficiary) should have same cumulative value
-	if cheque1.CumulativePayout != cheque2.CumulativePayout {
-		t.Fatalf("Expected symmetric cheques payout, but they are not: %d vs %d", cheque1.CumulativePayout, cheque2.CumulativePayout)
+	if !cheque1.CumulativePayout.Equals(cheque2.CumulativePayout) {
+		t.Fatalf("Expected symmetric cheques payout, but they are not: %v vs %v", cheque1.CumulativePayout, cheque2.CumulativePayout)
 	}
 
 	// check also the actual expected amount
 	expectedPayout = uint64(maxCheques) * (DefaultPaymentThreshold + 1)
 
-	if cheque2.CumulativePayout != expectedPayout {
-		t.Fatalf("Expected %d in cumulative payout, got %d", expectedPayout, cheque1.CumulativePayout)
+	if !cheque2.CumulativePayout.Equals(Uint64ToUint256(expectedPayout)) {
+		t.Fatalf("Expected %d in cumulative payout, got %v", expectedPayout, cheque1.CumulativePayout)
 	}
 
 	log.Info("Simulation ended")
@@ -745,7 +745,7 @@ func waitForChequeProcessed(t *testing.T, backend *swapTestBackend, counter metr
 				p.lock.Lock()
 				lastPayout := p.getLastSentCumulativePayout()
 				p.lock.Unlock()
-				if lastPayout != expectedLastPayout {
+				if !lastPayout.Equals(Uint64ToUint256(expectedLastPayout)) {
 					time.Sleep(5 * time.Millisecond)
 					continue
 				} else {

swap/swap.go

@@ -444,12 +444,31 @@ func (s *Swap) handleEmitChequeMsg(ctx context.Context, p *Peer, msg *EmitCheque
 		return err
 	}
 	transactionCosts := gasPrice.Uint64() * 50000 // cashing a cheque is approximately 50000 gas
+	castedTransactionCosts := Uint64ToUint256(transactionCosts)
+	costsMultiplier := Uint64ToUint256(2)
+
+	costThreshold, err := NewUint256().Mul(castedTransactionCosts, costsMultiplier)
+	if err != nil {
+		return err
+	}
+
 	paidOut, err := otherSwap.PaidOut(nil, cheque.Beneficiary)
 	if err != nil {
 		return err
 	}
+
+	castedPaidOut, err := NewUint256().Set(*paidOut)
+	if err != nil {
+		return err
+	}
+
+	transactionProfit, err := NewUint256().Sub(cheque.CumulativePayout, castedPaidOut)
+	if err != nil {
+		return err
+	}
+
 	// do a payout transaction if we get 2 times the gas costs
-	if (cheque.CumulativePayout - paidOut.Uint64()) > 2*transactionCosts {
+	if transactionProfit.Cmp(costThreshold) == 1 {
 		opts := bind.NewKeyedTransactor(s.owner.privateKey)
 		opts.Context = ctx
 		// cash cheque in async, otherwise this blocks here until the TX is mined
@@ -491,7 +510,8 @@ func (s *Swap) handleConfirmChequeMsg(ctx context.Context, p *Peer, msg *Confirm
 // The function cashes the cheque by sending it to the blockchain
 func cashCheque(s *Swap, otherSwap contract.Contract, opts *bind.TransactOpts, cheque *Cheque) {
 	// blocks here, as we are waiting for the transaction to be mined
-	result, receipt, err := otherSwap.CashChequeBeneficiary(opts, s.GetParams().ContractAddress, big.NewInt(int64(cheque.CumulativePayout)), cheque.Signature)
+	cumulativePayout := cheque.CumulativePayout.Value()
+	result, receipt, err := otherSwap.CashChequeBeneficiary(opts, s.GetParams().ContractAddress, &cumulativePayout, cheque.Signature)
 	if err != nil {
 		// TODO: do something with the error
 		// and we actually need to log this error as we are in an async routine; nobody is handling this error for now
@@ -513,22 +533,22 @@ func cashCheque(s *Swap, otherSwap contract.Contract, opts *bind.TransactOpts, c
 
 // processAndVerifyCheque verifies the cheque and compares it with the last received cheque
 // if the cheque is valid it will also be saved as the new last cheque
-func (s *Swap) processAndVerifyCheque(cheque *Cheque, p *Peer) (uint64, error) {
+func (s *Swap) processAndVerifyCheque(cheque *Cheque, p *Peer) (*Uint256, error) {
 	if err := cheque.verifyChequeProperties(p, s.owner.address); err != nil {
-		return 0, err
+		return nil, err
 	}
 
 	lastCheque := p.getLastReceivedCheque()
 
 	// TODO: there should probably be a lock here?
 	expectedAmount, err := s.honeyPriceOracle.GetPrice(cheque.Honey)
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 
-	actualAmount, err := cheque.verifyChequeAgainstLast(lastCheque, expectedAmount)
+	actualAmount, err := cheque.verifyChequeAgainstLast(lastCheque, Uint64ToUint256(expectedAmount))
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 
 	if err := p.setLastReceivedCheque(cheque); err != nil {