swap: unify variable types, pt. 4

api/config.go

@@ -32,6 +32,7 @@ import (
 	"github.com/ethersphere/swarm/pss"
 	"github.com/ethersphere/swarm/storage"
 	"github.com/ethersphere/swarm/swap"
+	"github.com/ethersphere/swarm/swap/int256"
 )
 
 const (
@@ -52,16 +53,16 @@ type Config struct {
 	BaseKey       []byte
 
 	// Swap configs
-	SwapBackendURL          string         // Ethereum API endpoint
-	SwapEnabled             bool           // whether SWAP incentives are enabled
-	SwapPaymentThreshold    uint64         // honey amount at which a payment is triggered
-	SwapDisconnectThreshold uint64         // honey amount at which a peer disconnects
-	SwapSkipDeposit         bool           // do not ask the user to deposit during boot sequence
-	SwapDepositAmount       uint64         // deposit amount to the chequebook
-	SwapLogPath             string         // dir to swap related audit logs
-	SwapLogLevel            int            // log level of swap related audit logs
-	Contract                common.Address // address of the chequebook contract
-	SwapChequebookFactory   common.Address // address of the chequebook factory contract
+	SwapBackendURL          string          // Ethereum API endpoint
+	SwapEnabled             bool            // whether SWAP incentives are enabled
+	SwapPaymentThreshold    *int256.Uint256 // honey amount at which a payment is triggered
+	SwapDisconnectThreshold *int256.Uint256 // honey amount at which a peer disconnects
+	SwapSkipDeposit         bool            // do not ask the user to deposit during boot sequence
+	SwapDepositAmount       uint64          // deposit amount to the chequebook
+	SwapLogPath             string          // dir to swap related audit logs
+	SwapLogLevel            int             // log level of swap related audit logs
+	Contract                common.Address  // address of the chequebook contract
+	SwapChequebookFactory   common.Address  // address of the chequebook factory contract
 	// end of Swap configs
 
 	*network.HiveParams

cmd/swarm/config.go

@@ -36,6 +36,7 @@ import (
 
 	bzzapi "github.com/ethersphere/swarm/api"
 	"github.com/ethersphere/swarm/network"
+	"github.com/ethersphere/swarm/swap/int256"
 )
 
 var (
@@ -223,10 +224,10 @@ func flagsOverride(currentConfig *bzzapi.Config, ctx *cli.Context) *bzzapi.Confi
 		currentConfig.SwapDepositAmount = deposit
 	}
 	if paymentThreshold := ctx.GlobalUint64(SwarmSwapPaymentThresholdFlag.Name); paymentThreshold != 0 {
-		currentConfig.SwapPaymentThreshold = paymentThreshold
+		currentConfig.SwapPaymentThreshold = int256.Uint256From(paymentThreshold)
 	}
 	if disconnectThreshold := ctx.GlobalUint64(SwarmSwapDisconnectThresholdFlag.Name); disconnectThreshold != 0 {
-		currentConfig.SwapDisconnectThreshold = disconnectThreshold
+		currentConfig.SwapDisconnectThreshold = int256.Uint256From(disconnectThreshold)
 	}
 	if ctx.GlobalIsSet(SwarmNoSyncFlag.Name) {
 		val := !ctx.GlobalBool(SwarmNoSyncFlag.Name)

cmd/swarm/config_test.go

@@ -24,7 +24,6 @@ import (
 	"net"
 	"os"
 	"os/exec"
-	"strconv"
 	"testing"
 	"time"
 
@@ -36,6 +35,7 @@ import (
 	"github.com/ethersphere/swarm"
 	"github.com/ethersphere/swarm/api"
 	"github.com/ethersphere/swarm/swap"
+	"github.com/ethersphere/swarm/swap/int256"
 	"github.com/ethersphere/swarm/testutil"
 )
 
@@ -227,6 +227,20 @@ func TestConfigCmdLineOverrides(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	// add 1 to payment threshold
+	paymentThresholdOverride, err := new(int256.Uint256).Add(swap.DefaultPaymentThreshold, int256.Uint256From(1))
+	if err != nil {
+		t.Fatal(err)
+	}
+	paymentThreshold := paymentThresholdOverride.Value()
+
+	// add 1 to disconnect threshold
+	disconnectThresholdOverride, err := new(int256.Uint256).Add(swap.DefaultDisconnectThreshold, int256.Uint256From(1))
+	if err != nil {
+		t.Fatal(err)
+	}
+	disconnectThreshold := disconnectThresholdOverride.Value()
+
 	flags := []string{
 		fmt.Sprintf("--%s", SwarmNetworkIdFlag.Name), "42",
 		fmt.Sprintf("--%s", SwarmPortFlag.Name), httpPort,
@@ -238,8 +252,8 @@ func TestConfigCmdLineOverrides(t *testing.T) {
 		fmt.Sprintf("--%s", utils.DataDirFlag.Name), dir,
 		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), conf.IPCPath,
 		"--verbosity", fmt.Sprintf("%d", *testutil.Loglevel),
-		fmt.Sprintf("--%s", SwarmSwapPaymentThresholdFlag.Name), strconv.FormatUint(swap.DefaultPaymentThreshold+1, 10),
-		fmt.Sprintf("--%s", SwarmSwapDisconnectThresholdFlag.Name), strconv.FormatUint(swap.DefaultDisconnectThreshold+1, 10),
+		fmt.Sprintf("--%s", SwarmSwapPaymentThresholdFlag.Name), paymentThreshold.String(),
+		fmt.Sprintf("--%s", SwarmSwapDisconnectThresholdFlag.Name), disconnectThreshold.String(),
 		fmt.Sprintf("--%s", SwarmEnablePinningFlag.Name),
 	}
 
@@ -287,12 +301,12 @@ func TestConfigCmdLineOverrides(t *testing.T) {
 		t.Fatalf("Expected Cors flag to be set to %s, got %s", "*", info.Cors)
 	}
 
-	if info.SwapPaymentThreshold != (swap.DefaultPaymentThreshold + 1) {
-		t.Fatalf("Expected SwapPaymentThreshold to be %d, but got %d", swap.DefaultPaymentThreshold+1, info.SwapPaymentThreshold)
+	if !info.SwapPaymentThreshold.Equals(paymentThresholdOverride) {
+		t.Fatalf("Expected SwapPaymentThreshold to be %v, but got %v", paymentThresholdOverride, info.SwapPaymentThreshold)
 	}
 
-	if info.SwapDisconnectThreshold != (swap.DefaultDisconnectThreshold + 1) {
-		t.Fatalf("Expected SwapDisconnectThreshold to be %d, but got %d", swap.DefaultDisconnectThreshold+1, info.SwapDisconnectThreshold)
+	if !info.SwapDisconnectThreshold.Equals(disconnectThresholdOverride) {
+		t.Fatalf("Expected SwapDisconnectThreshold to be %v, but got %v", disconnectThresholdOverride, info.SwapDisconnectThreshold)
 	}
 
 	if info.EnablePinning != true {

swap/api.go

@@ -26,8 +26,8 @@ func (s *Swap) APIs() []rpc.API {
 
 type swapAPI interface {
 	AvailableBalance() (*int256.Uint256, error)
-	PeerBalance(peer enode.ID) (int64, error)
-	Balances() (map[enode.ID]int64, error)
+	PeerBalance(peer enode.ID) (*int256.Int256, error)
+	Balances() (map[enode.ID]*int256.Int256, error)
 	PeerCheques(peer enode.ID) (PeerCheques, error)
 	Cheques() (map[enode.ID]*PeerCheques, error)
 }
@@ -95,7 +95,7 @@ func (s *Swap) AvailableBalance() (*int256.Uint256, error) {
 }
 
 // PeerBalance returns the balance for a given peer
-func (s *Swap) PeerBalance(peer enode.ID) (balance int64, err error) {
+func (s *Swap) PeerBalance(peer enode.ID) (balance *int256.Int256, err error) {
 	if swapPeer := s.getPeer(peer); swapPeer != nil {
 		swapPeer.lock.Lock()
 		defer swapPeer.lock.Unlock()
@@ -106,8 +106,8 @@ func (s *Swap) PeerBalance(peer enode.ID) (balance int64, err error) {
 }
 
 // Balances returns the balances for all known SWAP peers
-func (s *Swap) Balances() (map[enode.ID]int64, error) {
-	balances := make(map[enode.ID]int64)
+func (s *Swap) Balances() (map[enode.ID]*int256.Int256, error) {
+	balances := make(map[enode.ID]*int256.Int256)
 
 	s.peersLock.Lock()
 	for peer, swapPeer := range s.peers {
@@ -121,7 +121,7 @@ func (s *Swap) Balances() (map[enode.ID]int64, error) {
 	balanceIterFunction := func(key []byte, value []byte) (stop bool, err error) {
 		peer := keyToID(string(key), balancePrefix)
 		if _, peerHasBalance := balances[peer]; !peerHasBalance {
-			var peerBalance int64
+			var peerBalance *int256.Int256
 			err = json.Unmarshal(value, &peerBalance)
 			if err == nil {
 				balances[peer] = peerBalance

swap/api_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
 	"github.com/ethersphere/swarm/p2p/protocols"
 	"github.com/ethersphere/swarm/state"
+	"github.com/ethersphere/swarm/swap/int256"
 )
 
 type peerChequesTestCase struct {
@@ -40,19 +41,19 @@ func TestPeerBalance(t *testing.T) {
 	defer clean()
 
 	// test balance
-	setBalance(t, testPeer, 888)
-	testPeerBalance(t, swap, testPeerID, 888)
+	setBalance(t, testPeer, int256.Int256From(888))
+	testPeerBalance(t, swap, testPeerID, int256.Int256From(888))
 
 	// test balance after change
-	setBalance(t, testPeer, 17000)
-	testPeerBalance(t, swap, testPeerID, 17000)
+	setBalance(t, testPeer, int256.Int256From(17000))
+	testPeerBalance(t, swap, testPeerID, int256.Int256From(17000))
 
 	// test balance for second peer
 	testPeer2 := addPeer(t, swap)
 	testPeer2ID := testPeer2.ID()
 
-	setBalance(t, testPeer2, 4)
-	testPeerBalance(t, swap, testPeer2ID, 4)
+	setBalance(t, testPeer2, int256.Int256From(4))
+	testPeerBalance(t, swap, testPeer2ID, int256.Int256From(4))
 
 	// test balance for inexistent node
 	invalidPeerID := adapters.RandomNodeConfig().ID
@@ -67,23 +68,23 @@ func TestPeerBalance(t *testing.T) {
 	// test balance for disconnected node
 	testPeer3 := newDummyPeer().Peer
 	testPeer3ID := testPeer3.ID()
-	err = swap.saveBalance(testPeer3ID, 777)
-	testPeerBalance(t, swap, testPeer3ID, 777)
+	err = swap.saveBalance(testPeer3ID, int256.Int256From(777))
+	testPeerBalance(t, swap, testPeer3ID, int256.Int256From(777))
 
 	// test previous results are still correct
-	testPeerBalance(t, swap, testPeerID, 17000)
-	testPeerBalance(t, swap, testPeer2ID, 4)
+	testPeerBalance(t, swap, testPeerID, int256.Int256From(17000))
+	testPeerBalance(t, swap, testPeer2ID, int256.Int256From(4))
 }
 
 // tests that expected balance for peer matches the result of the Balance function
-func testPeerBalance(t *testing.T, s *Swap, id enode.ID, expectedBalance int64) {
+func testPeerBalance(t *testing.T, s *Swap, id enode.ID, expectedBalance *int256.Int256) {
 	t.Helper()
 	b, err := s.PeerBalance(id)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if b != expectedBalance {
-		t.Fatalf("Expected peer's balance to be %d, but is %d", expectedBalance, b)
+	if !b.Equals(expectedBalance) {
+		t.Fatalf("Expected peer's balance to be %v, but is %v", expectedBalance, b)
 	}
 }
 
@@ -97,7 +98,7 @@ func addPeer(t *testing.T, s *Swap) *Peer {
 }
 
 // sets the given balance for the given peer, fails if there are errors
-func setBalance(t *testing.T, p *Peer, balance int64) {
+func setBalance(t *testing.T, p *Peer, balance *int256.Int256) {
 	t.Helper()
 	err := p.setBalance(balance)
 	if err != nil {
@@ -112,38 +113,42 @@ func TestBalances(t *testing.T) {
 	defer clean()
 
 	// test balances are empty
-	testBalances(t, swap, map[enode.ID]int64{})
+	testBalances(t, swap, map[enode.ID]*int256.Int256{})
 
 	// add peer
 	testPeer := addPeer(t, swap)
 	testPeerID := testPeer.ID()
 
 	// test balances with one peer
-	setBalance(t, testPeer, 808)
-	testBalances(t, swap, map[enode.ID]int64{testPeerID: 808})
+	balancePeer := int256.Int256From(808)
+	setBalance(t, testPeer, int256.Int256From(808))
+	testBalances(t, swap, map[enode.ID]*int256.Int256{testPeerID: balancePeer})
 
 	// add second peer
 	testPeer2 := addPeer(t, swap)
 	testPeer2ID := testPeer2.ID()
 
 	// test balances with second peer
-	setBalance(t, testPeer2, 123)
-	testBalances(t, swap, map[enode.ID]int64{testPeerID: 808, testPeer2ID: 123})
+	balancePeer2 := int256.Int256From(123)
+	setBalance(t, testPeer2, int256.Int256From(123))
+	testBalances(t, swap, map[enode.ID]*int256.Int256{testPeerID: balancePeer, testPeer2ID: balancePeer2})
 
 	// test balances after balance change for peer
-	setBalance(t, testPeer, 303)
-	testBalances(t, swap, map[enode.ID]int64{testPeerID: 303, testPeer2ID: 123})
+	balancePeer = int256.Int256From(303)
+	balancePeer2 = int256.Int256From(123)
+	setBalance(t, testPeer, int256.Int256From(303))
+	testBalances(t, swap, map[enode.ID]*int256.Int256{testPeerID: balancePeer, testPeer2ID: balancePeer2})
 }
 
 // tests that a map of peerID:balance matches the result of the Balances function
-func testBalances(t *testing.T, s *Swap, expectedBalances map[enode.ID]int64) {
+func testBalances(t *testing.T, s *Swap, expectedBalances map[enode.ID]*int256.Int256) {
 	t.Helper()
 	actualBalances, err := s.Balances()
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(actualBalances, expectedBalances) {
-		t.Fatalf("Expected node's balances to be %d, but are %d", expectedBalances, actualBalances)
+		t.Fatalf("Expected node's balances to be %v, but are %v", expectedBalances, actualBalances)
 	}
 }
 

swap/common_test.go

@@ -83,8 +83,8 @@ func newDefaultParams(t *testing.T) *Params {
 		BaseAddrs:           network.NewBzzAddr(baseKey, nil),
 		LogPath:             emptyLogPath,
 		LogLevel:            DefaultSwapLogLevel, //Info level
-		PaymentThreshold:    int64(DefaultPaymentThreshold),
-		DisconnectThreshold: int64(DefaultDisconnectThreshold),
+		PaymentThreshold:    DefaultPaymentThreshold,
+		DisconnectThreshold: DefaultDisconnectThreshold,
 	}
 }
 

swap/config.go

@@ -18,18 +18,20 @@ package swap
 
 import (
 	"time"
+
+	"github.com/ethersphere/swarm/swap/int256"
 )
 
 // These are currently arbitrary values which have not been verified nor tested
 // Need experimentation to arrive to values which make sense
 const (
 	// Thresholds which trigger payment or disconnection. The unit is in honey (internal accounting unit)
 	// DefaultPaymentThreshold is set to be equivalent to requesting and serving 10mb of data (2441 chunks (4096 bytes) = 10 mb, 10^7 bytes = 10 mb)
-	DefaultPaymentThreshold    = 2441*RetrieveRequestPrice + (10^7)*ChunkDeliveryPrice // 4096 * 2441 = 10 mb,
-	DefaultDisconnectThreshold = 20 * DefaultPaymentThreshold
+	defaultPaymentThreshold    = 2441*RetrieveRequestPrice + (10^7)*ChunkDeliveryPrice // 4096 * 2441 = 10 mb,
+	defaultDisconnectThreshold = 20 * defaultPaymentThreshold
 	// ChequeDebtTolerance is the lowest resulting balance a node is willing to accept when receiving a cheque
 	// the value is meant to be used below 0, as positive resulting balances should always be accepted when receiving cheques
-	ChequeDebtTolerance = DefaultPaymentThreshold * 20 / 100 // roughly 20% of the payment threshold
+	ChequeDebtTolerance = defaultPaymentThreshold * 20 / 100 // roughly 20% of the payment threshold
 	// DefaultDepositAmount is the default amount to send to the contract when initially deploying
 	// NOTE: deliberate value for now; needs experimentation
 	DefaultDepositAmount = 0
@@ -40,3 +42,6 @@ const (
 	AllowedNetworkID          = 5
 	DefaultTransactionTimeout = 10 * time.Minute
 )
+
+var DefaultPaymentThreshold = int256.Uint256From(defaultPaymentThreshold)
+var DefaultDisconnectThreshold = int256.Uint256From(defaultDisconnectThreshold)

swap/int256/int256.go

@@ -30,6 +30,11 @@ type Int256 struct {
 	value *big.Int
 }
 
+// BigIntWrapper represents a struct with an underlying big.Int value
+type BigIntWrapper interface {
+	Value() *big.Int
+}
+
 var minInt256 = new(big.Int).Mul(big.NewInt(-1), new(big.Int).Exp(big.NewInt(2), big.NewInt(255), nil)) // -(2^255)
 var maxInt256 = new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(255), nil), big.NewInt(1))  // 2^255 - 1
 
@@ -57,6 +62,10 @@ func (u *Int256) Copy() *Int256 {
 
 // Value returns the underlying private value for a Int256 struct
 func (u *Int256) Value() *big.Int {
+	if u.value == nil {
+		return nil
+	}
+	// clone the value to avoid external modification
 	return new(big.Int).Set(u.value)
 }
 
@@ -110,13 +119,13 @@ func (u *Int256) Mul(multiplicand, multiplier *Int256) (*Int256, error) {
 }
 
 // cmp calls the underlying Cmp method for the big.Int stored in a Int256 struct as its value field
-func (u *Int256) cmp(v *Int256) int {
-	return u.value.Cmp(v.value)
+func (u *Int256) Cmp(v BigIntWrapper) int {
+	return u.value.Cmp(v.Value())
 }
 
 // Equals returns true if the two Int256 structs have the same underlying values, false otherwise
-func (u *Int256) Equals(v *Int256) bool {
-	return u.cmp(v) == 0
+func (u *Int256) Equals(v BigIntWrapper) bool {
+	return u.Cmp(v) == 0
 }
 
 // String returns the string representation for Int256 structs

swap/int256/uint256.go

@@ -57,6 +57,10 @@ func (u *Uint256) Copy() *Uint256 {
 
 // Value returns the underlying private value for a Uint256 struct
 func (u *Uint256) Value() *big.Int {
+	if u.value == nil {
+		return nil
+	}
+	// clone the value to avoid external modification
 	return new(big.Int).Set(u.value)
 }
 
@@ -110,12 +114,12 @@ func (u *Uint256) Mul(multiplicand, multiplier *Uint256) (*Uint256, error) {
 }
 
 // Cmp calls the underlying Cmp method for the big.Int stored in a Uint256 struct as its value field
-func (u *Uint256) Cmp(v *Uint256) int {
-	return u.value.Cmp(v.value)
+func (u *Uint256) Cmp(v BigIntWrapper) int {
+	return u.value.Cmp(v.Value())
 }
 
 // Equals returns true if the two Uint256 structs have the same underlying values, false otherwise
-func (u *Uint256) Equals(v *Uint256) bool {
+func (u *Uint256) Equals(v BigIntWrapper) bool {
 	return u.Cmp(v) == 0
 }