status-im
/
status-go
mirror of https://github.com/status-im/status-go.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

First step to remove StatusAPI (#1034)

This commit is contained in:
Adrià Cidre 2018-06-19 09:49:24 +02:00 committed by GitHub
parent 2b290d1a76
commit 56cc3d20da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 115 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
api/api.go
View File

@ -1,229 +0,0 @@
package api
import (
"context"
"github.com/NaySoftware/go-fcm"
"github.com/ethereum/go-ethereum/accounts/keystore"
gethcommon "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/log"
"github.com/status-im/status-go/account"
"github.com/status-im/status-go/jail"
"github.com/status-im/status-go/node"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/sign"
"github.com/status-im/status-go/transactions"
)
// StatusAPI provides API to access Status related functionality.
type StatusAPI struct {
b *StatusBackend
log log.Logger
}
// NewStatusAPI creates a new StatusAPI instance
func NewStatusAPI() *StatusAPI {
return NewStatusAPIWithBackend(NewStatusBackend())
}
// NewStatusAPIWithBackend creates a new StatusAPI instance using
// the passed backend.
func NewStatusAPIWithBackend(b *StatusBackend) *StatusAPI {
return &StatusAPI{
b: b,
log: log.New("package", "status-go/api.StatusAPI"),
}
}
// StatusNode returns reference to StatusNode.
func (api *StatusAPI) StatusNode() *node.StatusNode {
return api.b.StatusNode()
}
// AccountManager returns reference to account manager
func (api *StatusAPI) AccountManager() *account.Manager {
return api.b.AccountManager()
}
// JailManager returns reference to jail
func (api *StatusAPI) JailManager() jail.Manager {
return api.b.JailManager()
}
// Transactor returns reference to a status transactor
func (api *StatusAPI) Transactor() *transactions.Transactor {
return api.b.Transactor()
}
// PendingSignRequests returns reference to a list of current sign requests
func (api *StatusAPI) PendingSignRequests() *sign.PendingRequests {
return api.b.PendingSignRequests()
}
// StartNode start Status node, fails if node is already started
func (api *StatusAPI) StartNode(config *params.NodeConfig) error {
return api.b.StartNode(config)
}
// StartNodeAsync start Status node, fails if node is already started
// Returns immediately w/o waiting for node to start (see node.ready)
func (api *StatusAPI) StartNodeAsync(config *params.NodeConfig) <-chan error {
return runAsync(func() error { return api.StartNode(config) })
}
// StopNode stop Status node. Stopped node cannot be resumed.
func (api *StatusAPI) StopNode() error {
return api.b.StopNode()
}
// StopNodeAsync stop Status node. Stopped node cannot be resumed.
// Returns immediately, w/o waiting for node to stop (see node.stopped)
func (api *StatusAPI) StopNodeAsync() <-chan error {
return runAsync(api.StopNode)
}
// RestartNode restart running Status node, fails if node is not running
func (api *StatusAPI) RestartNode() error {
return api.b.RestartNode()
}
// RestartNodeAsync restart running Status node, in async manner
func (api *StatusAPI) RestartNodeAsync() <-chan error {
return runAsync(api.RestartNode)
}
// ResetChainData remove chain data from data directory.
// Node is stopped, and new node is started, with clean data directory.
func (api *StatusAPI) ResetChainData() error {
return api.b.ResetChainData()
}
// ResetChainDataAsync remove chain data from data directory, in async manner
func (api *StatusAPI) ResetChainDataAsync() <-chan error {
return runAsync(api.ResetChainData)
}
// CallRPC executes public RPC requests on node's in-proc RPC server.
func (api *StatusAPI) CallRPC(inputJSON string) string {
return api.b.CallRPC(inputJSON)
}
// CallPrivateRPC executes public and private RPC requests on node's in-proc RPC server.
func (api *StatusAPI) CallPrivateRPC(inputJSON string) string {
return api.b.CallPrivateRPC(inputJSON)
}
// CreateAccount creates an internal geth account
// BIP44-compatible keys are generated: CKD#1 is stored as account key, CKD#2 stored as sub-account root
// Public key of CKD#1 is returned, with CKD#2 securely encoded into account key file (to be used for
// sub-account derivations)
func (api *StatusAPI) CreateAccount(password string) (address, pubKey, mnemonic string, err error) {
return api.b.AccountManager().CreateAccount(password)
}
// CreateChildAccount creates sub-account for an account identified by parent address.
// CKD#2 is used as root for master accounts (when parentAddress is "").
// Otherwise (when parentAddress != ""), child is derived directly from parent.
func (api *StatusAPI) CreateChildAccount(parentAddress, password string) (address, pubKey string, err error) {
return api.b.AccountManager().CreateChildAccount(parentAddress, password)
}
// RecoverAccount re-creates master key using given details.
// Once master key is re-generated, it is inserted into keystore (if not already there).
func (api *StatusAPI) RecoverAccount(password, mnemonic string) (address, pubKey string, err error) {
return api.b.AccountManager().RecoverAccount(password, mnemonic)
}
// VerifyAccountPassword tries to decrypt a given account key file, with a provided password.
// If no error is returned, then account is considered verified.
func (api *StatusAPI) VerifyAccountPassword(keyStoreDir, address, password string) (*keystore.Key, error) {
return api.b.AccountManager().VerifyAccountPassword(keyStoreDir, address, password)
}
// SelectAccount selects current account, by verifying that address has corresponding account which can be decrypted
// using provided password. Once verification is done, decrypted key is injected into Whisper (as a single identity,
// all previous identities are removed).
func (api *StatusAPI) SelectAccount(address, password string) error {
return api.b.SelectAccount(address, password)
}
// Logout clears whisper identities
func (api *StatusAPI) Logout() error {
return api.b.Logout()
}
// SendTransaction creates a new transaction and waits until it's complete.
func (api *StatusAPI) SendTransaction(ctx context.Context, args transactions.SendTxArgs) (gethcommon.Hash, error) {
return api.b.SendTransaction(ctx, args)
}
// ApproveSignRequest instructs backend to complete sending of a given transaction
func (api *StatusAPI) ApproveSignRequest(id, password string) sign.Result {
return api.b.ApproveSignRequest(id, password)
}
// ApproveSignRequestWithArgs instructs backend to complete sending of a given transaction
// gas and gasPrice will be overrided with the given values before signing the
// transaction.
func (api *StatusAPI) ApproveSignRequestWithArgs(id, password string, gas, gasPrice int64) sign.Result {
return api.b.ApproveSignRequestWithArgs(id, password, gas, gasPrice)
}
// ApproveSignRequests instructs backend to complete sending of multiple transactions
func (api *StatusAPI) ApproveSignRequests(ids []string, password string) map[string]sign.Result {
return api.b.ApproveSignRequests(ids, password)
}
// DiscardSignRequest discards a given transaction from transaction queue
func (api *StatusAPI) DiscardSignRequest(id string) error {
return api.b.DiscardSignRequest(id)
}
// DiscardSignRequests discards given multiple transactions from transaction queue
func (api *StatusAPI) DiscardSignRequests(ids []string) map[string]error {
return api.b.DiscardSignRequests(ids)
}
// JailParse creates a new jail cell context, with the given chatID as identifier.
// New context executes provided JavaScript code, right after the initialization.
// DEPRECATED in favour of CreateAndInitCell.
func (api *StatusAPI) JailParse(chatID string, js string) string {
return api.b.jailManager.Parse(chatID, js)
}
// CreateAndInitCell creates a new jail cell context, with the given chatID as identifier.
// New context executes provided JavaScript code, right after the initialization.
func (api *StatusAPI) CreateAndInitCell(chatID, js string) string {
return api.b.jailManager.CreateAndInitCell(chatID, js)
}
// JailCall executes given JavaScript function w/i a jail cell context identified by the chatID.
func (api *StatusAPI) JailCall(chatID, this, args string) string {
return api.b.jailManager.Call(chatID, this, args)
}
// JailExecute allows to run arbitrary JS code within a jail cell.
func (api *StatusAPI) JailExecute(chatID, code string) string {
return api.b.jailManager.Execute(chatID, code)
}
// SetJailBaseJS allows to setup initial JavaScript to be loaded on each jail.CreateAndInitCell().
func (api *StatusAPI) SetJailBaseJS(js string) {
api.b.jailManager.SetBaseJS(js)
}
// NotifyUsers send notifications to users.
func (api *StatusAPI) NotifyUsers(message string, payload fcm.NotificationPayload, tokens ...string) error {
return api.b.NotifyUsers(message, payload, tokens...)
}
// ConnectionChange handles network state changes logic.
func (api *StatusAPI) ConnectionChange(typ string, expensive bool) {
api.b.ConnectionChange(typ, expensive)
}
// AppStateChange handles app state changes (background/foreground).
// state values: see https://facebook.github.io/react-native/docs/appstate.html
func (api *StatusAPI) AppStateChange(state string) {
api.b.AppStateChange(state)
}

2
api/utils.go
View File

@ -1,6 +1,6 @@
package api
func runAsync(f func() error) <-chan error {
func RunAsync(f func() error) <-chan error {
resp := make(chan error, 1)
go func() {
err := f()

28
cmd/statusd/debug/commands.go
View File

@ -106,14 +106,14 @@ func exprsToArgs(exprs []ast.Expr) []interface{} {
// is not possible due to non-low-level arguments. Here this wrapper
// helps.
type commandSet struct {
statusAPI *api.StatusAPI
statusBackend *api.StatusBackend
}
// newCommandSet creates the command set for the passed Status API
// instance.
func newCommandSet(statusAPI *api.StatusAPI) *commandSet {
func newCommandSet(statusBackend *api.StatusBackend) *commandSet {
return &commandSet{
statusAPI: statusAPI,
statusBackend: statusBackend,
}
}
@ -124,52 +124,52 @@ func (cs *commandSet) StartNode(config string) error {
if err != nil {
return err
}
return cs.statusAPI.StartNode(nodeConfig)
return cs.statusBackend.StartNode(nodeConfig)
}
// StopNode starts the stopped node.
func (cs *commandSet) StopNode() error {
return cs.statusAPI.StopNode()
return cs.statusBackend.StopNode()
}
// ResetChainData removes chain data from data directory.
func (cs *commandSet) ResetChainData() error {
return cs.statusAPI.ResetChainData()
return cs.statusBackend.ResetChainData()
}
// CallRPC calls status node via RPC.
func (cs *commandSet) CallRPC(inputJSON string) string {
return cs.statusAPI.CallRPC(inputJSON)
return cs.statusBackend.CallRPC(inputJSON)
}
// CreateAccount creates an internal geth account.
func (cs *commandSet) CreateAccount(password string) (string, string, string, error) {
return cs.statusAPI.CreateAccount(password)
return cs.statusBackend.AccountManager().CreateAccount(password)
}
// CreateChildAccount creates a sub-account.
func (cs *commandSet) CreateChildAccount(parentAddress, password string) (string, string, error) {
return cs.statusAPI.CreateChildAccount(parentAddress, password)
return cs.statusBackend.AccountManager().CreateChildAccount(parentAddress, password)
}
// RecoverAccount re-creates the master key using the given details.
func (cs *commandSet) RecoverAccount(password, mnemonic string) (string, string, error) {
return cs.statusAPI.RecoverAccount(password, mnemonic)
return cs.statusBackend.AccountManager().RecoverAccount(password, mnemonic)
}
// SelectAccount selects the addressed account.
func (cs *commandSet) SelectAccount(address, password string) error {
return cs.statusAPI.SelectAccount(address, password)
return cs.statusBackend.SelectAccount(address, password)
}
// Logout clears the Whisper identities.
func (cs *commandSet) Logout() error {
return cs.statusAPI.Logout()
return cs.statusBackend.Logout()
}
// ApproveSignRequest instructs API to complete sending of a given transaction.
func (cs *commandSet) ApproveSignRequest(id, password string) (string, error) {
result := cs.statusAPI.ApproveSignRequest(id, password)
result := cs.statusBackend.ApproveSignRequest(id, password)
if result.Error != nil {
return "", result.Error
}
@ -180,7 +180,7 @@ func (cs *commandSet) ApproveSignRequest(id, password string) (string, error) {
// gas and gasPrice will be overrided with the given values before signing the
// transaction.
func (cs *commandSet) ApproveSignRequestWithArgs(id, password string, gas, gasPrice int64) (string, error) {
result := cs.statusAPI.ApproveSignRequestWithArgs(id, password, gas, gasPrice)
result := cs.statusBackend.ApproveSignRequestWithArgs(id, password, gas, gasPrice)
if result.Error != nil {
return "", result.Error
}

4
cmd/statusd/debug/debug.go
View File

@ -27,13 +27,13 @@ type Server struct {
// New creates a debug server using the passed Status API.
// It also starts the server.
func New(statusAPI *api.StatusAPI, port string) (*Server, error) {
func New(statusBackend *api.StatusBackend, port string) (*Server, error) {
listener, err := net.Listen("tcp", fmt.Sprintf(":%s", port)) // nolint
if err != nil {
return nil, err
}
s := Server{
commandSetValue: reflect.ValueOf(newCommandSet(statusAPI)),
commandSetValue: reflect.ValueOf(newCommandSet(statusBackend)),
listener: listener,
log: log.New("package", "status-go/cmd/statusd/debug.Server"),
}

4
cmd/statusd/debug/debug_test.go
View File

@ -161,8 +161,8 @@ func startDebugging(assert *testifyAssert.Assertions) {
defer mu.Unlock()
if d == nil {
var err error
api := api.NewStatusAPI()
d, err = debug.New(api, debug.CLIPort)
backend := api.NewStatusBackend()
d, err = debug.New(backend, debug.CLIPort)
assert.NoError(err)
}
}

3
cmd/statusd/main.go
View File

@ -174,8 +174,7 @@ func main() {
// startDebug starts the debugging API server.
func startDebug(backend *api.StatusBackend) error {
statusAPI := api.NewStatusAPIWithBackend(backend)
_, err := debug.New(statusAPI, *cliPort)
_, err := debug.New(backend, *cliPort)
return err
}

51
lib/library.go
View File

@ -8,6 +8,7 @@ import (
"github.com/NaySoftware/go-fcm"
"github.com/ethereum/go-ethereum/log"
"github.com/status-im/status-go/api"
"github.com/status-im/status-go/logutils"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/profiling"
@ -46,7 +47,7 @@ func StartNode(configJSON *C.char) *C.char {
return makeJSONResponse(err)
}
statusAPI.StartNodeAsync(config)
api.RunAsync(func() error { return statusBackend.StartNode(config) })
return makeJSONResponse(nil)
}
@ -54,7 +55,7 @@ func StartNode(configJSON *C.char) *C.char {
//StopNode - stop status node
//export StopNode
func StopNode() *C.char {
statusAPI.StopNodeAsync()
api.RunAsync(statusBackend.StopNode)
return makeJSONResponse(nil)
}
@ -104,21 +105,21 @@ func ValidateNodeConfig(configJSON *C.char) *C.char {
//ResetChainData remove chain data from data directory
//export ResetChainData
func ResetChainData() *C.char {
statusAPI.ResetChainDataAsync()
api.RunAsync(statusBackend.ResetChainData)
return makeJSONResponse(nil)
}
//CallRPC calls public APIs via RPC
//export CallRPC
func CallRPC(inputJSON *C.char) *C.char {
outputJSON := statusAPI.CallRPC(C.GoString(inputJSON))
outputJSON := statusBackend.CallRPC(C.GoString(inputJSON))
return C.CString(outputJSON)
}
//CallPrivateRPC calls both public and private APIs via RPC
//export CallPrivateRPC
func CallPrivateRPC(inputJSON *C.char) *C.char {
outputJSON := statusAPI.CallPrivateRPC(C.GoString(inputJSON))
outputJSON := statusBackend.CallPrivateRPC(C.GoString(inputJSON))
return C.CString(outputJSON)
}
@ -126,7 +127,7 @@ func CallPrivateRPC(inputJSON *C.char) *C.char {
// just modified to handle the function arg passing
//export CreateAccount
func CreateAccount(password *C.char) *C.char {
address, pubKey, mnemonic, err := statusAPI.CreateAccount(C.GoString(password))
address, pubKey, mnemonic, err := statusBackend.AccountManager().CreateAccount(C.GoString(password))
errString := ""
if err != nil {
@ -147,7 +148,7 @@ func CreateAccount(password *C.char) *C.char {
//CreateChildAccount creates sub-account
//export CreateChildAccount
func CreateChildAccount(parentAddress, password *C.char) *C.char {
address, pubKey, err := statusAPI.CreateChildAccount(C.GoString(parentAddress), C.GoString(password))
address, pubKey, err := statusBackend.AccountManager().CreateChildAccount(C.GoString(parentAddress), C.GoString(password))
errString := ""
if err != nil {
@ -167,7 +168,7 @@ func CreateChildAccount(parentAddress, password *C.char) *C.char {
//RecoverAccount re-creates master key using given details
//export RecoverAccount
func RecoverAccount(password, mnemonic *C.char) *C.char {
address, pubKey, err := statusAPI.RecoverAccount(C.GoString(password), C.GoString(mnemonic))
address, pubKey, err := statusBackend.AccountManager().RecoverAccount(C.GoString(password), C.GoString(mnemonic))
errString := ""
if err != nil {
@ -188,7 +189,7 @@ func RecoverAccount(password, mnemonic *C.char) *C.char {
//VerifyAccountPassword verifies account password
//export VerifyAccountPassword
func VerifyAccountPassword(keyStoreDir, address, password *C.char) *C.char {
_, err := statusAPI.VerifyAccountPassword(C.GoString(keyStoreDir), C.GoString(address), C.GoString(password))
_, err := statusBackend.AccountManager().VerifyAccountPassword(C.GoString(keyStoreDir), C.GoString(address), C.GoString(password))
return makeJSONResponse(err)
}
@ -196,14 +197,14 @@ func VerifyAccountPassword(keyStoreDir, address, password *C.char) *C.char {
// if verified, purges all the previous identities from Whisper, and injects verified key as shh identity
//export Login
func Login(address, password *C.char) *C.char {
err := statusAPI.SelectAccount(C.GoString(address), C.GoString(password))
err := statusBackend.SelectAccount(C.GoString(address), C.GoString(password))
return makeJSONResponse(err)
}
//Logout is equivalent to clearing whisper identities
//export Logout
func Logout() *C.char {
err := statusAPI.Logout()
err := statusBackend.Logout()
return makeJSONResponse(err)
}
@ -212,7 +213,7 @@ func Logout() *C.char {
// transaction.
//export ApproveSignRequestWithArgs
func ApproveSignRequestWithArgs(id, password *C.char, gas, gasPrice C.longlong) *C.char {
result := statusAPI.ApproveSignRequestWithArgs(C.GoString(id), C.GoString(password), int64(gas), int64(gasPrice))
result := statusBackend.ApproveSignRequestWithArgs(C.GoString(id), C.GoString(password), int64(gas), int64(gasPrice))
return prepareApproveSignRequestResponse(result, id)
}
@ -220,7 +221,7 @@ func ApproveSignRequestWithArgs(id, password *C.char, gas, gasPrice C.longlong)
//ApproveSignRequest instructs backend to complete sending of a given transaction.
//export ApproveSignRequest
func ApproveSignRequest(id, password *C.char) *C.char {
result := statusAPI.ApproveSignRequest(C.GoString(id), C.GoString(password))
result := statusBackend.ApproveSignRequest(C.GoString(id), C.GoString(password))
return prepareApproveSignRequestResponse(result, id)
}
@ -265,7 +266,7 @@ func ApproveSignRequests(ids, password *C.char) *C.char {
txIDs[i] = id
}
results := statusAPI.ApproveSignRequests(txIDs, C.GoString(password))
results := statusBackend.ApproveSignRequests(txIDs, C.GoString(password))
for txID, result := range results {
txResult := SignRequestResult{
ID: txID,
@ -290,7 +291,7 @@ func ApproveSignRequests(ids, password *C.char) *C.char {
//DiscardSignRequest discards a given transaction from transaction queue
//export DiscardSignRequest
func DiscardSignRequest(id *C.char) *C.char {
err := statusAPI.DiscardSignRequest(C.GoString(id))
err := statusBackend.DiscardSignRequest(C.GoString(id))
errString := ""
if err != nil {
@ -328,7 +329,7 @@ func DiscardSignRequests(ids *C.char) *C.char {
txIDs[i] = id
}
results := statusAPI.DiscardSignRequests(txIDs)
results := statusBackend.DiscardSignRequests(txIDs)
for txID, err := range results {
out.Results[txID] = DiscardSignRequestResult{
ID: txID,
@ -349,35 +350,35 @@ func DiscardSignRequests(ids *C.char) *C.char {
//InitJail setup initial JavaScript
//export InitJail
func InitJail(js *C.char) {
statusAPI.SetJailBaseJS(C.GoString(js))
statusBackend.JailManager().SetBaseJS(C.GoString(js))
}
//Parse creates a new jail cell context and executes provided JavaScript code.
//DEPRECATED in favour of CreateAndInitCell.
//export Parse
func Parse(chatID *C.char, js *C.char) *C.char {
res := statusAPI.CreateAndInitCell(C.GoString(chatID), C.GoString(js))
res := statusBackend.JailManager().CreateAndInitCell(C.GoString(chatID), C.GoString(js))
return C.CString(res)
}
//CreateAndInitCell creates a new jail cell context and executes provided JavaScript code.
//export CreateAndInitCell
func CreateAndInitCell(chatID *C.char, js *C.char) *C.char {
res := statusAPI.CreateAndInitCell(C.GoString(chatID), C.GoString(js))
res := statusBackend.JailManager().CreateAndInitCell(C.GoString(chatID), C.GoString(js))
return C.CString(res)
}
//ExecuteJS allows to run arbitrary JS code within a cell.
//export ExecuteJS
func ExecuteJS(chatID *C.char, code *C.char) *C.char {
res := statusAPI.JailExecute(C.GoString(chatID), C.GoString(code))
res := statusBackend.JailManager().Execute(C.GoString(chatID), C.GoString(code))
return C.CString(res)
}
//Call executes given JavaScript function
//export Call
func Call(chatID *C.char, path *C.char, params *C.char) *C.char {
res := statusAPI.JailCall(C.GoString(chatID), C.GoString(path), C.GoString(params))
res := statusBackend.JailManager().Call(C.GoString(chatID), C.GoString(path), C.GoString(params))
return C.CString(res)
}
@ -455,7 +456,7 @@ func NotifyUsers(message, payloadJSON, tokensArray *C.char) (outCBytes *C.char)
return
}
err = statusAPI.NotifyUsers(C.GoString(message), payload, tokens...)
err = statusBackend.NotifyUsers(C.GoString(message), payload, tokens...)
if err != nil {
errString = err.Error()
return
@ -467,7 +468,7 @@ func NotifyUsers(message, payloadJSON, tokensArray *C.char) (outCBytes *C.char)
// AddPeer adds an enode as a peer.
//export AddPeer
func AddPeer(enode *C.char) *C.char {
err := statusAPI.StatusNode().AddPeer(C.GoString(enode))
err := statusBackend.StatusNode().AddPeer(C.GoString(enode))
return makeJSONResponse(err)
}
@ -475,11 +476,11 @@ func AddPeer(enode *C.char) *C.char {
// by ReactNative (see https://facebook.github.io/react-native/docs/netinfo.html)
//export ConnectionChange
func ConnectionChange(typ *C.char, expensive C.int) {
statusAPI.ConnectionChange(C.GoString(typ), expensive == 1)
statusBackend.ConnectionChange(C.GoString(typ), expensive == 1)
}
// AppStateChange handles app state changes (background/foreground).
//export AppStateChange
func AppStateChange(state *C.char) {
statusAPI.AppStateChange(C.GoString(state))
statusBackend.AppStateChange(C.GoString(state))
}

66
lib/library_test_utils.go
View File

@ -267,7 +267,7 @@ func testResetChainData(t *testing.T) bool {
return false
}
EnsureNodeSync(statusAPI.StatusNode().EnsureSync)
EnsureNodeSync(statusBackend.StatusNode().EnsureSync)
testCompleteTransaction(t)
return true
@ -275,17 +275,17 @@ func testResetChainData(t *testing.T) bool {
func testStopResumeNode(t *testing.T) bool { //nolint: gocyclo
// to make sure that we start with empty account (which might have gotten populated during previous tests)
if err := statusAPI.Logout(); err != nil {
if err := statusBackend.Logout(); err != nil {
t.Fatal(err)
}
whisperService, err := statusAPI.StatusNode().WhisperService()
whisperService, err := statusBackend.StatusNode().WhisperService()
if err != nil {
t.Errorf("whisper service not running: %v", err)
}
// create an account
address1, pubKey1, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password)
address1, pubKey1, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password)
if err != nil {
t.Errorf("could not create account: %v", err)
return false
@ -366,7 +366,7 @@ func testStopResumeNode(t *testing.T) bool { //nolint: gocyclo
time.Sleep(10 * time.Second) // allow to start (instead of using blocking version of start, of filter event)
// now, verify that we still have account logged in
whisperService, err = statusAPI.StatusNode().WhisperService()
whisperService, err = statusBackend.StatusNode().WhisperService()
if err != nil {
t.Errorf("whisper service not running: %v", err)
}
@ -417,11 +417,11 @@ func testCallPrivateRPCWithPrivateAPI(t *testing.T) bool {
func testCreateChildAccount(t *testing.T) bool { //nolint: gocyclo
// to make sure that we start with empty account (which might get populated during previous tests)
if err := statusAPI.Logout(); err != nil {
if err := statusBackend.Logout(); err != nil {
t.Fatal(err)
}
keyStore, err := statusAPI.StatusNode().AccountKeyStore()
keyStore, err := statusBackend.StatusNode().AccountKeyStore()
if err != nil {
t.Error(err)
return false
@ -475,7 +475,7 @@ func testCreateChildAccount(t *testing.T) bool { //nolint: gocyclo
return false
}
err = statusAPI.SelectAccount(address, TestConfig.Account1.Password)
err = statusBackend.SelectAccount(address, TestConfig.Account1.Password)
if err != nil {
t.Errorf("Test failed: could not select account: %v", err)
return false
@ -552,10 +552,10 @@ func testCreateChildAccount(t *testing.T) bool { //nolint: gocyclo
}
func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo
keyStore, _ := statusAPI.StatusNode().AccountKeyStore()
keyStore, _ := statusBackend.StatusNode().AccountKeyStore()
// create an account
address, pubKey, mnemonic, err := statusAPI.CreateAccount(TestConfig.Account1.Password)
address, pubKey, mnemonic, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password)
if err != nil {
t.Errorf("could not create account: %v", err)
return false
@ -643,7 +643,7 @@ func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo
}
// time to login with recovered data
whisperService, err := statusAPI.StatusNode().WhisperService()
whisperService, err := statusBackend.StatusNode().WhisperService()
if err != nil {
t.Errorf("whisper service not running: %v", err)
}
@ -652,7 +652,7 @@ func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo
if whisperService.HasKeyPair(pubKeyCheck) {
t.Error("identity already present in whisper")
}
err = statusAPI.SelectAccount(addressCheck, TestConfig.Account1.Password)
err = statusBackend.SelectAccount(addressCheck, TestConfig.Account1.Password)
if err != nil {
t.Errorf("Test failed: could not select account: %v", err)
return false
@ -666,20 +666,20 @@ func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo
func testAccountSelect(t *testing.T) bool { //nolint: gocyclo
// test to see if the account was injected in whisper
whisperService, err := statusAPI.StatusNode().WhisperService()
whisperService, err := statusBackend.StatusNode().WhisperService()
if err != nil {
t.Errorf("whisper service not running: %v", err)
}
// create an account
address1, pubKey1, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password)
address1, pubKey1, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password)
if err != nil {
t.Errorf("could not create account: %v", err)
return false
}
t.Logf("Account created: {address: %s, key: %s}", address1, pubKey1)
address2, pubKey2, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password)
address2, pubKey2, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password)
if err != nil {
t.Error("Test failed: could not create account")
return false
@ -749,14 +749,14 @@ func testAccountSelect(t *testing.T) bool { //nolint: gocyclo
}
func testAccountLogout(t *testing.T) bool {
whisperService, err := statusAPI.StatusNode().WhisperService()
whisperService, err := statusBackend.StatusNode().WhisperService()
if err != nil {
t.Errorf("whisper service not running: %v", err)
return false
}
// create an account
address, pubKey, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password)
address, pubKey, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password)
if err != nil {
t.Errorf("could not create account: %v", err)
return false
@ -769,7 +769,7 @@ func testAccountLogout(t *testing.T) bool {
}
// select/login
err = statusAPI.SelectAccount(address, TestConfig.Account1.Password)
err = statusBackend.SelectAccount(address, TestConfig.Account1.Password)
if err != nil {
t.Errorf("Test failed: could not select account: %v", err)
return false
@ -802,12 +802,12 @@ func testAccountLogout(t *testing.T) bool {
}
func testCompleteTransaction(t *testing.T) bool {
signRequests := statusAPI.PendingSignRequests()
signRequests := statusBackend.PendingSignRequests()
EnsureNodeSync(statusAPI.StatusNode().EnsureSync)
EnsureNodeSync(statusBackend.StatusNode().EnsureSync)
// log into account from which transactions will be sent
if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
t.Errorf("cannot select account: %v. Error %q", TestConfig.Account1.Address, err)
return false
}
@ -849,7 +849,7 @@ func testCompleteTransaction(t *testing.T) bool {
})
// this call blocks, up until Complete Transaction is called
txCheckHash, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{
txCheckHash, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{
From: account.FromAddress(TestConfig.Account1.Address),
To: account.ToAddress(TestConfig.Account2.Address),
Value: (*hexutil.Big)(big.NewInt(1000000000000)),
@ -881,10 +881,10 @@ func testCompleteTransaction(t *testing.T) bool {
}
func testCompleteMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyclo
signRequests := statusAPI.PendingSignRequests()
signRequests := statusBackend.PendingSignRequests()
// log into account from which transactions will be sent
if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
t.Errorf("cannot select account: %v", TestConfig.Account1.Address)
return false
}
@ -913,7 +913,7 @@ func testCompleteMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyc
// this call blocks, and should return when DiscardQueuedTransaction() for a given tx id is called
sendTx := func() {
txHashCheck, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{
txHashCheck, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{
From: account.FromAddress(TestConfig.Account1.Address),
To: account.ToAddress(TestConfig.Account2.Address),
Value: (*hexutil.Big)(big.NewInt(1000000000000)),
@ -1013,10 +1013,10 @@ func testCompleteMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyc
}
func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo
signRequests := statusAPI.PendingSignRequests()
signRequests := statusBackend.PendingSignRequests()
// log into account from which transactions will be sent
if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
t.Errorf("cannot select account: %v", TestConfig.Account1.Address)
return false
}
@ -1058,7 +1058,7 @@ func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo
}
// try completing discarded transaction
err := statusAPI.ApproveSignRequest(string(txID), TestConfig.Account1.Password).Error
err := statusBackend.ApproveSignRequest(string(txID), TestConfig.Account1.Password).Error
if err != sign.ErrSignReqNotFound {
t.Error("expects tx not found, but call to CompleteTransaction succeeded")
return
@ -1094,7 +1094,7 @@ func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo
})
// this call blocks, and should return when DiscardQueuedTransaction() is called
txHashCheck, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{
txHashCheck, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{
From: account.FromAddress(TestConfig.Account1.Address),
To: account.ToAddress(TestConfig.Account2.Address),
Value: (*hexutil.Big)(big.NewInt(1000000000000)),
@ -1126,10 +1126,10 @@ func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo
}
func testDiscardMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyclo
signRequests := statusAPI.PendingSignRequests()
signRequests := statusBackend.PendingSignRequests()
// log into account from which transactions will be sent
if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil {
t.Errorf("cannot select account: %v", TestConfig.Account1.Address)
return false
}
@ -1185,7 +1185,7 @@ func testDiscardMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocycl
// this call blocks, and should return when DiscardQueuedTransaction() for a given tx id is called
sendTx := func() {
txHashCheck, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{
txHashCheck, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{
From: account.FromAddress(TestConfig.Account1.Address),
To: account.ToAddress(TestConfig.Account2.Address),
Value: (*hexutil.Big)(big.NewInt(1000000000000)),
@ -1472,7 +1472,7 @@ func startTestNode(t *testing.T) <-chan struct{} {
// sync
if syncRequired {
t.Logf("Sync is required")
EnsureNodeSync(statusAPI.StatusNode().EnsureSync)
EnsureNodeSync(statusBackend.StatusNode().EnsureSync)
} else {
time.Sleep(5 * time.Second)
}

2
lib/main.go
View File

@ -2,7 +2,7 @@ package main
import "github.com/status-im/status-go/api"
var statusAPI = api.NewStatusAPI()
var statusBackend = api.NewStatusBackend()
// Technically this package supposed to be a lib for
// cross-compilation and usage with Android/iOS, but

75
t/e2e/api/api_test.go
View File

@ -9,7 +9,6 @@ import (
"testing"
"time"
"github.com/ethereum/go-ethereum/log"
"github.com/status-im/status-go/api"
"github.com/status-im/status-go/node"
"github.com/status-im/status-go/params"
@ -30,18 +29,18 @@ func TestAPI(t *testing.T) {
type APITestSuite struct {
suite.Suite
api *api.StatusAPI
backend *api.StatusBackend
}
func (s *APITestSuite) ensureNodeStopped() {
if err := s.api.StopNode(); err != node.ErrNoRunningNode && err != nil {
if err := s.backend.StopNode(); err != node.ErrNoRunningNode && err != nil {
s.NoError(err, "unexpected error")
}
}
func (s *APITestSuite) SetupTest() {
s.api = api.NewStatusAPI()
s.NotNil(s.api)
s.backend = api.NewStatusBackend()
s.NotNil(s.backend)
}
func (s *APITestSuite) TestCHTUpdate() {
@ -76,29 +75,25 @@ func (s *APITestSuite) TestRaceConditions() {
var funcsToTest = []func(*params.NodeConfig){
func(config *params.NodeConfig) {
log.Info("StartNodeAsync()")
s.api.StartNodeAsync(config)
s.T().Logf("StartNodeAsync() for network: %d", config.NetworkID)
s.T().Logf("async call to StartNode() for network: %d", config.NetworkID)
api.RunAsync(func() error { return s.backend.StartNode(config) })
progress <- struct{}{}
},
func(config *params.NodeConfig) {
log.Info("StopNodeAsync()")
s.api.StopNodeAsync()
s.T().Logf("StopNodeAsync()")
s.T().Logf("async call to StopNode() for network: %d", config.NetworkID)
api.RunAsync(s.backend.StopNode)
progress <- struct{}{}
},
func(config *params.NodeConfig) {
log.Info("RestartNodeAsync()")
s.api.RestartNodeAsync()
s.T().Logf("RestartNodeAsync()")
s.T().Logf("async call to RestartNode() for network: %d", config.NetworkID)
api.RunAsync(s.backend.RestartNode)
progress <- struct{}{}
},
// TODO(adam): quarantined until it uses a different datadir
// as otherwise it wipes out cached blockchain data.
// func(config *params.NodeConfig) {
// log.Info("ResetChainDataAsync()")
// _, err := s.api.ResetChainDataAsync()
// s.T().Logf("ResetChainDataAsync(), error: %v", err)
// s.T().Logf("async call to ResetChainData() for network: %d", config.NetworkID)
// _, err := s.api.ResetChainData()
// progress <- struct{}{}
// },
}
@ -141,29 +136,29 @@ func (s *APITestSuite) TestCellsRemovedAfterSwitchAccount() {
config, err := MakeTestNodeConfig(GetNetworkID())
require.NoError(err)
err = s.api.StartNode(config)
err = s.backend.StartNode(config)
require.NoError(err)
defer s.api.StopNode() //nolint: errcheck
defer s.backend.StopNode() //nolint: errcheck
address1, _, _, err := s.api.AccountManager().CreateAccount(TestConfig.Account1.Password)
address1, _, _, err := s.backend.AccountManager().CreateAccount(TestConfig.Account1.Password)
require.NoError(err)
address2, _, _, err := s.api.AccountManager().CreateAccount(TestConfig.Account2.Password)
address2, _, _, err := s.backend.AccountManager().CreateAccount(TestConfig.Account2.Password)
require.NoError(err)
err = s.api.SelectAccount(address1, TestConfig.Account1.Password)
err = s.backend.SelectAccount(address1, TestConfig.Account1.Password)
require.NoError(err)
for i := 0; i < itersCount; i++ {
_, e := s.api.JailManager().CreateCell(getChatID(i))
_, e := s.backend.JailManager().CreateCell(getChatID(i))
require.NoError(e)
}
err = s.api.SelectAccount(address2, TestConfig.Account2.Password)
err = s.backend.SelectAccount(address2, TestConfig.Account2.Password)
require.NoError(err)
for i := 0; i < itersCount; i++ {
_, e := s.api.JailManager().Cell(getChatID(i))
_, e := s.backend.JailManager().Cell(getChatID(i))
require.Error(e)
}
}
@ -178,22 +173,22 @@ func (s *APITestSuite) TestLogoutRemovesCells() {
config, err := MakeTestNodeConfig(GetNetworkID())
require.NoError(err)
err = s.api.StartNode(config)
err = s.backend.StartNode(config)
require.NoError(err)
defer s.api.StopNode() //nolint: errcheck
defer s.backend.StopNode() //nolint: errcheck
address1, _, _, err := s.api.AccountManager().CreateAccount(TestConfig.Account1.Password)
address1, _, _, err := s.backend.AccountManager().CreateAccount(TestConfig.Account1.Password)
require.NoError(err)
err = s.api.SelectAccount(address1, TestConfig.Account1.Password)
err = s.backend.SelectAccount(address1, TestConfig.Account1.Password)
require.NoError(err)
s.api.JailManager().CreateAndInitCell(testChatID)
s.backend.JailManager().CreateAndInitCell(testChatID)
err = s.api.Logout()
err = s.backend.Logout()
require.NoError(err)
_, err = s.api.JailManager().Cell(testChatID)
_, err = s.backend.JailManager().Cell(testChatID)
require.Error(err, "Expected that cells was removed")
}
@ -216,14 +211,14 @@ func (s *APITestSuite) TestEventsNodeStartStop() {
nodeConfig, err := MakeTestNodeConfig(GetNetworkID())
s.NoError(err)
s.NoError(s.api.StartNode(nodeConfig))
s.NoError(s.api.StopNode())
s.NoError(s.backend.StartNode(nodeConfig))
s.NoError(s.backend.StopNode())
s.verifyEnvelopes(envelopes, signal.EventNodeStarted, signal.EventNodeReady, signal.EventNodeStopped)
s.NoError(s.api.StartNode(nodeConfig))
s.NoError(s.backend.StartNode(nodeConfig))
s.verifyEnvelopes(envelopes, signal.EventNodeStarted, signal.EventNodeReady)
s.NoError(s.api.RestartNode())
s.NoError(s.backend.RestartNode())
s.verifyEnvelopes(envelopes, signal.EventNodeStopped, signal.EventNodeStarted, signal.EventNodeReady)
s.NoError(s.api.StopNode())
s.NoError(s.backend.StopNode())
s.verifyEnvelopes(envelopes, signal.EventNodeStopped)
}
@ -266,7 +261,7 @@ func (s *APITestSuite) TestNodeStartCrash() {
s.NoError(err)
// now try starting using node manager, it should fail (error is irrelevant as it is implementation detail)
s.Error(<-s.api.StartNodeAsync(nodeConfig))
s.Error(<-api.RunAsync(func() error { return s.backend.StartNode(nodeConfig) }))
select {
case <-time.After(500 * time.Millisecond):
@ -277,7 +272,7 @@ func (s *APITestSuite) TestNodeStartCrash() {
// stop outside node, and re-try
s.NoError(outsideNode.Stop())
signalReceived = make(chan struct{})
s.NoError(<-s.api.StartNodeAsync(nodeConfig))
s.NoError(<-api.RunAsync(func() error { return s.backend.StartNode(nodeConfig) }))
select {
case <-time.After(500 * time.Millisecond):
@ -286,5 +281,5 @@ func (s *APITestSuite) TestNodeStartCrash() {
}
// cleanup
s.NoError(s.api.StopNode())
s.NoError(s.backend.StopNode())
}