monkey.go

// Copyright 2018 The dexon-consensus Authors
// This file is part of the dexon-consensus library.
//
// The dexon-consensus 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 dexon-consensus 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 dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.

// A simple monkey that sends random transactions into the network.

package monkey

import (
	"context"
	"crypto/ecdsa"
	"encoding/hex"
	"fmt"
	"math/big"
	"math/rand"
	"os"
	"time"

	"github.com/dexon-foundation/dexon/cmd/zoo/client"
	"github.com/dexon-foundation/dexon/crypto"
)

var config *MonkeyConfig

type MonkeyConfig struct {
	Key      string
	Endpoint string
	N        int
	Gambler  bool
	Feeder   bool
	Batch    bool
	Sleep    int
	Timeout  int
}

func Init(cfg *MonkeyConfig) {
	config = cfg
}

type Monkey struct {
	client.Client

	source *ecdsa.PrivateKey
	keys   []*ecdsa.PrivateKey
	timer  <-chan time.Time
}

func New(ep string, source *ecdsa.PrivateKey, num int, timeout time.Duration) *Monkey {
	client, err := client.New(ep)
	if err != nil {
		panic(err)
	}

	file := func() *os.File {
		for i := 0; i < 100; i++ {
			name := fmt.Sprintf("zoo-%d.keys", i)
			file, err := os.OpenFile(name,
				os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0600)
			if err != nil {
				continue
			}
			fmt.Printf("Save keys to file %s\n", name)
			return file
		}
		return nil
	}()
	if file == nil {
		panic(fmt.Errorf("Failed to create file for zoo keys"))
	}
	defer file.Close()

	var keys []*ecdsa.PrivateKey

	for i := 0; i < num; i++ {
		key, err := crypto.GenerateKey()
		if err != nil {
			panic(err)
		}
		_, err = file.Write([]byte(hex.EncodeToString(crypto.FromECDSA(key)) + "\n"))
		if err != nil {
			panic(err)
		}
		keys = append(keys, key)
	}

	monkey := &Monkey{
		Client: *client,
		source: source,
		keys:   keys,
	}

	if timeout > 0 {
		monkey.timer = time.After(timeout * time.Second)
	}

	return monkey
}

func (m *Monkey) Distribute() {
	fmt.Println("Distributing DEX to random accounts ...")
	address := crypto.PubkeyToAddress(m.source.PublicKey)
	nonce, err := m.PendingNonceAt(context.Background(), address)
	if err != nil {
		panic(err)
	}

	ctxs := make([]*client.TransferContext, len(m.keys))
	for i, key := range m.keys {
		address := crypto.PubkeyToAddress(key.PublicKey)
		amount := new(big.Int)
		amount.SetString("1000000000000000000", 10)
		ctxs[i] = &client.TransferContext{
			Key:       m.source,
			ToAddress: address,
			Amount:    amount,
			Nonce:     nonce,
			Gas:       21000,
		}
		nonce++
	}
	m.BatchTransfer(ctxs)
	time.Sleep(20 * time.Second)
}

func (m *Monkey) Crazy() uint64 {
	fmt.Println("Performing random transfers ...")
	nonce := uint64(0)
loop:
	for {
		ctxs := make([]*client.TransferContext, len(m.keys))
		for i, key := range m.keys {
			to := crypto.PubkeyToAddress(m.keys[rand.Int()%len(m.keys)].PublicKey)
			amount := new(big.Int)
			amount.SetString(fmt.Sprintf("%d0000000000000", rand.Intn(10)+1), 10)
			ctx := &client.TransferContext{
				Key:       key,
				ToAddress: to,
				Amount:    amount,
				Nonce:     nonce,
				Gas:       21000,
			}
			if config.Batch {
				ctxs[i] = ctx
			} else {
				m.Transfer(ctx)
			}
		}
		if config.Batch {
			m.BatchTransfer(ctxs)
		}
		fmt.Printf("Sent %d transactions, nonce = %d\n", len(m.keys), nonce)

		if m.timer != nil {
			select {
			case <-m.timer:
				break loop
			default:
			}
		}

		nonce++
		time.Sleep(time.Duration(config.Sleep) * time.Millisecond)
	}

	return nonce
}

func (m *Monkey) Keys() []*ecdsa.PrivateKey {
	return m.keys
}

func Exec() (*Monkey, uint64) {
	privKey, err := crypto.LoadECDSA(config.Key)
	if err != nil {
		panic(err)
	}

	m := New(config.Endpoint, privKey, config.N, time.Duration(config.Timeout))
	m.Distribute()
	var finalNonce uint64
	if config.Gambler {
		finalNonce = m.Gamble()
	} else if config.Feeder {
		finalNonce = m.Feed()
	} else {
		finalNonce = m.Crazy()
	}

	return m, finalNonce
}