Source code for graphenecommon.aio.wallet

# -*- coding: utf-8 -*-
import logging

from graphenecommon.exceptions import KeyNotFound
from ..wallet import Wallet as SyncWallet


log = logging.getLogger(__name__)


class Wallet(SyncWallet):
    """The wallet is meant to maintain access to private keys for
    your accounts. It either uses manually provided private keys
    or uses a SQLite database managed by storage.py.

    :param array,dict,string keys: Predefine the wif keys to shortcut the
           wallet database

    .. note:: Wallet should be instantiated synchroously e.g.

    .. code-block:: python

        w = Wallet()

    Three wallet operation modes are possible:

    * **Wallet Database**: Here, the library loads the keys from the
      locally stored wallet SQLite database (see ``storage.py``).
    * **Providing Keys**: Here, you can provide the keys for
      your accounts manually. All you need to do is add the wif
      keys for the accounts you want to use as a simple array
      using the ``keys`` parameter to your blockchain instance.
    * **Force keys**: This more is for advanced users and
      requires that you know what you are doing. Here, the
      ``keys`` parameter is a dictionary that overwrite the
      ``active``, ``owner``, ``posting`` or ``memo`` keys for
      any account. This mode is only used for *foreign*
      signatures!
    """

    async def getOwnerKeyForAccount(self, name):
        """Obtain owner Private Key for an account from the wallet database"""
        account = await self.rpc.get_account(name)
        for authority in account["owner"]["key_auths"]:
            key = self.getPrivateKeyForPublicKey(authority[0])
            if key:
                return key
        raise KeyNotFound

    async def getMemoKeyForAccount(self, name):
        """Obtain owner Memo Key for an account from the wallet database"""
        account = await self.rpc.get_account(name)
        key = self.getPrivateKeyForPublicKey(account["options"]["memo_key"])
        if key:
            return key
        return False

    async def getActiveKeyForAccount(self, name):
        """Obtain owner Active Key for an account from the wallet database"""
        account = await self.rpc.get_account(name)
        for authority in account["active"]["key_auths"]:
            try:
                return self.getPrivateKeyForPublicKey(authority[0])
            except Exception:
                pass
        return False

    async def getAccountsFromPublicKey(self, pub):
        """Obtain all accounts associated with a public key"""
        result = await self.rpc.get_key_references([str(pub)])
        names = result[0]
        return names

    async def getAccountFromPublicKey(self, pub):
        """Obtain the first account name from public key"""
        # FIXME, this only returns the first associated key.
        # If the key is used by multiple accounts, this
        # will surely lead to undesired behavior
        names = list(await self.getAccountsFromPublicKey(str(pub)))
        if names:
            return names[0]

    async def getAccounts(self):
        """Return all accounts installed in the wallet database"""
        pubkeys = self.getPublicKeys()
        accounts = []
        for pubkey in pubkeys:
            # Filter those keys not for our network
            if pubkey[: len(self.prefix)] == self.prefix:
                accounts.extend(await self.getAccountsFromPublicKey(pubkey))
        return accounts