mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-12-27 08:45:19 +00:00
ff5b0e814e
* setup e2e test that starts kava chain * refactor into a testify suite * setup ethClient * add example test checking chain id * cleanup * refactor & support funded accounts with txs * ignore e2e tests in CI & consolidate makefiles * remove circular go.mod dependency vendors `signing` and `grpc` packages from `kava-labs/go-tools` to refrain from a circular dep and fix pulled in dep versions * add min fee for evm side * prune nothing in e2e node
128 lines
3.5 KiB
Go
128 lines
3.5 KiB
Go
package testutil
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
|
|
"github.com/cosmos/cosmos-sdk/crypto/hd"
|
|
"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
|
|
"github.com/cosmos/go-bip39"
|
|
|
|
"github.com/kava-labs/kava/app"
|
|
"github.com/kava-labs/kava/tests/util"
|
|
)
|
|
|
|
type SigningAccount struct {
|
|
name string
|
|
mnemonic string
|
|
signer *util.Signer
|
|
requests chan<- util.MsgRequest
|
|
responses <-chan util.MsgResponse
|
|
|
|
Address sdk.AccAddress
|
|
|
|
l *log.Logger
|
|
}
|
|
|
|
// GetAccount returns the account with the given name or fails
|
|
func (suite *E2eTestSuite) GetAccount(name string) *SigningAccount {
|
|
acc, found := suite.accounts[name]
|
|
if !found {
|
|
suite.Failf("account does not exist", "failed to find account with name %s", name)
|
|
}
|
|
return acc
|
|
}
|
|
|
|
// AddNewSigningAccount sets up a new account with a signer.
|
|
func (suite *E2eTestSuite) AddNewSigningAccount(name string, hdPath *hd.BIP44Params, chainId, mnemonic string) *SigningAccount {
|
|
if _, found := suite.accounts[name]; found {
|
|
suite.Failf("can't create signing account", "account with name %s already exists", name)
|
|
}
|
|
|
|
privKeyBytes, err := hd.Secp256k1.Derive()(mnemonic, "", hdPath.String())
|
|
suite.NoErrorf(err, "failed to derive private key from mnemonic for %s: %s", name, err)
|
|
privKey := &secp256k1.PrivKey{Key: privKeyBytes}
|
|
|
|
signer := util.NewSigner(
|
|
chainId,
|
|
suite.encodingConfig,
|
|
suite.Auth,
|
|
suite.Tx,
|
|
privKey,
|
|
100,
|
|
)
|
|
|
|
requests := make(chan util.MsgRequest)
|
|
responses, err := signer.Run(requests)
|
|
suite.NoErrorf(err, "failed to start signer for account %s: %s", name, err)
|
|
|
|
logger := log.New(os.Stdout, fmt.Sprintf("[%s] ", name), log.LstdFlags)
|
|
|
|
// TODO: authenticated eth client.
|
|
suite.accounts[name] = &SigningAccount{
|
|
name: name,
|
|
mnemonic: mnemonic,
|
|
signer: signer,
|
|
requests: requests,
|
|
responses: responses,
|
|
l: logger,
|
|
|
|
Address: signer.Address(),
|
|
}
|
|
|
|
return suite.accounts[name]
|
|
}
|
|
|
|
// SignAndBroadcastKavaTx sends a request to the signer and awaits its response.
|
|
func (a *SigningAccount) SignAndBroadcastKavaTx(req util.MsgRequest) util.MsgResponse {
|
|
a.l.Printf("broadcasting tx %+v\n", req.Data)
|
|
// send the request to signer
|
|
a.requests <- req
|
|
|
|
// block and await response
|
|
// response is not returned until the msg is committed to a block
|
|
res := <-a.responses
|
|
|
|
// error will be set if response is not Code 0 (success) or Code 19 (already in mempool)
|
|
if res.Err != nil {
|
|
a.l.Printf("response code: %d error: %s\n", res.Result.Code, res.Result.RawLog)
|
|
} else {
|
|
a.l.Printf("response code: %d, hash %s\n", res.Result.Code, res.Result.TxHash)
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func (suite *E2eTestSuite) NewFundedAccount(name string, funds sdk.Coins) *SigningAccount {
|
|
entropy, err := bip39.NewEntropy(128)
|
|
suite.NoErrorf(err, "failed to generate entropy for account %s: %s", name, err)
|
|
mnemonic, err := bip39.NewMnemonic(entropy)
|
|
suite.NoErrorf(err, "failed to create new mnemonic for account %s: %s", name, err)
|
|
|
|
acc := suite.AddNewSigningAccount(
|
|
name,
|
|
hd.CreateHDPath(app.Bip44CoinType, 0, 0),
|
|
ChainId,
|
|
mnemonic,
|
|
)
|
|
|
|
whale := suite.GetAccount(FundedAccountName)
|
|
res := whale.SignAndBroadcastKavaTx(
|
|
util.MsgRequest{
|
|
Msgs: []sdk.Msg{
|
|
banktypes.NewMsgSend(whale.Address, acc.Address, funds),
|
|
},
|
|
GasLimit: 1e5,
|
|
FeeAmount: sdk.NewCoins(sdk.NewCoin(StakingDenom, sdk.NewInt(75000))),
|
|
Data: fmt.Sprintf("initial funding of account %s", name),
|
|
},
|
|
)
|
|
|
|
suite.NoErrorf(res.Err, "failed to fund new account %s: %s", name, res.Err)
|
|
|
|
return acc
|
|
}
|