hive-nectar 0.0.2__py3-none-any.whl

nectar/transactionbuilder.py

@@ -0,0 +1,622 @@
+# -*- coding: utf-8 -*-
+import logging
+import struct
+from binascii import unhexlify
+
+# import time (not currently used)
+from datetime import timedelta
+
+from nectar.instance import shared_blockchain_instance
+from nectarbase import operations  # removed deprecated transactions module
+from nectarbase.ledgertransactions import Ledger_Transaction
+from nectarbase.objects import Operation
+from nectarbase.signedtransactions import Signed_Transaction
+from nectargraphenebase.account import PrivateKey, PublicKey
+from nectarstorage.exceptions import WalletLocked
+
+from .account import Account
+from .exceptions import (
+    InsufficientAuthorityError,
+    InvalidWifError,
+    MissingKeyError,
+    OfflineHasNoRPCException,
+)
+from .utils import formatTimeFromNow, formatTimeString
+
+log = logging.getLogger(__name__)
+
+
+class TransactionBuilder(dict):
+    """This class simplifies the creation of transactions by adding
+    operations and signers.
+    To build your own transactions and sign them
+
+    :param dict tx: transaction (Optional). If not set, the new transaction is created.
+    :param int expiration: Delay in seconds until transactions are supposed
+        to expire *(optional)* (default is 30)
+    :param Hive/Steem blockchain_instance: If not set, shared_blockchain_instance() is used
+
+    .. testcode::
+
+       from nectar.transactionbuilder import TransactionBuilder
+       from nectarbase.operations import Transfer
+       from nectar import Hive
+       wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"
+       hive = Hive(nobroadcast=True, keys={'active': wif})
+       tx = TransactionBuilder(blockchain_instance=hive)
+       transfer = {"from": "test", "to": "test1", "amount": "1 HIVE", "memo": ""}
+       tx.appendOps(Transfer(transfer))
+       tx.appendSigner("test", "active") # or tx.appendWif(wif)
+       signed_tx = tx.sign()
+       broadcast_tx = tx.broadcast()
+
+    """
+
+    def __init__(self, tx={}, blockchain_instance=None, **kwargs):
+        if blockchain_instance is None:
+            if kwargs.get("steem_instance"):
+                blockchain_instance = kwargs["steem_instance"]
+            elif kwargs.get("hive_instance"):
+                blockchain_instance = kwargs["hive_instance"]
+        self.blockchain = blockchain_instance or shared_blockchain_instance()
+        self.clear()
+        if tx and isinstance(tx, dict):
+            super(TransactionBuilder, self).__init__(tx)
+            # Load operations
+            self.ops = tx["operations"]
+            self._require_reconstruction = False
+        else:
+            self._require_reconstruction = True
+        self._use_ledger = self.blockchain.use_ledger
+        self.path = self.blockchain.path
+        self._use_condenser_api = bool(self.blockchain.config["use_condenser"])
+        self.set_expiration(kwargs.get("expiration", self.blockchain.expiration))
+
+    def set_expiration(self, p):
+        """Set expiration date"""
+        self.expiration = p
+
+    def is_empty(self):
+        """Check if ops is empty"""
+        return not (len(self.ops) > 0)
+
+    def list_operations(self):
+        """List all ops"""
+        if self.blockchain.is_connected() and self.blockchain.rpc.get_use_appbase():
+            # appbase disabled by now
+            appbase = not self._use_condenser_api
+        else:
+            appbase = False
+        return [Operation(o, appbase=appbase, prefix=self.blockchain.prefix) for o in self.ops]
+
+    def _is_signed(self):
+        """Check if signatures exists"""
+        return "signatures" in self and bool(self["signatures"])
+
+    def _is_constructed(self):
+        """Check if tx is already constructed"""
+        return "expiration" in self and bool(self["expiration"])
+
+    def _is_require_reconstruction(self):
+        return self._require_reconstruction
+
+    def _set_require_reconstruction(self):
+        self._require_reconstruction = True
+
+    def _unset_require_reconstruction(self):
+        self._require_reconstruction = False
+
+    def _get_auth_field(self, permission):
+        return permission
+
+    def __repr__(self):
+        return "<Transaction num_ops={}, ops={}>".format(
+            len(self.ops), [op.__class__.__name__ for op in self.ops]
+        )
+
+    def __str__(self):
+        return str(self.json())
+
+    def __getitem__(self, key):
+        if key not in self:
+            self.constructTx()
+        return dict(self).__getitem__(key)
+
+    def get_parent(self):
+        """TransactionBuilders don't have parents, they are their own parent"""
+        return self
+
+    def json(self, with_prefix=False):
+        """Show the transaction as plain json"""
+        if not self._is_constructed() or self._is_require_reconstruction():
+            self.constructTx()
+        json_dict = dict(self)
+        if with_prefix:
+            json_dict["prefix"] = self.blockchain.prefix
+        return json_dict
+
+    def appendOps(self, ops, append_to=None):
+        """Append op(s) to the transaction builder
+
+        :param list ops: One or a list of operations
+        """
+        if isinstance(ops, list):
+            self.ops.extend(ops)
+        else:
+            self.ops.append(ops)
+        self._set_require_reconstruction()
+
+    def _fetchkeys(self, account, perm, level=0, required_treshold=1):
+        # Do not travel recursion more than 2 levels
+        if level > 2:
+            return []
+
+        r = []
+        wif = None
+        # Let's go through all *keys* of the account
+        for authority in account[perm]["key_auths"]:
+            try:
+                # Try obtain the private key from wallet
+                wif = self.blockchain.wallet.getPrivateKeyForPublicKey(authority[0])
+            except ValueError:
+                pass
+            except MissingKeyError:
+                pass
+
+            if wif:
+                r.append([wif, authority[1]])
+                # If we found a key for account, we add it
+                # to signing_accounts to be sure we do not resign
+                # another operation with the same account/wif
+                self.signing_accounts.append(account)
+
+            # Test if we reached threshold already
+            if sum([x[1] for x in r]) >= required_treshold:
+                break
+
+        # Let's see if we still need to go through accounts
+        if sum([x[1] for x in r]) < required_treshold:
+            # go one level deeper
+            for authority in account[perm]["account_auths"]:
+                # Let's see if we can find keys for an account in
+                # account_auths
+                # This is recursive with a limit at level 2 (see above)
+                auth_account = Account(authority[0], blockchain_instance=self.blockchain)
+                required_treshold = auth_account[perm]["weight_threshold"]
+                keys = self._fetchkeys(auth_account, perm, level + 1, required_treshold)
+
+                for key in keys:
+                    r.append(key)
+
+                    # Test if we reached threshold already and break
+                    if sum([x[1] for x in r]) >= required_treshold:
+                        break
+
+        return r
+
+    def appendSigner(self, account, permission):
+        """Try to obtain the wif key from the wallet by telling which account
+        and permission is supposed to sign the transaction
+        It is possible to add more than one signer.
+
+        :param str account: account to sign transaction with
+        :param str permission: type of permission, e.g. "active", "owner" etc
+        """
+        if not self.blockchain.is_connected():
+            return
+        if permission not in ["active", "owner", "posting"]:
+            raise AssertionError("Invalid permission")
+        account = Account(account, blockchain_instance=self.blockchain)
+        auth_field = self._get_auth_field(permission)
+        if auth_field not in account:
+            account = Account(account, blockchain_instance=self.blockchain, lazy=False, full=True)
+            account.clear_cache()
+            account.refresh()
+        if auth_field not in account:
+            account = Account(account, blockchain_instance=self.blockchain)
+        if auth_field not in account:
+            raise AssertionError("Could not access permission")
+
+        if self._use_ledger:
+            if not self._is_constructed() or self._is_require_reconstruction():
+                self.constructTx()
+
+            key_found = False
+            if self.path is not None:
+                current_pubkey = self.ledgertx.get_pubkey(self.path)
+                for authority in account[auth_field]["key_auths"]:
+                    if str(current_pubkey) == authority[0]:
+                        key_found = True
+                if permission == "posting" and not key_found:
+                    for authority in account["active"]["key_auths"]:
+                        if str(current_pubkey) == authority[0]:
+                            key_found = True
+                if not key_found:
+                    for authority in account["owner"]["key_auths"]:
+                        if str(current_pubkey) == authority[0]:
+                            key_found = True
+            if not key_found:
+                raise AssertionError(
+                    "Could not find pubkey from %s in path: %s!" % (account["name"], self.path)
+                )
+            return
+
+        if self.blockchain.wallet.locked():
+            raise WalletLocked()
+        if self.blockchain.use_sc2 and self.blockchain.steemconnect is not None:
+            self.blockchain.steemconnect.set_username(account["name"], permission)
+            return
+
+        if account["name"] not in self.signing_accounts:
+            # is the account an instance of public key?
+            if isinstance(account, PublicKey):
+                self.wifs.add(self.blockchain.wallet.getPrivateKeyForPublicKey(str(account)))
+            else:
+                if auth_field not in account:
+                    raise AssertionError("Could not access permission")
+                required_treshold = account[auth_field]["weight_threshold"]
+                keys = self._fetchkeys(account, permission, required_treshold=required_treshold)
+                # If keys are empty, try again with active key
+                if not keys and permission == "posting":
+                    _keys = self._fetchkeys(account, "active", required_treshold=required_treshold)
+                    keys.extend(_keys)
+                # If keys are empty, try again with owner key
+                if not keys and permission != "owner":
+                    _keys = self._fetchkeys(account, "owner", required_treshold=required_treshold)
+                    keys.extend(_keys)
+                for x in keys:
+                    self.appendWif(x[0])
+
+            self.signing_accounts.append(account["name"])
+
+    def appendWif(self, wif):
+        """Add a wif that should be used for signing of the transaction.
+
+        :param string wif: One wif key to use for signing
+            a transaction.
+        """
+        if wif:
+            try:
+                PrivateKey(wif, prefix=self.blockchain.prefix)
+                self.wifs.add(wif)
+            except:
+                raise InvalidWifError
+
+    def clearWifs(self):
+        """Clear all stored wifs"""
+        self.wifs = set()
+
+    def setPath(self, path):
+        self.path = path
+
+    def searchPath(self, account, perm):
+        if not self.blockchain.use_ledger:
+            return
+        if not self._is_constructed() or self._is_require_reconstruction():
+            self.constructTx()
+        key_found = False
+        path = None
+        current_account_index = 0
+        current_key_index = 0
+        while not key_found and current_account_index < 5:
+            path = self.ledgertx.build_path(perm, current_account_index, current_key_index)
+            current_pubkey = self.ledgertx.get_pubkey(path)
+            key_found = False
+            for authority in account[perm]["key_auths"]:
+                if str(current_pubkey) == authority[1]:
+                    key_found = True
+            if not key_found and current_key_index < 5:
+                current_key_index += 1
+            elif not key_found and current_key_index >= 5:
+                current_key_index = 0
+                current_account_index += 1
+        if not key_found:
+            return None
+        else:
+            return path
+
+    def constructTx(self, ref_block_num=None, ref_block_prefix=None):
+        """Construct the actual transaction and store it in the class's dict
+        store
+
+        """
+        ops = list()
+        if self.blockchain.is_connected() and self.blockchain.rpc.get_use_appbase():
+            # appbase disabled by now
+            # broadcasting does not work at the moment
+            appbase = not self._use_condenser_api
+        else:
+            appbase = False
+        for op in self.ops:
+            # otherwise, we simply wrap ops into Operations
+            ops.extend([Operation(op, appbase=appbase, prefix=self.blockchain.prefix)])
+
+        # calculation expiration time from last block time not system time
+        # it fixes transaction expiration error when pushing transactions
+        # when blocks are moved forward with debug_produce_block*
+        if self.blockchain.is_connected():
+            now = formatTimeString(
+                self.blockchain.get_dynamic_global_properties(use_stored_data=False).get("time")
+            ).replace(tzinfo=None)
+            expiration = now + timedelta(seconds=int(self.expiration or self.blockchain.expiration))
+            expiration = expiration.replace(microsecond=0).isoformat()
+        else:
+            expiration = formatTimeFromNow(self.expiration or self.blockchain.expiration)
+
+        # We now wrap everything into an actual transaction
+        if ref_block_num is None or ref_block_prefix is None:
+            ref_block_num, ref_block_prefix = self.get_block_params()
+        if self._use_ledger:
+            self.ledgertx = Ledger_Transaction(
+                ref_block_prefix=ref_block_prefix,
+                expiration=expiration,
+                operations=ops,
+                ref_block_num=ref_block_num,
+                custom_chains=self.blockchain.custom_chains,
+                prefix=self.blockchain.prefix,
+            )
+
+        self.tx = Signed_Transaction(
+            ref_block_prefix=ref_block_prefix,
+            expiration=expiration,
+            operations=ops,
+            ref_block_num=ref_block_num,
+            custom_chains=self.blockchain.custom_chains,
+            prefix=self.blockchain.prefix,
+        )
+
+        super(TransactionBuilder, self).update(self.tx.json())
+        self._unset_require_reconstruction()
+
+    def get_block_params(self, use_head_block=False):
+        """Auxiliary method to obtain ``ref_block_num`` and
+        ``ref_block_prefix``. Requires a connection to a
+        node!
+        """
+
+        dynBCParams = self.blockchain.get_dynamic_global_properties(use_stored_data=False)
+        # fix for corner case where last_irreversible_block_num == head_block_number
+        # then int(dynBCParams["last_irreversible_block_num"]) + 1 does not exists
+        # and BlockHeader throws error
+        if use_head_block or int(dynBCParams["last_irreversible_block_num"]) == int(
+            dynBCParams["head_block_number"]
+        ):
+            ref_block_num = dynBCParams["head_block_number"] & 0xFFFF
+            ref_block_prefix = struct.unpack_from("<I", unhexlify(dynBCParams["head_block_id"]), 4)[
+                0
+            ]
+        else:
+            # need to get subsequent block because block head doesn't return 'id' - stupid
+            from .block import BlockHeader
+
+            block = BlockHeader(
+                int(dynBCParams["last_irreversible_block_num"]) + 1,
+                blockchain_instance=self.blockchain,
+            )
+            ref_block_num = dynBCParams["last_irreversible_block_num"] & 0xFFFF
+            ref_block_prefix = struct.unpack_from("<I", unhexlify(block["previous"]), 4)[0]
+        return ref_block_num, ref_block_prefix
+
+    def sign(self, reconstruct_tx=True):
+        """Sign a provided transaction with the provided key(s)
+        One or many wif keys to use for signing a transaction.
+        The wif keys can be provided by "appendWif" or the
+        signer can be defined "appendSigner". The wif keys
+        from all signer that are defined by "appendSigner
+        will be loaded from the wallet.
+
+        :param bool reconstruct_tx: when set to False and tx
+            is already contructed, it will not reconstructed
+            and already added signatures remain
+
+        """
+        if not self._is_constructed() or (self._is_constructed() and reconstruct_tx):
+            self.constructTx()
+        if "operations" not in self or not self["operations"]:
+            return
+        if self.blockchain.use_sc2:
+            return
+        # We need to set the default prefix, otherwise pubkeys are
+        # presented wrongly!
+        if self.blockchain.rpc is not None:
+            operations.default_prefix = self.blockchain.chain_params["prefix"]
+        elif "blockchain" in self:
+            operations.default_prefix = self["blockchain"]["prefix"]
+
+        if self._use_ledger:
+            # try:
+            #    ledgertx = Ledger_Transaction(**self.json(with_prefix=True))
+            #    ledgertx.add_custom_chains(self.blockchain.custom_chains)
+            # except:
+            #    raise ValueError("Invalid TransactionBuilder Format")
+            # ledgertx.sign(self.path, chain=self.blockchain.chain_params)
+            self.ledgertx.sign(self.path, chain=self.blockchain.chain_params)
+            self["signatures"].extend(self.ledgertx.json().get("signatures"))
+            return self.ledgertx
+        else:
+            if not any(self.wifs):
+                raise MissingKeyError
+
+            self.tx.sign(self.wifs, chain=self.blockchain.chain_params)
+            self["signatures"].extend(self.tx.json().get("signatures"))
+            return self.tx
+
+    def verify_authority(self):
+        """Verify the authority of the signed transaction"""
+        try:
+            self.blockchain.rpc.set_next_node_on_empty_reply(False)
+            if self.blockchain.rpc.get_use_appbase():
+                args = {"trx": self.json()}
+            else:
+                args = self.json()
+            ret = self.blockchain.rpc.verify_authority(args, api="database")
+            if not ret:
+                raise InsufficientAuthorityError
+            elif isinstance(ret, dict) and "valid" in ret and not ret["valid"]:
+                raise InsufficientAuthorityError
+        except Exception as e:
+            raise e
+
+    def get_potential_signatures(self):
+        """Returns public key from signature"""
+        if not self.blockchain.is_connected():
+            raise OfflineHasNoRPCException("No RPC available in offline mode!")
+        self.blockchain.rpc.set_next_node_on_empty_reply(False)
+        if self.blockchain.rpc.get_use_appbase():
+            args = {"trx": self.json()}
+        else:
+            args = self.json()
+        ret = self.blockchain.rpc.get_potential_signatures(args, api="database")
+        if "keys" in ret:
+            ret = ret["keys"]
+        return ret
+
+    def get_transaction_hex(self):
+        """Returns a hex value of the transaction"""
+        if not self.blockchain.is_connected():
+            raise OfflineHasNoRPCException("No RPC available in offline mode!")
+        self.blockchain.rpc.set_next_node_on_empty_reply(False)
+        if self.blockchain.rpc.get_use_appbase():
+            args = {"trx": self.json()}
+        else:
+            args = self.json()
+        ret = self.blockchain.rpc.get_transaction_hex(args, api="database")
+        if "hex" in ret:
+            ret = ret["hex"]
+        return ret
+
+    def get_required_signatures(self, available_keys=list()):
+        """Returns public key from signature"""
+        if not self.blockchain.is_connected():
+            raise OfflineHasNoRPCException("No RPC available in offline mode!")
+        self.blockchain.rpc.set_next_node_on_empty_reply(False)
+        if self.blockchain.rpc.get_use_appbase():
+            args = {"trx": self.json(), "available_keys": available_keys}
+            ret = self.blockchain.rpc.get_required_signatures(args, api="database")
+        else:
+            ret = self.blockchain.rpc.get_required_signatures(
+                self.json(), available_keys, api="database"
+            )
+
+        return ret
+
+    def broadcast(self, max_block_age=-1, trx_id=True):
+        """Broadcast a transaction to the steem network
+        Returns the signed transaction and clears itself
+        after broadast
+
+        Clears itself when broadcast was not successfully.
+
+        :param int max_block_age: parameter only used
+            for appbase ready nodes
+        :param bool trx_id: When True, trx_id is return
+
+        """
+        # Cannot broadcast an empty transaction
+        if not self._is_signed():
+            sign_ret = self.sign()
+        else:
+            sign_ret = None
+
+        if "operations" not in self or not self["operations"]:
+            return
+        ret = self.json()
+
+        # Returns an internal Error at the moment
+        if not self._use_condenser_api:
+            args = {"trx": self.json(), "max_block_age": max_block_age}
+            broadcast_api = "network_broadcast"
+        else:
+            args = self.json()
+            broadcast_api = "condenser"
+
+        if self.blockchain.nobroadcast:
+            log.info("Not broadcasting anything!")
+            self.clear()
+            return ret
+        # Broadcast
+        try:
+            self.blockchain.rpc.set_next_node_on_empty_reply(False)
+            if self.blockchain.use_sc2:
+                ret = self.blockchain.steemconnect.broadcast(self["operations"])
+            elif self.blockchain.blocking and self._use_condenser_api:
+                ret = self.blockchain.rpc.broadcast_transaction_synchronous(args, api=broadcast_api)
+                if "trx" in ret:
+                    ret.update(**ret.get("trx"))
+            else:
+                self.blockchain.rpc.broadcast_transaction(args, api=broadcast_api)
+        except Exception as e:
+            # log.error("Could Not broadcasting anything!")
+            self.clear()
+            raise e
+        if sign_ret is not None and "trx_id" not in ret and trx_id:
+            ret["trx_id"] = sign_ret.id
+        self.clear()
+        return ret
+
+    def clear(self):
+        """Clear the transaction builder and start from scratch"""
+        self.ops = []
+        self.wifs = set()
+        self.signing_accounts = []
+        self.ref_block_num = None
+        self.ref_block_prefix = None
+        # This makes sure that _is_constructed will return False afterwards
+        self["expiration"] = None
+        super(TransactionBuilder, self).__init__({})
+
+    def addSigningInformation(self, account, permission, reconstruct_tx=False):
+        """This is a private method that adds side information to a
+        unsigned/partial transaction in order to simplify later
+        signing (e.g. for multisig or coldstorage)
+
+        Not needed when "appendWif" was already or is going to be used
+
+        FIXME: Does not work with owner keys!
+
+        :param bool reconstruct_tx: when set to False and tx
+            is already contructed, it will not reconstructed
+            and already added signatures remain
+
+        """
+        if not self._is_constructed() or (self._is_constructed() and reconstruct_tx):
+            self.constructTx()
+        self["blockchain"] = self.blockchain.chain_params
+
+        if isinstance(account, PublicKey):
+            self["missing_signatures"] = [str(account)]
+        else:
+            accountObj = Account(account, blockchain_instance=self.blockchain)
+            authority = accountObj[permission]
+            # We add a required_authorities to be able to identify
+            # how to sign later. This is an array, because we
+            # may later want to allow multiple operations per tx
+            self.update({"required_authorities": {accountObj["name"]: authority}})
+            for account_auth in authority["account_auths"]:
+                account_auth_account = Account(account_auth[0], blockchain_instance=self.blockchain)
+                self["required_authorities"].update(
+                    {account_auth[0]: account_auth_account.get(permission)}
+                )
+
+            # Try to resolve required signatures for offline signing
+            self["missing_signatures"] = [x[0] for x in authority["key_auths"]]
+            # Add one recursion of keys from account_auths:
+            for account_auth in authority["account_auths"]:
+                account_auth_account = Account(account_auth[0], blockchain_instance=self.blockchain)
+                self["missing_signatures"].extend(
+                    [x[0] for x in account_auth_account[permission]["key_auths"]]
+                )
+
+    def appendMissingSignatures(self):
+        """Store which accounts/keys are supposed to sign the transaction
+
+        This method is used for an offline-signer!
+        """
+        missing_signatures = self.get("missing_signatures", [])
+        for pub in missing_signatures:
+            try:
+                wif = self.blockchain.wallet.getPrivateKeyForPublicKey(pub)
+                if wif:
+                    self.appendWif(wif)
+            except MissingKeyError:
+                wif = None