Ejemplo n.º 1
0
def approve(*args, **kwargs):
    """ This process is meant to approve proposals that I have created.

        The reason for this is that proposals created by accountA are not
        automatically also approved by accountA and need an explicit approval.
    """
    peerplays.rpc.connect()
    myapprover = kwargs.get("approver", None)
    if not myapprover:
        myapprover = config.get("BOOKIE_APPROVER")

    myproposer = kwargs.get("proposer", None)
    if not myproposer:
        myproposer = config.get("BOOKIE_PROPOSER")

    log.info("Testing for pending proposals "
             "created by {} that we could approve by {}".format(
                 myproposer, myapprover))

    proposals = Proposals("witness-account")
    approver = Account(myapprover)
    for proposal in proposals:
        proposer = Account(proposal.proposer)
        if (proposer["name"] == myproposer and approver["id"]
                not in proposal["available_active_approvals"]):
            log.info(
                "Proposal {} has been proposed by {}. Approving it!".format(
                    proposal["id"], myproposer))
            log.info(
                peerplays.approveproposal(proposal["id"], account=myapprover))
Ejemplo n.º 2
0
def history(ctx, account, limit, type, csv, exclude, raw):
    """ Show history of an account
    """
    from peerplaysbase.operations import getOperationNameForId
    header = ["#", "time (block)", "operation", "details"]
    if csv:
        import csv
        t = csv.writer(sys.stdout, delimiter=";")
        t.writerow(header)
    else:
        t = PrettyTable(header)
        t.align = "r"
        t.align["details"] = "l"

    for a in account:
        account = Account(a, peerplays_instance=ctx.peerplays)
        for b in account.history(limit=limit,
                                 only_ops=type,
                                 exclude_ops=exclude):
            row = [
                b["id"].split(".")[2],
                "%s" % (b["block_num"]),
                "{} ({})".format(getOperationNameForId(b["op"][0]),
                                 b["op"][0]),
                pprintOperation(b) if not raw else json.dumps(b, indent=4),
            ]
            if csv:
                t.writerow(row)
            else:
                t.add_row(row)
    if not csv:
        click.echo(t)
Ejemplo n.º 3
0
def fixture_data():
    peerplays.clear()
    BettingMarkets.clear_cache()
    Rules.clear_cache()
    BettingMarketGroups.clear_cache()
    Proposals.clear_cache()
    Witnesses.clear_cache()
    Events.clear_cache()
    EventGroups.clear_cache()
    Sports.clear_cache()

    with open(os.path.join(os.path.dirname(__file__), "fixtures.yaml")) as fid:
        data = yaml.safe_load(fid)

    [Account(x) for x in data.get("accounts", [])]
    [Account(x).store(x, "name") for x in data.get("accounts", [])]
    Witnesses.cache_objects([Witness(x) for x in data.get("witnesses", [])])
    Sports.cache_objects([Sport(x) for x in data.get("sports", [])])
    EventGroups.cache_objects(
        [EventGroup(x) for x in data.get("eventgroups", [])])
    Events.cache_objects([Event(x) for x in data.get("events", [])])
    BettingMarketGroups.cache_objects(
        [BettingMarketGroup(x) for x in data.get("bettingmarketgroups", [])])
    BettingMarkets.cache_objects(
        [BettingMarket(x) for x in data.get("bettingmarkets", [])])
    Rules.cache_objects([Rule(x) for x in data.get("rules", [])])
    [Bet(x) for x in data.get("bets", [])]

    proposals = []
    for proposal in data.get("proposals", []):
        ops = list()
        for _op in proposal["operations"]:
            for opName, op in _op.items():
                ops.append([operations[opName], op])
        # Proposal!
        proposal_id = proposal["proposal_id"]
        proposal_data = {
            "available_active_approvals": [],
            "available_key_approvals": [],
            "available_owner_approvals": [],
            "expiration_time": "2018-05-29T10:23:13",
            "id": proposal_id,
            "proposed_transaction": {
                "expiration": "2018-05-29T10:23:13",
                "extensions": [],
                "operations": ops,
                "ref_block_num": 0,
                "ref_block_prefix": 0,
            },
            "proposer": "1.2.7",
            "required_active_approvals": ["1.2.1"],
            "required_owner_approvals": [],
        }
        proposals.append(Proposal(proposal_data))

    Proposals.cache_objects(proposals, "1.2.1")
    Proposals.cache_objects(proposals, "witness-account")
Ejemplo n.º 4
0
def getResolutions(bettor_id, bmg_id=None):
    a = Account(bettor_id, peerplays_instance=ppy, full=True)
    history = []
    for line in a.history(
            limit=1000):  # sufficiently large to get all resolutions
        if line['op'][0] == 64:
            if bmg_id is not None:
                if line['op'][1]['betting_market_group_id'] == bmg_id:
                    history.append(line)
            else:
                history.append(line)
    return history
Ejemplo n.º 5
0
 def test_account_upgrade(self):
     account = Account("witness-account")
     tx = account.upgrade()
     ops = tx["operations"]
     op = ops[0][1]
     self.assertEqual(len(ops), 1)
     self.assertEqual(getOperationNameForId(ops[0][0]), "account_upgrade")
     self.assertTrue(op["upgrade_to_lifetime_member"])
     self.assertEqual(
         op["account_to_upgrade"],
         "1.2.1",
     )
Ejemplo n.º 6
0
 def getWitnessAccount(self):
     # so far default is always active
     try:
         return Account("witness-account",
                        peerplays_instance=self.get_node())
     except Exception as ex:
         raise NodeException(ex.__class__.__name__ + ": " + str(ex))
Ejemplo n.º 7
0
def addkey(ctx, key):
    """ Add a private key to the wallet
    """
    if not key:
        while True:
            key = click.prompt("Private Key (wif) [Enter to quit]",
                               hide_input=True,
                               show_default=False,
                               default="exit")
            if not key or key == "exit":
                break
            try:
                ctx.peerplays.wallet.addPrivateKey(key)
            except Exception as e:
                click.echo(str(e))
                continue
    else:
        for k in key:
            try:
                ctx.peerplays.wallet.addPrivateKey(k)
            except Exception as e:
                click.echo(str(e))

    installedKeys = ctx.peerplays.wallet.getPublicKeys()
    if len(installedKeys) == 1:
        name = ctx.peerplays.wallet.getAccountFromPublicKey(installedKeys[0])
        if name:  # only if a name to the key was found
            account = Account(name, peerplays_instance=ctx.peerplays)
            click.echo("=" * 30)
            click.echo("Setting new default user: %s" % account["name"])
            click.echo()
            click.echo("You can change these settings with:")
            click.echo("    uptick set default_account <account>")
            click.echo("=" * 30)
            config["default_account"] = account["name"]
Ejemplo n.º 8
0
 def get_pending_operations(self,
                            account="witness-account",
                            require_witness=True,
                            require_active_witness=True,
                            **kwargs):
     pending_proposals = Proposals(account)
     witnesses = Witnesses(only_active=require_active_witness)
     props = list()
     for proposal in pending_proposals:
         # Do not inspect proposals that have not been proposed by a witness
         if require_witness and proposal.proposer not in witnesses:
             log.info(
                 "Skipping proposal {} as it has been proposed by a non-witness '{}'"
                 .format(proposal["id"],
                         Account(proposal.proposer)["name"]))
             continue
         ret = []
         if not proposal["id"] in Lookup.approval_map:
             Lookup.approval_map[proposal["id"]] = {}
         for oid, operations in enumerate(proposal.proposed_operations):
             if oid not in Lookup.approval_map[proposal["id"]]:
                 Lookup.approval_map[proposal["id"]][oid] = False
             ret.append((operations, proposal["id"], oid))
         props.append(dict(proposal=proposal, data=ret))
     return props
Ejemplo n.º 9
0
 def getSelectedAccount(self):
     # so far default is always active
     try:
         return Account(self.get_node().config["default_account"],
                        peerplays_instance=self.get_node())
     except Exception as ex:
         raise NodeException(ex.__class__.__name__ + ": " + str(ex))
Ejemplo n.º 10
0
def placeSingleBet():
	try:
		accountStr = request.args.get("account")
		if accountStr is None:
			return make_response(jsonify(error="Specify account in query params"), 500)
		account = Account(accountStr, peerplays_instance = ppy, full=True)
		body = request.get_json()
		asset_symbol = body['asset_symbol']
		bet_amount = body['bet_amount']
		betting_market_id = body['betting_market_id']
		odds = body['odds']
		back_or_lay = body['back_or_lay']
		a  = Amount(bet_amount, asset_symbol)
		ppy.bet_place(betting_market_id, a, odds, back_or_lay, account['id'], fee_asset = asset_symbol)
		time.sleep(3) # until next block is produced
		unmatchedBets = bookie.getUnmatchedBets(account['id'])
		for bet in reversed(unmatchedBets):
			if bet['betting_market_id'] == betting_market_id and bet['back_or_lay'] == back_or_lay and bet['backer_multiplier'] == odds * 10000: #10000 = precision
				return jsonify(bet)
		# only reachable if bet has already been fully matched
		matchedBets = bookie.getMatchedBets(account['id'])
		for bet in matchedBets:
			if bet['betting_market_id'] == betting_market_id and bet['back_or_lay'] == back_or_lay and bet['backer_multiplier'] == odds * 10000: #10000 = precision
				return jsonify(bet)
	except Exception as e:
		return make_response(jsonify(error=e.__doc__), 500)
Ejemplo n.º 11
0
 def getAccounts(self, idList):
     accounts = []
     try:
         for accountId in idList:
             accounts.append(
                 Account(accountId, peerplays_instance=self.get_node()))
         return accounts
     except Exception as ex:
         raise NodeException(ex.__class__.__name__ + ": " + str(ex))
Ejemplo n.º 12
0
def proposals(ctx, account):
    """ List proposals
    """
    proposals = Proposals(account)
    t = PrettyTable([
        "id",
        "expiration",
        "proposer",
        "required approvals",
        "available approvals",
        "review period time",
        "proposal",
    ])
    t.align = "l"
    for proposal in proposals:
        if proposal.proposer:
            proposer = Account(proposal.proposer,
                               peerplays_instance=ctx.peerplays)["name"]
        else:
            proposer = "n/a"

        t.add_row([
            proposal["id"],
            proposal["expiration_time"],
            proposer,
            [
                Account(x)["name"]
                for x in (proposal["required_active_approvals"] +
                          proposal["required_owner_approvals"])
            ],
            json.dumps(
                [
                    Account(x)["name"]
                    for x in proposal["available_active_approvals"]
                ] + proposal["available_key_approvals"] +
                proposal["available_owner_approvals"],
                indent=1,
            ),
            proposal.get("review_period_time", None),
            json.dumps(proposal["proposed_transaction"], indent=4),
        ])

    click.echo(str(t))
Ejemplo n.º 13
0
def balance(ctx, accounts):
    """ Show Account balances
    """
    t = PrettyTable(["Account", "Amount"])
    t.align = "r"
    for a in accounts:
        account = Account(a, peerplays_instance=ctx.peerplays)
        for b in account.balances:
            t.add_row([str(a), str(b)])
    click.echo(str(t))
Ejemplo n.º 14
0
    def test_predefined_data(self):
        from peerplays.account import Account
        # Inject test data into cache
        _cache = ObjectCache(default_expiration=60 * 60 * 1)
        for i in test_objects:
            _cache[i["id"]] = i
        self.assertEqual(_cache['1.19.5']["test"], "passed")

        BlockchainObject._cache = _cache

        account = Account("1.2.0")
        self.assertEqual(account["name"], "committee-account-passed")
Ejemplo n.º 15
0
 def selectAccount(self, accountId):
     # if there are any pending operations the user need to finish
     # that first
     if self.getPendingTransaction() and len(
             self.getPendingTransaction().list_operations()) > 0:
         raise BroadcastActiveOperationsExceptions
     try:
         account = Account(accountId, peerplays_instance=self.get_node())
         self.get_node().config["default_account"] = account['name']
         return account['id'] + ' - ' + account['name']
     except Exception as ex:
         raise NodeException(ex.__class__.__name__ + ": " + str(ex))
Ejemplo n.º 16
0
    def __init__(
        self,
        accounts=[],
        objects=[],
        on_tx=None,
        on_object=None,
        on_block=None,
        on_account=None,
        peerplays_instance=None,
    ):
        # Events
        super(Notify, self).__init__()
        self.events = Events()

        # PeerPlays instance
        self.peerplays = peerplays_instance or shared_peerplays_instance()

        # Accounts
        account_ids = []
        for account_name in accounts:
            account = Account(
                account_name,
                peerplays_instance=self.peerplays
            )
            account_ids.append(account["id"])

        # Callbacks
        if on_tx:
            self.on_tx += on_tx
        if on_object:
            self.on_object += on_object
        if on_block:
            self.on_block += on_block
        if on_account:
            self.on_account += on_account

        # Open the websocket
        self.websocket = PeerPlaysWebsocket(
            urls=self.peerplays.rpc.urls,
            user=self.peerplays.rpc.user,
            password=self.peerplays.rpc.password,
            accounts=account_ids,
            objects=objects,
            on_tx=on_tx,
            on_object=on_object,
            on_block=on_block,
            on_account=self.process_account,
        )
Ejemplo n.º 17
0
def print_permissions(account):
    t = PrettyTable(["Permission", "Threshold", "Key/Account"], hrules=allBorders)
    t.align = "r"
    for permission in ["owner", "active"]:
        auths = []
        # account auths:
        for authority in account[permission]["account_auths"]:
            auths.append("%s (%d)" % (Account(authority[0])["name"], authority[1]))
        # key auths:
        for authority in account[permission]["key_auths"]:
            auths.append("%s (%d)" % (authority[0], authority[1]))
        t.add_row([
            permission,
            account[permission]["weight_threshold"],
            "\n".join(auths),
        ])
    print(t)
Ejemplo n.º 18
0
def listaccounts(ctx):
    """ List accounts (for the connected network)
    """
    t = PrettyTable(["Name", "Key", "Owner", "Active", "Memo"])
    for key in ctx.blockchain.wallet.getPublicKeys(True):
        for account in ctx.blockchain.wallet.getAccountsFromPublicKey(key):
            account = Account(account)
            is_owner = key in [x[0] for x in account["owner"]["key_auths"]]
            is_active = key in [x[0] for x in account["active"]["key_auths"]]
            is_memo = key == account["options"]["memo_key"]
            t.add_row([
                account["name"],
                key,
                "x" if is_owner else "",
                "x" if is_active else "",
                "x" if is_memo else "",
            ])
    click.echo(t)
Ejemplo n.º 19
0
def importaccount(ctx, account, role):
    """ Import an account using an account password
    """
    from peerplaysbase.account import PasswordKey

    password = click.prompt(
        "Account Passphrase",
        hide_input=True,
    )
    account = Account(account, peerplays_instance=ctx.peerplays)
    imported = False

    if role == "owner":
        owner_key = PasswordKey(account["name"], password, role="owner")
        owner_pubkey = format(owner_key.get_public_key(),
                              ctx.peerplays.rpc.chain_params["prefix"])
        if owner_pubkey in [x[0] for x in account["owner"]["key_auths"]]:
            click.echo("Importing owner key!")
            owner_privkey = owner_key.get_private_key()
            ctx.peerplays.wallet.addPrivateKey(owner_privkey)
            imported = True

    if role == "active":
        active_key = PasswordKey(account["name"], password, role="active")
        active_pubkey = format(active_key.get_public_key(),
                               ctx.peerplays.rpc.chain_params["prefix"])
        if active_pubkey in [x[0] for x in account["active"]["key_auths"]]:
            click.echo("Importing active key!")
            active_privkey = active_key.get_private_key()
            ctx.peerplays.wallet.addPrivateKey(active_privkey)
            imported = True

    if role == "memo":
        memo_key = PasswordKey(account["name"], password, role=role)
        memo_pubkey = format(memo_key.get_public_key(),
                             ctx.peerplays.rpc.chain_params["prefix"])
        if memo_pubkey == account["memo_key"]:
            click.echo("Importing memo key!")
            memo_privkey = memo_key.get_private_key()
            ctx.peerplays.wallet.addPrivateKey(memo_privkey)
            imported = True

    if not imported:
        click.echo("No matching key(s) found. Password correct?")
Ejemplo n.º 20
0
    def test_finalize(self):
        account = Account(account_id)

        op = operations.Transfer(
            **{
                "fee": {
                    "asset_id": "1.3.0",
                    "amount": 1
                },
                "from": account_id,
                "to": '1.2.8',
                "amount": {
                    "asset_id": "1.3.0",
                    "amount": 1
                }
            })

        tx = self.ppy.finalizeOp(op, account, "active")
        self.assertEqual(len(tx["signatures"]), 1)
Ejemplo n.º 21
0
    def retrieve_data(self):
        self.data = None
        if self.account_name is None or self.asset is None:
            logging.error(
                "retrieve data of source Peerplays Balance failed, because of missing information"
            )
            return None

        try:
            self.data = Account(self.account_name).balance(self.asset).amount
        except AssetDoesNotExistsException as e:
            logging.error("Asset does not exist: " + str(e))
        except AccountDoesNotExistsException as e:
            logging.error("Account does not exist: " + str(e))
        except ValueError as e:
            logging.error(
                str(e) +
                " -- This usually happens when Peerplays is not set up correctly."
            )
Ejemplo n.º 22
0
    def retrieve_data(self):
        account = self.get_witness_account()
        proposals = Proposals(account)
        # list of open proposals
        proposals.refresh()
        proposals = Proposals(account)

        data = []
        for proposal in proposals:
            if proposal.proposer:
                proposer = Account(proposal.proposer)["name"]
            else:
                proposer = "n/a"

            data.append(
                dict(
                    proposal_id=proposal["id"],
                    expiration_time=proposal["expiration_time"],
                    #         proposer,
                    #         [
                    #             Account(x)["name"]
                    #             for x in (
                    #                 proposal["required_active_approvals"]
                    #                 + proposal["required_owner_approvals"]
                    #         )
                    #         ],
                    #         json.dumps(
                    #             [Account(x)["name"] for x in proposal["available_active_approvals"]]
                    #             + proposal["available_key_approvals"]
                    #             + proposal["available_owner_approvals"],
                    #             indent=1,
                    #         ),
                    #         proposal.get("review_period_time", None),
                    #         json.dumps(proposal["proposed_transaction"], indent=4),
                ))
        self._set_data(data)
Ejemplo n.º 23
0
def permissions(ctx, account):
    """ Show permissions of an account
    """
    print_permissions(Account(account))
Ejemplo n.º 24
0
def getMatchedBets(bettor_id):
    try:
        a = Account(bettor_id, peerplays_instance=ppy, full=True)
        return jsonify(bookie.getMatchedBets(a['id']))
    except Exception as e:
        return make_response(jsonify(error=e.__doc__), 500)
Ejemplo n.º 25
0
def info(ctx, objects):
    """ Obtain all kinds of information
    """
    if not objects:
        t = PrettyTable(["Key", "Value"])
        t.align = "l"
        info = ctx.peerplays.rpc.get_dynamic_global_properties()
        for key in info:
            t.add_row([key, info[key]])
        click.echo(t.get_string(sortby="Key"))

    for obj in objects:
        # Block
        if re.match("^[0-9]*$", obj):
            block = Block(obj, peerplays_instance=ctx.peerplays)
            if block:
                t = PrettyTable(["Key", "Value"])
                t.align = "l"
                for key in sorted(block):
                    value = block[key]
                    if key == "transactions":
                        value = json.dumps(value, indent=4)
                    t.add_row([key, value])
                click.echo(t)
            else:
                click.echo("Block number %s unknown" % obj)
        # Object Id
        elif len(obj.split(".")) == 3:
            data = ctx.peerplays.rpc.get_object(obj)
            if data:
                t = PrettyTable(["Key", "Value"])
                t.align = "l"
                for key in sorted(data):
                    value = data[key]
                    if isinstance(value, dict) or isinstance(value, list):
                        value = json.dumps(value, indent=4)
                    t.add_row([key, value])
                click.echo(t)
            else:
                click.echo("Object %s unknown" % obj)

        # Asset
        elif obj.upper() == obj:
            data = Asset(obj)
            t = PrettyTable(["Key", "Value"])
            t.align = "l"
            for key in sorted(data):
                value = data[key]
                if isinstance(value, dict):
                    value = json.dumps(value, indent=4)
                t.add_row([key, value])
            click.echo(t)

        # Public Key
        elif re.match("^PPY.{48,55}$", obj):
            account = ctx.peerplays.wallet.getAccountFromPublicKey(obj)
            if account:
                t = PrettyTable(["Account"])
                t.align = "l"
                t.add_row([account])
                click.echo(t)
            else:
                click.echo("Public Key not known" % obj)

        # Account name
        elif re.match("^[a-zA-Z0-9\-\._]{2,64}$", obj):
            account = Account(obj, full=True)
            if account:
                t = PrettyTable(["Key", "Value"])
                t.align = "l"
                for key in sorted(account):
                    value = account[key]
                    if isinstance(value, dict) or isinstance(value, list):
                        value = json.dumps(value, indent=4)
                    t.add_row([key, value])
                click.echo(t)
            else:
                click.echo("Account %s unknown" % obj)
        else:
            click.echo("Couldn't identify object to read")
Ejemplo n.º 26
0
def getHistory(bettor_id, limit=10):
    a = Account(bettor_id, peerplays_instance=ppy, full=True)
    history = []
    for line in a.history(limit=limit):
        history.append(line)
    return history
Ejemplo n.º 27
0
 def getAccount(self, name):
     try:
         return Account(name, peerplays_instance=self.get_node())
     except Exception as ex:
         raise NodeException(ex.__class__.__name__ + ": " + str(ex))
Ejemplo n.º 28
0
def getAccountDetails(bettor_id):
    a = Account(bettor_id, peerplays_instance=ppy, full=True)
    return a
Ejemplo n.º 29
0
    def approve(self, pid, oid, **kwargs):
        """ Approve a proposal

            This call basically flags a single update operation of a proposal
            as "approved". Only if all operations in the proposal are approved,
            will this tool approve the whole proposal and otherwise ignore the
            proposal.

            The call has to identify the correct operation of a proposal on its
            own.

            Internally, a proposal is approved partially using a map that
            contains the approval of each operation in a proposal. Once all
            operations of a proposal are approved, the whole proopsal is
            approved.

            :param str pid: Proposal id
            :param int oid: Operation number within the proposal
        """
        if pid[:3] == "0.0":
            log.info("Cannot approve pending-for-broadcast proposals")
            return
        assert self.approving_account, "No approving_account defined!"

        Lookup.approval_map[pid][oid] = True

        def pretty_proposal_map():
            ret = dict()
            for k, v in Lookup.approval_map.items():
                ret[k] = "{:.1f}".format(sum(v.values()) / len(v) * 100)
            return ret

        log.info("Approval Map: {}".format(pretty_proposal_map()))

        approved_read_for_delete = []
        for p in Lookup.approval_map:
            if all(Lookup.approval_map[p].values()):
                proposal = Proposal(p)
                account = Account(self.approving_account)
                if account["id"] not in proposal["available_active_approvals"]:
                    log.info("Approving proposal {} by {}".format(
                        p, account["name"]))
                    approved_read_for_delete.append(p)
                    try:
                        log.info(self.peerplays.approveproposal(
                            p,
                            account=self.approving_account,
                            append_to=Lookup.direct_buffer
                        ))
                    except Exception as e:
                        log.debug("Exception when approving proposal: {}".format(
                            str(e)))
                        # Not raising as at this point, the only reason for
                        # this to fail is (probably) for the proposal to be
                        # approved already - in the meantime.
                        pass
                else:
                    log.info(
                        "Proposal {} has already been approved by {}".format(
                            p, account["name"])
                    )

        # In order not to approve the same proposal again and again, we remove
        # it from the map
        for p in approved_read_for_delete:
            del Lookup.approval_map[p]
Ejemplo n.º 30
0
    def test_account(self):
        Account("witness-account")
        Account("1.2.3")
        asset = Asset("1.3.0")
        symbol = asset["symbol"]
        account = Account("witness-account", full=True)
        self.assertEqual(account.name, "witness-account")
        self.assertEqual(account["name"], account.name)
        self.assertEqual(account["id"], "1.2.1")
        self.assertIsInstance(account.balance("1.3.0"), Amount)
        self.assertIsInstance(account.balance({"symbol": symbol}), Amount)
        self.assertIsInstance(account.balances, list)
        for h in account.history(limit=1):
            pass

        # BlockchainObjects method
        account.cached = False
        self.assertTrue(account.items())
        account.cached = False
        self.assertIn("id", account)
        account.cached = False
        self.assertEqual(account["id"], "1.2.1")
        self.assertEqual(str(account), "<Account 1.2.1>")
        self.assertIsInstance(Account(account), Account)