def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = operations.CommentOptions(
**{
"author": "xeroc",
"permlink": "piston",
"max_accepted_payout": "1000000.000 SBD",
"percent_steem_dollars": 10000,
"allow_votes": True,
"allow_curation_rewards": True,
"extensions": []
})
ops = [operations.Operation(op)]
tx = SignedTransaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=self.steem.chain_params)
tx_wire = hexlify(bytes(tx)).decode("ascii")
# todo
rpc = self.steem.commit.wallet
compare = rpc.serialize_transaction(tx.json())
pprint(tx.json())
print("\n")
print(compare[:-130])
print(tx_wire[:-130])
print("\n")
print(tx_wire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], tx_wire[:-130])
def comment_options(self, identifier, options, account=None):
""" Set the comment options
:param str identifier: Post identifier
:param dict options: The options to define.
:param str account: (optional) the account to allow access
to (defaults to ``default_account``)
For the options, you have these defaults:::
{
"author": "",
"permlink": "",
"max_accepted_payout": "1000000.000 SMOKE",
"percent_steem_dollars": 10000,
"allow_votes": True,
"allow_curation_rewards": True,
}
"""
if not account:
account = configStorage.get("default_account")
if not account:
raise ValueError("You need to provide an account")
account = Account(account, steemd_instance=self.steemd)
author, permlink = resolve_identifier(identifier)
default_max_payout = "1000000.000 SBD"
op = operations.CommentOptions(
**{
"author":
author,
"permlink":
permlink,
"max_accepted_payout":
options.get("max_accepted_payout", default_max_payout),
"percent_steem_dollars":
options.get("percent_steem_dollars", 100) * STEEMIT_1_PERCENT,
"allow_votes":
options.get("allow_votes", True),
"allow_curation_rewards":
options.get("allow_curation_rewards", True),
})
return self.finalizeOp(op, account["name"], "posting")
def test_comment_options(self):
op = operations.CommentOptions(
**{
"author":
"xeroc",
"permlink":
"piston",
"max_accepted_payout":
"1000000.000 SBD",
"percent_steem_dollars":
10000,
"allow_votes":
True,
"allow_curation_rewards":
True,
"beneficiaries": [{
"weight": 2000,
"account": "good-karma"
}, {
"weight": 5000,
"account": "null"
}],
})
ops = [operations.Operation(op)]
tx = SignedTransaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=self.steem.chain_params)
txWire = hexlify(bytes(tx)).decode("ascii")
compare = ("f68585abf4dce7c804570113057865726f6306706973746f6e"
"00ca9a3b000000000353424400000000102701010100020a67"
"6f6f642d6b61726d61d007046e756c6c881300011f59634e65"
"55fec7c01cb7d4921601c37c250c6746022cc35eaefdd90405"
"d7771b2f65b44e97b7f3159a6d52cb20640502d2503437215f"
"0907b2e2213940f34f2c")
self.assertEqual(compare[:-130], txWire[:-130])
def post(self,
title,
body,
author,
permlink=None,
reply_identifier=None,
json_metadata=None,
comment_options=None,
community=None,
tags=None,
beneficiaries=None,
self_vote=False):
""" Create a new post.
If this post is intended as a reply/comment, `reply_identifier` needs
to be set with the identifier of the parent post/comment (eg.
`author/permlink`).
Optionally you can also set json_metadata, comment_options and upvote
the newly created post as an author.
Setting category, tags or community will override the values provided
in json_metadata and/or comment_options where appropriate.
Args:
title (str): Title of the post
body (str): Body of the post/comment
author (str): Account are you posting from
permlink (str): Manually set the permlink (defaults to None).
If left empty, it will be derived from title automatically.
reply_identifier (str): Identifier of the parent post/comment (only
if this post is a reply/comment).
json_metadata (str, dict): JSON meta object that can be attached to
the post.
comment_options (str, dict): JSON options object that can be
attached to the post.
Example::
comment_options = {
'max_accepted_payout': '1000000.000 SMOKE',
'allow_votes': True,
'allow_curation_rewards': True,
'extensions': [[0, {
'beneficiaries': [
{'account': 'account1', 'weight': 5000},
{'account': 'account2', 'weight': 5000},
]}
]]
}
community (str): (Optional) Name of the community we are posting
into. This will also override the community specified in
`json_metadata`.
tags (str, list): (Optional) A list of tags (5 max) to go with the
post. This will also override the tags specified in
`json_metadata`. The first tag will be used as a 'category'. If
provided as a string, it should be space separated.
beneficiaries (list of dicts): (Optional) A list of beneficiaries
for posting reward distribution. This argument overrides
beneficiaries as specified in `comment_options`.
For example, if we would like to split rewards between account1 and
account2::
beneficiaries = [
{'account': 'account1', 'weight': 5000},
{'account': 'account2', 'weight': 5000}
]
self_vote (bool): (Optional) Upvote the post as author, right after
posting.
"""
# prepare json_metadata
json_metadata = json_metadata or {}
if isinstance(json_metadata, str):
json_metadata = silent(json.loads)(json_metadata) or {}
# override the community
if community:
json_metadata.update({'community': community})
# deal with the category and tags
if isinstance(tags, str):
tags = list(set(filter(None, (re.split("[\W_]", tags)))))
category = None
tags = tags or json_metadata.get('tags', [])
if tags:
if len(tags) > 5:
raise ValueError('Can only specify up to 5 tags per post.')
# first tag should be a category
category = tags[0]
json_metadata.update({"tags": tags})
# can't provide a category while replying to a post
if reply_identifier and category:
category = None
# deal with replies/categories
if reply_identifier:
parent_author, parent_permlink = resolve_identifier(
reply_identifier)
if not permlink:
permlink = derive_permlink(title, parent_permlink)
elif category:
parent_permlink = derive_permlink(category)
parent_author = ""
if not permlink:
permlink = derive_permlink(title)
else:
parent_author = ""
parent_permlink = ""
if not permlink:
permlink = derive_permlink(title)
post_op = operations.Comment(
**{
"parent_author": parent_author,
"parent_permlink": parent_permlink,
"author": author,
"permlink": permlink,
"title": title,
"body": body,
"json_metadata": json_metadata
})
ops = [post_op]
# if comment_options are used, add a new op to the transaction
if comment_options or beneficiaries:
options = keep_in_dict(comment_options or {}, [
'max_accepted_payout', 'percent_steem_dollars', 'allow_votes',
'allow_curation_rewards', 'extensions'
])
# override beneficiaries extension
if beneficiaries:
# validate schema
# or just simply vo.Schema([{'account': str, 'weight': int}])
schema = vo.Schema([{
vo.Required('account'):
vo.All(str, vo.Length(max=16)),
vo.Required('weight', default=10000):
vo.All(int, vo.Range(min=1, max=10000))
}])
schema(beneficiaries)
options['beneficiaries'] = beneficiaries
default_max_payout = "1000000.000 SMOKE"
comment_op = operations.CommentOptions(
**{
"author":
author,
"permlink":
permlink,
"max_accepted_payout":
options.get("max_accepted_payout", default_max_payout),
"percent_steem_dollars":
int(options.get("percent_steem_dollars", 10000)),
"allow_votes":
options.get("allow_votes", True),
"allow_curation_rewards":
options.get("allow_curation_rewards", True),
"extensions":
options.get("extensions", []),
"beneficiaries":
options.get("beneficiaries"),
})
ops.append(comment_op)
if self_vote:
vote_op = operations.Vote(
**{
'voter': author,
'author': author,
'permlink': permlink,
'weight': 10000,
})
ops.append(vote_op)
return self.finalizeOp(ops, author, "posting")
