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
This commit is contained in:
ΞTHΞЯSPHΞЯΞ
Felix Lange
283
swarm/services/swap/swap.go
Normal file
283
swarm/services/swap/swap.go
Normal file
@ -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
|
||||
}
|
||||
254
swarm/services/swap/swap/swap.go
Normal file
254
swarm/services/swap/swap/swap.go
Normal file
@ -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()
|
||||
}
|
||||
}
|
||||
194
swarm/services/swap/swap/swap_test.go
Normal file
194
swarm/services/swap/swap/swap_test.go
Normal file
@ -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),
|
||||
},
|
||||
})
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user