You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 lines
4.7 KiB
175 lines
4.7 KiB
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"flag"
|
|
"fmt"
|
|
"time"
|
|
|
|
acm "github.com/tendermint/tendermint/account"
|
|
. "github.com/tendermint/tendermint/common"
|
|
"github.com/tendermint/tendermint/rpc/client"
|
|
ctypes "github.com/tendermint/tendermint/rpc/core/types"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
const Version = "0.0.1"
|
|
const sleepSeconds = 1 // Every second
|
|
|
|
// Parse command-line options
|
|
func parseFlags() (privKeyHex string, numAccounts int, remote string, version bool) {
|
|
flag.StringVar(&privKeyHex, "priv-key", "", "Private key bytes in HEX")
|
|
flag.IntVar(&numAccounts, "num-accounts", 1000, "Deterministically generates this many sub-accounts")
|
|
flag.StringVar(&remote, "remote", "http://localhost:46657", "Remote RPC host:port")
|
|
flag.BoolVar(&version, "version", false, "Version")
|
|
flag.Parse()
|
|
return
|
|
}
|
|
|
|
func main() {
|
|
|
|
// Read options
|
|
privKeyHex, numAccounts, remote, version := parseFlags()
|
|
if version {
|
|
fmt.Println(Fmt("sim_txs version %v", Version))
|
|
return
|
|
}
|
|
|
|
// Print args.
|
|
// fmt.Println(privKeyHex, numAccounts, remote, version)
|
|
|
|
privKeyBytes, err := hex.DecodeString(privKeyHex)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var privKeyArray [64]byte
|
|
copy(privKeyArray[:], privKeyBytes)
|
|
root := acm.GenPrivAccountFromPrivKeyBytes(&privKeyArray)
|
|
fmt.Println("Computed address: %X", root.Address)
|
|
|
|
// Get root account.
|
|
rootAccount, err := getAccount(remote, root.Address)
|
|
if err != nil {
|
|
fmt.Println(Fmt("Root account does not exist: %X", root.Address))
|
|
return
|
|
} else {
|
|
fmt.Println("Root account", rootAccount)
|
|
}
|
|
|
|
go func() {
|
|
// Construct a new send Tx
|
|
accounts := make([]*acm.Account, numAccounts)
|
|
privAccounts := make([]*acm.PrivAccount, numAccounts)
|
|
for i := 0; i < numAccounts; i++ {
|
|
privAccounts[i] = root.Generate(i)
|
|
account, err := getAccount(remote, privAccounts[i].Address)
|
|
if err != nil {
|
|
fmt.Println("Error", err)
|
|
return
|
|
} else {
|
|
accounts[i] = account
|
|
}
|
|
}
|
|
for {
|
|
sendTx := makeRandomTransaction(rootAccount, root, accounts, privAccounts)
|
|
// Broadcast it.
|
|
err := broadcastSendTx(remote, sendTx)
|
|
if err != nil {
|
|
Exit(Fmt("Failed to broadcast SendTx: %v", err))
|
|
return
|
|
}
|
|
// Broadcast 1 tx!
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
}()
|
|
|
|
// Trap signal
|
|
TrapSignal(func() {
|
|
fmt.Println("sim_txs shutting down")
|
|
})
|
|
}
|
|
|
|
func getAccount(remote string, address []byte) (*acm.Account, error) {
|
|
// var account *acm.Account = new(acm.Account)
|
|
account, err := rpcclient.Call(remote, "get_account", []interface{}{address}, (*acm.Account)(nil))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if account.(*acm.Account) == nil {
|
|
return &acm.Account{Address: address}, nil
|
|
} else {
|
|
return account.(*acm.Account), nil
|
|
}
|
|
}
|
|
|
|
func broadcastSendTx(remote string, sendTx *types.SendTx) error {
|
|
receipt, err := rpcclient.Call(remote, "broadcast_tx", []interface{}{sendTx}, (*ctypes.Receipt)(nil))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Println("Broadcast receipt:", receipt)
|
|
return nil
|
|
}
|
|
|
|
func makeRandomTransaction(rootAccount *acm.Account, rootPrivAccount *acm.PrivAccount, accounts []*acm.Account, privAccounts []*acm.PrivAccount) *types.SendTx {
|
|
allAccounts := append(accounts, rootAccount)
|
|
allPrivAccounts := append(privAccounts, rootPrivAccount)
|
|
|
|
// Find accout with the most money
|
|
inputBalance := int64(0)
|
|
inputAccount := (*acm.Account)(nil)
|
|
inputPrivAccount := (*acm.PrivAccount)(nil)
|
|
for i, account := range allAccounts {
|
|
if account == nil {
|
|
continue
|
|
}
|
|
if inputBalance < account.Balance {
|
|
inputBalance = account.Balance
|
|
inputAccount = account
|
|
inputPrivAccount = allPrivAccounts[i]
|
|
}
|
|
}
|
|
if inputAccount == nil {
|
|
Exit("No accounts have any money")
|
|
return nil
|
|
}
|
|
|
|
// Find a selection of accounts to send to
|
|
outputAccounts := map[string]*acm.Account{}
|
|
for i := 0; i < 2; i++ {
|
|
for {
|
|
idx := RandInt() % len(accounts)
|
|
if bytes.Equal(accounts[idx].Address, inputAccount.Address) {
|
|
continue
|
|
}
|
|
if _, ok := outputAccounts[string(accounts[idx].Address)]; ok {
|
|
continue
|
|
}
|
|
outputAccounts[string(accounts[idx].Address)] = accounts[idx]
|
|
break
|
|
}
|
|
}
|
|
|
|
// Construct SendTx
|
|
sendTx := types.NewSendTx()
|
|
err := sendTx.AddInputWithNonce(inputPrivAccount.PubKey, inputAccount.Balance, inputAccount.Sequence+1)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for _, outputAccount := range outputAccounts {
|
|
sendTx.AddOutput(outputAccount.Address, inputAccount.Balance/int64(len(outputAccounts)))
|
|
// XXX FIXME???
|
|
outputAccount.Balance += inputAccount.Balance / int64(len(outputAccounts))
|
|
}
|
|
|
|
// Sign SendTx
|
|
sendTx.SignInput("tendermint_testnet_7", 0, inputPrivAccount)
|
|
|
|
// Hack: Listen for events or create a new RPC call for this.
|
|
// XXX FIXME
|
|
inputAccount.Sequence += 1
|
|
inputAccount.Balance = 0 // FIXME???
|
|
|
|
return sendTx
|
|
}
|