swarm: plan bee for content storage and distribution on web3

This change imports the Swarm protocol codebase. Compared to the 'swarm'
branch, a few mostly cosmetic changes had to be made:

* The various redundant log message prefixes are gone.
* All files now have LGPLv3 license headers.
* Minor code changes were needed to please go vet and make the tests
  pass on Windows.
* Further changes were required to adapt to the go-ethereum develop
  branch and its new Go APIs.

Some code has not (yet) been brought over:

* swarm/cmd/bzzhash: will reappear as cmd/bzzhash later
* swarm/cmd/bzzup.sh: will be reimplemented in cmd/bzzup
* swarm/cmd/makegenesis: will reappear somehow
* swarm/examples/album: will move to a separate repository
* swarm/examples/filemanager: ditto
* swarm/examples/files: will not be merged
* swarm/test/*: will not be merged
* swarm/services/swear: will reappear as contracts/swear when needed

3 files changed, 731 insertions, 0 deletions

diff --git a/swarm/services/swap/swap.go b/swarm/services/swap/swap.go
new file mode 100644
index 000000000..f72036d72
--- /dev/null
+++ b/swarm/services/swap/swap.go
@@ -0,0 +1,283 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package swap
+
+import (
+	"crypto/ecdsa"
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/contracts/chequebook"
+	"github.com/ethereum/go-ethereum/contracts/chequebook/contract"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/swarm/services/swap/swap"
+	"golang.org/x/net/context"
+)
+
+// SwAP       Swarm Accounting Protocol with
+// SWAP^2     Strategies of Withholding Automatic Payments
+// SWAP^3     Accreditation: payment via credit SWAP
+// using chequebook pkg for delayed payments
+// default parameters
+
+var (
+	autoCashInterval     = 300 * time.Second           // default interval for autocash
+	autoCashThreshold    = big.NewInt(50000000000000)  // threshold that triggers autocash (wei)
+	autoDepositInterval  = 300 * time.Second           // default interval for autocash
+	autoDepositThreshold = big.NewInt(50000000000000)  // threshold that triggers autodeposit (wei)
+	autoDepositBuffer    = big.NewInt(100000000000000) // buffer that is surplus for fork protection etc (wei)
+	buyAt                = big.NewInt(20000000000)     // maximum chunk price host is willing to pay (wei)
+	sellAt               = big.NewInt(20000000000)     // minimum chunk price host requires (wei)
+	payAt                = 100                         // threshold that triggers payment {request} (units)
+	dropAt               = 10000                       // threshold that triggers disconnect (units)
+)
+
+const (
+	chequebookDeployRetries = 5
+	chequebookDeployDelay   = 1 * time.Second // delay between retries
+)
+
+type SwapParams struct {
+	*swap.Params
+	*PayProfile
+}
+
+type SwapProfile struct {
+	*swap.Profile
+	*PayProfile
+}
+
+type PayProfile struct {
+	PublicKey   string         // check against signature of promise
+	Contract    common.Address // address of chequebook contract
+	Beneficiary common.Address // recipient address for swarm sales revenue
+	privateKey  *ecdsa.PrivateKey
+	publicKey   *ecdsa.PublicKey
+	owner       common.Address
+	chbook      *chequebook.Chequebook
+	lock        sync.RWMutex
+}
+
+func DefaultSwapParams(contract common.Address, prvkey *ecdsa.PrivateKey) *SwapParams {
+	pubkey := &prvkey.PublicKey
+	return &SwapParams{
+		PayProfile: &PayProfile{
+			PublicKey:   common.ToHex(crypto.FromECDSAPub(pubkey)),
+			Contract:    contract,
+			Beneficiary: crypto.PubkeyToAddress(*pubkey),
+			privateKey:  prvkey,
+			publicKey:   pubkey,
+			owner:       crypto.PubkeyToAddress(*pubkey),
+		},
+		Params: &swap.Params{
+			Profile: &swap.Profile{
+				BuyAt:  buyAt,
+				SellAt: sellAt,
+				PayAt:  uint(payAt),
+				DropAt: uint(dropAt),
+			},
+			Strategy: &swap.Strategy{
+				AutoCashInterval:     autoCashInterval,
+				AutoCashThreshold:    autoCashThreshold,
+				AutoDepositInterval:  autoDepositInterval,
+				AutoDepositThreshold: autoDepositThreshold,
+				AutoDepositBuffer:    autoDepositBuffer,
+			},
+		},
+	}
+}
+
+// swap constructor, parameters
+// * global chequebook, assume deployed service and
+// * the balance is at buffer.
+// swap.Add(n) called in netstore
+// n > 0 called when sending chunks = receiving retrieve requests
+//                 OR sending cheques.
+// n < 0  called when receiving chunks = receiving delivery responses
+//                 OR receiving cheques.
+
+func NewSwap(local *SwapParams, remote *SwapProfile, backend chequebook.Backend, proto swap.Protocol) (self *swap.Swap, err error) {
+	var (
+		ctx = context.TODO()
+		ok  bool
+		in  *chequebook.Inbox
+		out *chequebook.Outbox
+	)
+
+	// check if remote chequebook is valid
+	// insolvent chequebooks suicide so will signal as invalid
+	// TODO: monitoring a chequebooks events
+	ok, err = chequebook.ValidateCode(ctx, backend, remote.Contract)
+	if !ok {
+		glog.V(logger.Info).Infof("invalid contract %v for peer %v: %v)", remote.Contract.Hex()[:8], proto, err)
+	} else {
+		// remote contract valid, create inbox
+		in, err = chequebook.NewInbox(local.privateKey, remote.Contract, local.Beneficiary, crypto.ToECDSAPub(common.FromHex(remote.PublicKey)), backend)
+		if err != nil {
+			glog.V(logger.Warn).Infof("unable to set up inbox for chequebook contract %v for peer %v: %v)", remote.Contract.Hex()[:8], proto, err)
+		}
+	}
+
+	// check if local chequebook contract is valid
+	ok, err = chequebook.ValidateCode(ctx, backend, local.Contract)
+	if !ok {
+		glog.V(logger.Warn).Infof("unable to set up outbox for peer %v:  chequebook contract (owner: %v): %v)", proto, local.owner.Hex(), err)
+	} else {
+		out = chequebook.NewOutbox(local.Chequebook(), remote.Beneficiary)
+	}
+
+	pm := swap.Payment{
+		In:    in,
+		Out:   out,
+		Buys:  out != nil,
+		Sells: in != nil,
+	}
+	self, err = swap.New(local.Params, pm, proto)
+	if err != nil {
+		return
+	}
+	// remote profile given (first) in handshake
+	self.SetRemote(remote.Profile)
+	var buy, sell string
+	if self.Buys {
+		buy = "purchase from peer enabled at " + remote.SellAt.String() + " wei/chunk"
+	} else {
+		buy = "purchase from peer disabled"
+	}
+	if self.Sells {
+		sell = "selling to peer enabled at " + local.SellAt.String() + " wei/chunk"
+	} else {
+		sell = "selling to peer disabled"
+	}
+	glog.V(logger.Warn).Infof("SWAP arrangement with <%v>: %v; %v)", proto, buy, sell)
+
+	return
+}
+
+func (self *SwapParams) Chequebook() *chequebook.Chequebook {
+	defer self.lock.Unlock()
+	self.lock.Lock()
+	return self.chbook
+}
+
+func (self *SwapParams) PrivateKey() *ecdsa.PrivateKey {
+	return self.privateKey
+}
+
+// func (self *SwapParams) PublicKey() *ecdsa.PublicKey {
+// 	return self.publicKey
+// }
+
+func (self *SwapParams) SetKey(prvkey *ecdsa.PrivateKey) {
+	self.privateKey = prvkey
+	self.publicKey = &prvkey.PublicKey
+}
+
+// setChequebook(path, backend) wraps the
+// chequebook initialiser and sets up autoDeposit to cover spending.
+func (self *SwapParams) SetChequebook(ctx context.Context, backend chequebook.Backend, path string) error {
+	self.lock.Lock()
+	contract := self.Contract
+	self.lock.Unlock()
+
+	valid, err := chequebook.ValidateCode(ctx, backend, contract)
+	if err != nil {
+		return err
+	} else if valid {
+		return self.newChequebookFromContract(path, backend)
+	}
+	return self.deployChequebook(ctx, backend, path)
+}
+
+func (self *SwapParams) deployChequebook(ctx context.Context, backend chequebook.Backend, path string) error {
+	opts := bind.NewKeyedTransactor(self.privateKey)
+	opts.Value = self.AutoDepositBuffer
+	opts.Context = ctx
+
+	glog.V(logger.Info).Infof("Deploying new chequebook (owner: %v)", opts.From.Hex())
+	contract, err := deployChequebookLoop(opts, backend)
+	if err != nil {
+		glog.V(logger.Error).Infof("unable to deploy new chequebook: %v", err)
+		return err
+	}
+	glog.V(logger.Info).Infof("new chequebook deployed at %v (owner: %v)", contract.Hex(), opts.From.Hex())
+
+	// need to save config at this point
+	self.lock.Lock()
+	self.Contract = contract
+	err = self.newChequebookFromContract(path, backend)
+	self.lock.Unlock()
+	if err != nil {
+		glog.V(logger.Warn).Infof("error initialising cheque book (owner: %v): %v", opts.From.Hex(), err)
+	}
+	return err
+}
+
+// repeatedly tries to deploy a chequebook.
+func deployChequebookLoop(opts *bind.TransactOpts, backend chequebook.Backend) (addr common.Address, err error) {
+	var tx *types.Transaction
+	for try := 0; try < chequebookDeployRetries; try++ {
+		if try > 0 {
+			time.Sleep(chequebookDeployDelay)
+		}
+		if _, tx, _, err = contract.DeployChequebook(opts, backend); err != nil {
+			glog.V(logger.Warn).Infof("can't send chequebook deploy tx (try %d): %v", try, err)
+			continue
+		}
+		if addr, err = bind.WaitDeployed(opts.Context, backend, tx); err != nil {
+			glog.V(logger.Warn).Infof("chequebook deploy error (try %d): %v", try, err)
+			continue
+		}
+		return addr, nil
+	}
+	return addr, err
+}
+
+// initialise the chequebook from a persisted json file or create a new one
+// caller holds the lock
+func (self *SwapParams) newChequebookFromContract(path string, backend chequebook.Backend) error {
+	hexkey := common.Bytes2Hex(self.Contract.Bytes())
+	err := os.MkdirAll(filepath.Join(path, "chequebooks"), os.ModePerm)
+	if err != nil {
+		return fmt.Errorf("unable to create directory for chequebooks: %v", err)
+	}
+
+	chbookpath := filepath.Join(path, "chequebooks", hexkey+".json")
+	self.chbook, err = chequebook.LoadChequebook(chbookpath, self.privateKey, backend, true)
+
+	if err != nil {
+		self.chbook, err = chequebook.NewChequebook(chbookpath, self.Contract, self.privateKey, backend)
+		if err != nil {
+			glog.V(logger.Warn).Infof("unable to initialise chequebook (owner: %v): %v", self.owner.Hex(), err)
+			return fmt.Errorf("unable to initialise chequebook (owner: %v): %v", self.owner.Hex(), err)
+		}
+	}
+
+	self.chbook.AutoDeposit(self.AutoDepositInterval, self.AutoDepositThreshold, self.AutoDepositBuffer)
+	glog.V(logger.Info).Infof("auto deposit ON for %v -> %v: interval = %v, threshold = %v, buffer = %v)", crypto.PubkeyToAddress(*(self.publicKey)).Hex()[:8], self.Contract.Hex()[:8], self.AutoDepositInterval, self.AutoDepositThreshold, self.AutoDepositBuffer)
+
+	return nil
+}
diff --git a/swarm/services/swap/swap/swap.go b/swarm/services/swap/swap/swap.go
new file mode 100644
index 000000000..9d5da7c3a
--- /dev/null
+++ b/swarm/services/swap/swap/swap.go
@@ -0,0 +1,254 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package swap
+
+import (
+	"fmt"
+	"math/big"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+)
+
+// SwAP Swarm Accounting Protocol with
+//      Swift Automatic  Payments
+// a peer to peer micropayment system
+
+// public swap profile
+// public parameters for SWAP, serializable config struct passed in handshake
+type Profile struct {
+	BuyAt  *big.Int // accepted max price for chunk
+	SellAt *big.Int // offered sale price for chunk
+	PayAt  uint     // threshold that triggers payment request
+	DropAt uint     // threshold that triggers disconnect
+}
+
+// Strategy encapsulates parameters relating to
+// automatic deposit and automatic cashing
+type Strategy struct {
+	AutoCashInterval     time.Duration // default interval for autocash
+	AutoCashThreshold    *big.Int      // threshold that triggers autocash (wei)
+	AutoDepositInterval  time.Duration // default interval for autocash
+	AutoDepositThreshold *big.Int      // threshold that triggers autodeposit (wei)
+	AutoDepositBuffer    *big.Int      // buffer that is surplus for fork protection etc (wei)
+}
+
+// Params extends the public profile with private parameters relating to
+// automatic deposit and automatic cashing
+type Params struct {
+	*Profile
+	*Strategy
+}
+
+// Promise
+// 3rd party Provable Promise of Payment
+// issued by outPayment
+// serialisable to send with Protocol
+type Promise interface{}
+
+// interface for the peer protocol for testing or external alternative payment
+type Protocol interface {
+	Pay(int, Promise) // units, payment proof
+	Drop()
+	String() string
+}
+
+// interface for the (delayed) ougoing payment system with autodeposit
+type OutPayment interface {
+	Issue(amount *big.Int) (promise Promise, err error)
+	AutoDeposit(interval time.Duration, threshold, buffer *big.Int)
+	Stop()
+}
+
+// interface for the (delayed) incoming payment system with autocash
+type InPayment interface {
+	Receive(promise Promise) (*big.Int, error)
+	AutoCash(cashInterval time.Duration, maxUncashed *big.Int)
+	Stop()
+}
+
+// swap is the swarm accounting protocol instance
+// * pairwise accounting and payments
+type Swap struct {
+	lock    sync.Mutex // mutex for balance access
+	balance int        // units of chunk/retrieval request
+	local   *Params    // local peer's swap parameters
+	remote  *Profile   // remote peer's swap profile
+	proto   Protocol   // peer communication protocol
+	Payment
+}
+
+type Payment struct {
+	Out         OutPayment // outgoing payment handler
+	In          InPayment  // incoming  payment handler
+	Buys, Sells bool
+}
+
+// swap constructor
+func New(local *Params, pm Payment, proto Protocol) (self *Swap, err error) {
+
+	self = &Swap{
+		local:   local,
+		Payment: pm,
+		proto:   proto,
+	}
+
+	self.SetParams(local)
+
+	return
+}
+
+// entry point for setting remote swap profile (e.g from handshake or other message)
+func (self *Swap) SetRemote(remote *Profile) {
+	defer self.lock.Unlock()
+	self.lock.Lock()
+
+	self.remote = remote
+	if self.Sells && (remote.BuyAt.Cmp(common.Big0) <= 0 || self.local.SellAt.Cmp(common.Big0) <= 0 || remote.BuyAt.Cmp(self.local.SellAt) < 0) {
+		self.Out.Stop()
+		self.Sells = false
+	}
+	if self.Buys && (remote.SellAt.Cmp(common.Big0) <= 0 || self.local.BuyAt.Cmp(common.Big0) <= 0 || self.local.BuyAt.Cmp(self.remote.SellAt) < 0) {
+		self.In.Stop()
+		self.Buys = false
+	}
+
+	glog.V(logger.Debug).Infof("<%v> remote profile set: pay at: %v, drop at: %v, buy at: %v, sell at: %v", self.proto, remote.PayAt, remote.DropAt, remote.BuyAt, remote.SellAt)
+
+}
+
+// to set strategy dynamically
+func (self *Swap) SetParams(local *Params) {
+	defer self.lock.Unlock()
+	self.lock.Lock()
+	self.local = local
+	self.setParams(local)
+}
+
+// caller holds the lock
+
+func (self *Swap) setParams(local *Params) {
+
+	if self.Sells {
+		self.In.AutoCash(local.AutoCashInterval, local.AutoCashThreshold)
+		glog.V(logger.Info).Infof("<%v> set autocash to every %v, max uncashed limit: %v", self.proto, local.AutoCashInterval, local.AutoCashThreshold)
+	} else {
+		glog.V(logger.Info).Infof("<%v> autocash off (not selling)", self.proto)
+	}
+	if self.Buys {
+		self.Out.AutoDeposit(local.AutoDepositInterval, local.AutoDepositThreshold, local.AutoDepositBuffer)
+		glog.V(logger.Info).Infof("<%v> set autodeposit to every %v, pay at: %v, buffer: %v", self.proto, local.AutoDepositInterval, local.AutoDepositThreshold, local.AutoDepositBuffer)
+	} else {
+		glog.V(logger.Info).Infof("<%v> autodeposit off (not buying)", self.proto)
+	}
+}
+
+// Add(n)
+// n > 0 called when promised/provided n units of service
+// n < 0 called when used/requested n units of service
+func (self *Swap) Add(n int) error {
+	defer self.lock.Unlock()
+	self.lock.Lock()
+	self.balance += n
+	if !self.Sells && self.balance > 0 {
+		glog.V(logger.Detail).Infof("<%v> remote peer cannot have debt (balance: %v)", self.proto, self.balance)
+		self.proto.Drop()
+		return fmt.Errorf("[SWAP] <%v> remote peer cannot have debt (balance: %v)", self.proto, self.balance)
+	}
+	if !self.Buys && self.balance < 0 {
+		glog.V(logger.Detail).Infof("<%v> we cannot have debt (balance: %v)", self.proto, self.balance)
+		return fmt.Errorf("[SWAP] <%v> we cannot have debt (balance: %v)", self.proto, self.balance)
+	}
+	if self.balance >= int(self.local.DropAt) {
+		glog.V(logger.Detail).Infof("<%v> remote peer has too much debt (balance: %v, disconnect threshold: %v)", self.proto, self.balance, self.local.DropAt)
+		self.proto.Drop()
+		return fmt.Errorf("[SWAP] <%v> remote peer has too much debt (balance: %v, disconnect threshold: %v)", self.proto, self.balance, self.local.DropAt)
+	} else if self.balance <= -int(self.remote.PayAt) {
+		self.send()
+	}
+	return nil
+}
+
+func (self *Swap) Balance() int {
+	defer self.lock.Unlock()
+	self.lock.Lock()
+	return self.balance
+}
+
+// send(units) is called when payment is due
+// In case of insolvency no promise is issued and sent, safe against fraud
+// No return value: no error = payment is opportunistic = hang in till dropped
+func (self *Swap) send() {
+	if self.local.BuyAt != nil && self.balance < 0 {
+		amount := big.NewInt(int64(-self.balance))
+		amount.Mul(amount, self.remote.SellAt)
+		promise, err := self.Out.Issue(amount)
+		if err != nil {
+			glog.V(logger.Warn).Infof("<%v> cannot issue cheque (amount: %v, channel: %v): %v", self.proto, amount, self.Out, err)
+		} else {
+			glog.V(logger.Warn).Infof("<%v> cheque issued (amount: %v, channel: %v)", self.proto, amount, self.Out)
+			self.proto.Pay(-self.balance, promise)
+			self.balance = 0
+		}
+	}
+}
+
+// receive(units, promise) is called by the protocol when a payment msg is received
+// returns error if promise is invalid.
+func (self *Swap) Receive(units int, promise Promise) error {
+	if units <= 0 {
+		return fmt.Errorf("invalid units: %v <= 0", units)
+	}
+
+	price := new(big.Int).SetInt64(int64(units))
+	price.Mul(price, self.local.SellAt)
+
+	amount, err := self.In.Receive(promise)
+
+	if err != nil {
+		err = fmt.Errorf("invalid promise: %v", err)
+	} else if price.Cmp(amount) != 0 {
+		// verify amount = units * unit sale price
+		return fmt.Errorf("invalid amount: %v = %v * %v (units sent in msg * agreed sale unit price) != %v (signed in cheque)", price, units, self.local.SellAt, amount)
+	}
+	if err != nil {
+		glog.V(logger.Detail).Infof("<%v> invalid promise (amount: %v, channel: %v): %v", self.proto, amount, self.In, err)
+		return err
+	}
+
+	// credit remote peer with units
+	self.Add(-units)
+	glog.V(logger.Detail).Infof("<%v> received promise (amount: %v, channel: %v): %v", self.proto, amount, self.In, promise)
+
+	return nil
+}
+
+// stop() causes autocash loop to terminate.
+// Called after protocol handle loop terminates.
+func (self *Swap) Stop() {
+	defer self.lock.Unlock()
+	self.lock.Lock()
+	if self.Buys {
+		self.Out.Stop()
+	}
+	if self.Sells {
+		self.In.Stop()
+	}
+}
diff --git a/swarm/services/swap/swap/swap_test.go b/swarm/services/swap/swap/swap_test.go
new file mode 100644
index 000000000..222e0770f
--- /dev/null
+++ b/swarm/services/swap/swap/swap_test.go
@@ -0,0 +1,194 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package swap
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type testInPayment struct {
+	received         []*testPromise
+	autocashInterval time.Duration
+	autocashLimit    *big.Int
+}
+
+type testPromise struct {
+	amount *big.Int
+}
+
+func (self *testInPayment) Receive(promise Promise) (*big.Int, error) {
+	p := promise.(*testPromise)
+	self.received = append(self.received, p)
+	return p.amount, nil
+}
+
+func (self *testInPayment) AutoCash(interval time.Duration, limit *big.Int) {
+	self.autocashInterval = interval
+	self.autocashLimit = limit
+}
+
+func (self *testInPayment) Cash() (string, error) { return "", nil }
+
+func (self *testInPayment) Stop() {}
+
+type testOutPayment struct {
+	deposits             []*big.Int
+	autodepositInterval  time.Duration
+	autodepositThreshold *big.Int
+	autodepositBuffer    *big.Int
+}
+
+func (self *testOutPayment) Issue(amount *big.Int) (promise Promise, err error) {
+	return &testPromise{amount}, nil
+}
+
+func (self *testOutPayment) Deposit(amount *big.Int) (string, error) {
+	self.deposits = append(self.deposits, amount)
+	return "", nil
+}
+
+func (self *testOutPayment) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) {
+	self.autodepositInterval = interval
+	self.autodepositThreshold = threshold
+	self.autodepositBuffer = buffer
+}
+
+func (self *testOutPayment) Stop() {}
+
+type testProtocol struct {
+	drop     bool
+	amounts  []int
+	promises []*testPromise
+}
+
+func (self *testProtocol) Drop() {
+	self.drop = true
+}
+
+func (self *testProtocol) String() string {
+	return ""
+}
+
+func (self *testProtocol) Pay(amount int, promise Promise) {
+	p := promise.(*testPromise)
+	self.promises = append(self.promises, p)
+	self.amounts = append(self.amounts, amount)
+}
+
+func TestSwap(t *testing.T) {
+
+	strategy := &Strategy{
+		AutoCashInterval:     1 * time.Second,
+		AutoCashThreshold:    big.NewInt(20),
+		AutoDepositInterval:  1 * time.Second,
+		AutoDepositThreshold: big.NewInt(20),
+		AutoDepositBuffer:    big.NewInt(40),
+	}
+
+	local := &Params{
+		Profile: &Profile{
+			PayAt:  5,
+			DropAt: 10,
+			BuyAt:  common.Big3,
+			SellAt: common.Big2,
+		},
+		Strategy: strategy,
+	}
+
+	in := &testInPayment{}
+	out := &testOutPayment{}
+	proto := &testProtocol{}
+
+	swap, _ := New(local, Payment{In: in, Out: out, Buys: true, Sells: true}, proto)
+
+	if in.autocashInterval != strategy.AutoCashInterval {
+		t.Fatalf("autocash interval not properly set, expect %v, got %v", strategy.AutoCashInterval, in.autocashInterval)
+	}
+	if out.autodepositInterval != strategy.AutoDepositInterval {
+		t.Fatalf("autodeposit interval not properly set, expect %v, got %v", strategy.AutoDepositInterval, out.autodepositInterval)
+	}
+
+	remote := &Profile{
+		PayAt:  3,
+		DropAt: 10,
+		BuyAt:  common.Big2,
+		SellAt: common.Big3,
+	}
+	swap.SetRemote(remote)
+
+	swap.Add(9)
+	if proto.drop {
+		t.Fatalf("not expected peer to be dropped")
+	}
+	swap.Add(1)
+	if !proto.drop {
+		t.Fatalf("expected peer to be dropped")
+	}
+	if !proto.drop {
+		t.Fatalf("expected peer to be dropped")
+	}
+	proto.drop = false
+
+	swap.Receive(10, &testPromise{big.NewInt(20)})
+	if swap.balance != 0 {
+		t.Fatalf("expected zero balance, got %v", swap.balance)
+	}
+
+	if len(proto.amounts) != 0 {
+		t.Fatalf("expected zero balance, got %v", swap.balance)
+	}
+
+	swap.Add(-2)
+	if len(proto.amounts) > 0 {
+		t.Fatalf("expected no payments yet, got %v", proto.amounts)
+	}
+
+	swap.Add(-1)
+	if len(proto.amounts) != 1 {
+		t.Fatalf("expected one payment, got %v", len(proto.amounts))
+	}
+
+	if proto.amounts[0] != 3 {
+		t.Fatalf("expected payment for %v units, got %v", proto.amounts[0], 3)
+	}
+
+	exp := new(big.Int).Mul(big.NewInt(int64(proto.amounts[0])), remote.SellAt)
+	if proto.promises[0].amount.Cmp(exp) != 0 {
+		t.Fatalf("expected payment amount %v, got %v", exp, proto.promises[0].amount)
+	}
+
+	swap.SetParams(&Params{
+		Profile: &Profile{
+			PayAt:  5,
+			DropAt: 10,
+			BuyAt:  common.Big3,
+			SellAt: common.Big2,
+		},
+		Strategy: &Strategy{
+			AutoCashInterval:     2 * time.Second,
+			AutoCashThreshold:    big.NewInt(40),
+			AutoDepositInterval:  2 * time.Second,
+			AutoDepositThreshold: big.NewInt(40),
+			AutoDepositBuffer:    big.NewInt(60),
+		},
+	})
+
+}