375 lines
11 KiB
Go
375 lines
11 KiB
Go
package accounts
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/status-im/status-go/account"
|
|
"github.com/status-im/status-go/eth-node/types"
|
|
"github.com/status-im/status-go/multiaccounts/accounts"
|
|
"github.com/status-im/status-go/multiaccounts/keycards"
|
|
"github.com/status-im/status-go/params"
|
|
"github.com/status-im/status-go/protocol"
|
|
)
|
|
|
|
func NewAccountsAPI(manager *account.GethManager, config *params.NodeConfig, db *accounts.Database, feed *event.Feed, messenger **protocol.Messenger) *API {
|
|
return &API{manager, config, db, feed, messenger}
|
|
}
|
|
|
|
// API is class with methods available over RPC.
|
|
type API struct {
|
|
manager *account.GethManager
|
|
config *params.NodeConfig
|
|
db *accounts.Database
|
|
feed *event.Feed
|
|
messenger **protocol.Messenger
|
|
}
|
|
|
|
type DerivedAddress struct {
|
|
Address common.Address `json:"address"`
|
|
Path string `json:"path"`
|
|
HasActivity bool `json:"hasActivity"`
|
|
AlreadyCreated bool `json:"alreadyCreated"`
|
|
}
|
|
|
|
func (api *API) SaveAccount(ctx context.Context, account *accounts.Account) error {
|
|
log.Info("[AccountsAPI::SaveAccount]")
|
|
err := (*api.messenger).SaveAccount(account)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
api.feed.Send([]*accounts.Account{account})
|
|
return nil
|
|
}
|
|
|
|
func (api *API) checkDerivedFromField(accounts []*accounts.Account) ([]*accounts.Account, error) {
|
|
for i := range accounts {
|
|
account := accounts[i]
|
|
if account.Wallet && account.DerivedFrom == "" {
|
|
address, err := api.db.GetWalletRootAddress()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
account.DerivedFrom = address.Hex()
|
|
}
|
|
}
|
|
return accounts, nil
|
|
}
|
|
|
|
func (api *API) GetAccounts(ctx context.Context) ([]*accounts.Account, error) {
|
|
accounts, err := api.db.GetAccounts()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return api.checkDerivedFromField(accounts)
|
|
}
|
|
|
|
func (api *API) GetAccountsByKeyUID(ctx context.Context, keyUID string) ([]*accounts.Account, error) {
|
|
accounts, err := api.db.GetAccountsByKeyUID(keyUID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return api.checkDerivedFromField(accounts)
|
|
}
|
|
|
|
func (api *API) DeleteAccount(ctx context.Context, address types.Address) error {
|
|
acc, err := api.db.GetAccountByAddress(address)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
allAccountsOfKeypairWithKeyUID, err := api.db.GetAccountsByKeyUID(acc.KeyUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
lastAcccountOfKeypairWithTheSameKey := len(allAccountsOfKeypairWithKeyUID) == 1
|
|
|
|
if acc.Type != accounts.AccountTypeWatch {
|
|
knownKeycardsForKeyUID, err := api.db.GetKeycardByKeyUID(acc.KeyUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(knownKeycardsForKeyUID) == 0 {
|
|
err = api.manager.DeleteAccount(address)
|
|
var e *account.ErrCannotLocateKeyFile
|
|
if err != nil && !errors.As(err, &e) {
|
|
return err
|
|
}
|
|
|
|
if acc.Type != accounts.AccountTypeKey {
|
|
if lastAcccountOfKeypairWithTheSameKey {
|
|
err = api.manager.DeleteAccount(types.Address(common.HexToAddress(acc.DerivedFrom)))
|
|
var e *account.ErrCannotLocateKeyFile
|
|
if err != nil && !errors.As(err, &e) {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if lastAcccountOfKeypairWithTheSameKey {
|
|
knownKeycards, err := api.db.GetAllKnownKeycards()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, kc := range knownKeycards {
|
|
if kc.KeyUID == acc.KeyUID {
|
|
clock := uint64(time.Now().Unix())
|
|
err = (*api.messenger).RemoveMigratedAccountsForKeycard(ctx, kc.KeycardUID, kc.AccountsAddresses, clock)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (*api.messenger).DeleteAccount(address)
|
|
}
|
|
|
|
func (api *API) AddAccount(ctx context.Context, password string, account *accounts.Account) error {
|
|
if len(account.Address) == 0 {
|
|
return errors.New("`Address` field must be set")
|
|
}
|
|
|
|
if account.Wallet || account.Chat {
|
|
return errors.New("default wallet and chat account cannot be added this way")
|
|
}
|
|
|
|
if len(account.Name) == 0 {
|
|
return errors.New("`Name` field must be set")
|
|
}
|
|
|
|
if len(account.Emoji) == 0 {
|
|
return errors.New("`Emoji` field must be set")
|
|
}
|
|
|
|
if len(account.Color) == 0 {
|
|
return errors.New("`Color` field must be set")
|
|
}
|
|
|
|
if account.Type != accounts.AccountTypeWatch {
|
|
|
|
if len(account.KeyUID) == 0 {
|
|
return errors.New("`KeyUID` field must be set")
|
|
}
|
|
|
|
if len(account.PublicKey) == 0 {
|
|
return errors.New("`PublicKey` field must be set")
|
|
}
|
|
|
|
if len(account.KeypairName) == 0 {
|
|
return errors.New("`KeypairName` field must be set")
|
|
}
|
|
|
|
if account.Type != accounts.AccountTypeKey {
|
|
if len(account.DerivedFrom) == 0 {
|
|
return errors.New("`DerivedFrom` field must be set")
|
|
}
|
|
|
|
if len(account.Path) == 0 {
|
|
return errors.New("`Path` field must be set")
|
|
}
|
|
}
|
|
}
|
|
|
|
addressExists, err := api.db.AddressExists(account.Address)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if addressExists {
|
|
return errors.New("account already exists")
|
|
}
|
|
|
|
// we need to create local keystore file only if password is provided and the account is being added is of
|
|
// "generated" or "seed" type.
|
|
if (account.Type == accounts.AccountTypeGenerated || account.Type == accounts.AccountTypeSeed) && len(password) > 0 {
|
|
info, err := api.manager.AccountsGenerator().LoadAccount(account.DerivedFrom, password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = api.manager.AccountsGenerator().StoreDerivedAccounts(info.ID, password, []string{account.Path})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return api.SaveAccount(ctx, account)
|
|
}
|
|
|
|
// Imports a new private key and creates local keystore file.
|
|
func (api *API) ImportPrivateKey(ctx context.Context, privateKey string, password string) error {
|
|
info, err := api.manager.AccountsGenerator().ImportPrivateKey(privateKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
accs, err := api.db.GetAccountsByKeyUID(info.KeyUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(accs) > 0 {
|
|
return errors.New("provided private key was already imported")
|
|
}
|
|
|
|
_, err = api.manager.AccountsGenerator().StoreAccount(info.ID, password)
|
|
return err
|
|
}
|
|
|
|
// Imports a new mnemonic and creates local keystore file.
|
|
func (api *API) ImportMnemonic(ctx context.Context, mnemonic string, password string) error {
|
|
mnemonicNoExtraSpaces := strings.Join(strings.Fields(mnemonic), " ")
|
|
|
|
generatedAccountInfo, err := api.manager.AccountsGenerator().ImportMnemonic(mnemonicNoExtraSpaces, "")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
accs, err := api.db.GetAccountsByKeyUID(generatedAccountInfo.KeyUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(accs) > 0 {
|
|
return errors.New("provided mnemonic was already imported, to add new account use `AddAccount` endpoint")
|
|
}
|
|
|
|
_, err = api.manager.AccountsGenerator().StoreAccount(generatedAccountInfo.ID, password)
|
|
return err
|
|
}
|
|
|
|
// Creates a random new mnemonic.
|
|
func (api *API) GetRandomMnemonic(ctx context.Context) (string, error) {
|
|
return api.manager.GetRandomMnemonic()
|
|
}
|
|
|
|
func (api *API) VerifyKeystoreFileForAccount(address types.Address, password string) bool {
|
|
_, err := api.manager.VerifyAccountPassword(api.config.KeyStoreDir, address.Hex(), password)
|
|
return err == nil
|
|
}
|
|
|
|
func (api *API) VerifyPassword(password string) bool {
|
|
address, err := api.db.GetChatAddress()
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return api.VerifyKeystoreFileForAccount(address, password)
|
|
}
|
|
|
|
func (api *API) AddKeycardOrAddAccountsIfKeycardIsAdded(ctx context.Context, kcUID string, kpName string, keyUID string, accountAddresses []string) error {
|
|
if len(accountAddresses) == 0 {
|
|
return errors.New("cannot migrate a keypair without any address")
|
|
}
|
|
|
|
acc, err := api.db.GetAccountByAddress(types.Address(common.HexToAddress(accountAddresses[0])))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(acc.DerivedFrom) == 0 {
|
|
return errors.New("an account being migrated doesn't contain `derived_from` field set")
|
|
}
|
|
|
|
kp := keycards.Keycard{
|
|
KeycardUID: kcUID,
|
|
KeycardName: kpName,
|
|
KeycardLocked: false,
|
|
KeyUID: keyUID,
|
|
LastUpdateClock: uint64(time.Now().Unix()),
|
|
}
|
|
for _, addr := range accountAddresses {
|
|
kp.AccountsAddresses = append(kp.AccountsAddresses, types.Address(common.HexToAddress(addr)))
|
|
}
|
|
|
|
knownKeycardsForKeyUID, err := api.db.GetKeycardByKeyUID(keyUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
added, err := (*api.messenger).AddKeycardOrAddAccountsIfKeycardIsAdded(ctx, &kp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Once we migrate a keypair, corresponding keystore files need to be deleted
|
|
// if the keypair being migrated is not already migrated (in case user is creating a copy of an existing Keycard)
|
|
if added && len(knownKeycardsForKeyUID) == 0 && acc.Type != accounts.AccountTypeWatch {
|
|
for _, addr := range kp.AccountsAddresses {
|
|
err = api.manager.DeleteAccount(addr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
err = api.manager.DeleteAccount(types.Address(common.HexToAddress(acc.DerivedFrom)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (api *API) RemoveMigratedAccountsForKeycard(ctx context.Context, kcUID string, accountAddresses []string) error {
|
|
clock := uint64(time.Now().Unix())
|
|
var addresses []types.Address
|
|
for _, addr := range accountAddresses {
|
|
addresses = append(addresses, types.HexToAddress(addr))
|
|
}
|
|
return (*api.messenger).RemoveMigratedAccountsForKeycard(ctx, kcUID, addresses, clock)
|
|
}
|
|
|
|
func (api *API) GetAllKnownKeycards(ctx context.Context) ([]*keycards.Keycard, error) {
|
|
return api.db.GetAllKnownKeycards()
|
|
}
|
|
|
|
func (api *API) GetAllKnownKeycardsGroupedByKeyUID(ctx context.Context) ([]*keycards.Keycard, error) {
|
|
return api.db.GetAllKnownKeycardsGroupedByKeyUID()
|
|
}
|
|
|
|
func (api *API) GetKeycardByKeyUID(ctx context.Context, keyUID string) ([]*keycards.Keycard, error) {
|
|
return api.db.GetKeycardByKeyUID(keyUID)
|
|
}
|
|
|
|
func (api *API) SetKeycardName(ctx context.Context, kcUID string, kpName string) error {
|
|
clock := uint64(time.Now().Unix())
|
|
return (*api.messenger).SetKeycardName(ctx, kcUID, kpName, clock)
|
|
}
|
|
|
|
func (api *API) KeycardLocked(ctx context.Context, kcUID string) error {
|
|
clock := uint64(time.Now().Unix())
|
|
return (*api.messenger).KeycardLocked(ctx, kcUID, clock)
|
|
}
|
|
|
|
func (api *API) KeycardUnlocked(ctx context.Context, kcUID string) error {
|
|
clock := uint64(time.Now().Unix())
|
|
return (*api.messenger).KeycardUnlocked(ctx, kcUID, clock)
|
|
}
|
|
|
|
func (api *API) DeleteKeycard(ctx context.Context, kcUID string) error {
|
|
clock := uint64(time.Now().Unix())
|
|
return (*api.messenger).DeleteKeycard(ctx, kcUID, clock)
|
|
}
|
|
|
|
func (api *API) DeleteAllKeycardsWithKeyUID(ctx context.Context, keyUID string) error {
|
|
return api.db.DeleteAllKeycardsWithKeyUID(keyUID)
|
|
}
|
|
|
|
func (api *API) UpdateKeycardUID(ctx context.Context, oldKcUID string, newKcUID string) error {
|
|
clock := uint64(time.Now().Unix())
|
|
return (*api.messenger).UpdateKeycardUID(ctx, oldKcUID, newKcUID, clock)
|
|
}
|