def test_powerdownroute(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
result = runner.invoke(cli, ['powerdownroute', 'beem1'],
input="test\n")
self.assertEqual(result.exit_code, 0)
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_nodes(
normal=True, appbase=True),
num_retries=10))
cls.bts = Steem(node=nodelist.get_nodes(),
nobroadcast=True,
keys={"active": wif},
num_retries=10)
b = Blockchain(steem_instance=cls.bts)
num = b.get_current_block_num()
cls.start = num - 25
cls.stop = num
cls.testnet = Steem(node="https://testnet.steemitdev.com",
nobroadcast=True,
keys={"active": wif},
num_retries=10)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_steem_instance(cls.bts)
cls.bts.set_default_account("test")
b = Blockchain(steem_instance=cls.testnet)
num = b.get_current_block_num()
cls.start_testnet = num - 25
cls.stop_testnet = num
def setUpClass(cls):
nodelist = NodeList()
# stm = shared_steem_instance()
# stm.config.refreshBackup()
# nodes = nodelist.get_testnet()
cls.nodes = nodelist.get_nodes()
cls.bts = Steem(
node=cls.nodes,
nobroadcast=True,
num_retries=10,
expiration=120,
)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
cls.bts.set_default_account("beem")
# Test account "beem"
cls.active_key = "5Jt2wTfhUt5GkZHV1HYVfkEaJ6XnY8D2iA4qjtK9nnGXAhThM3w"
cls.posting_key = "5Jh1Gtu2j4Yi16TfhoDmg8Qj3ULcgRi7A49JXdfUUTVPkaFaRKz"
cls.memo_key = "5KPbCuocX26aMxN9CDPdUex4wCbfw9NoT5P7UhcqgDwxXa47bit"
# Test account "beem1"
cls.active_key1 = "5Jo9SinzpdAiCDLDJVwuN7K5JcusKmzFnHpEAtPoBHaC1B5RDUd"
cls.posting_key1 = "5JGNhDXuDLusTR3nbmpWAw4dcmE8WfSM8odzqcQ6mDhJHP8YkQo"
cls.memo_key1 = "5KA2ddfAffjfRFoe1UhQjJtKnGsBn9xcsdPQTfMt1fQuErDAkWr"
cls.active_private_key_of_beem4 = '5JkZZEUWrDsu3pYF7aknSo7BLJx7VfxB3SaRtQaHhsPouDYjxzi'
cls.active_private_key_of_beem5 = '5Hvbm9VjRbd1B3ft8Lm81csaqQudwFwPGdiRKrCmTKcomFS3Z9J'
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes()
nodelist.update_nodes(steem_instance=Steem(
node=nodelist.get_nodes(hive=True), num_retries=10))
cls.node_list = nodelist.get_nodes(hive=True)
# stm = shared_steem_instance()
# stm.config.refreshBackup()
runner = CliRunner()
result = runner.invoke(cli,
['-o', 'set', 'default_vote_weight', '100'])
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['-o', 'set', 'default_account', 'beem'])
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['-o', 'set', 'nodes', str(cls.node_list)])
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['createwallet', '--wipe'],
input="test\ntest\n")
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['addkey'], input="test\n" + wif + "\n")
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['addkey'],
input="test\n" + posting_key + "\n")
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['addkey'],
input="test\n" + memo_key + "\n")
if result.exit_code != 0:
raise AssertionError(str(result))
def test_hive_nodes(self):
nodelist = NodeList()
nodelist.update_nodes()
hive_nodes = nodelist.get_hive_nodes()
for node in hive_nodes:
blockchainobject = Hive(node=node)
assert blockchainobject.is_hive
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(
node=nodelist.get_nodes(normal=True, appbase=True), num_retries=3))
cls.nodes = nodelist.get_nodes(https=False, appbase=False)
cls.nodes_https = nodelist.get_nodes(wss=False, appbase=False)
cls.nodes_appbase = nodelist.get_nodes(normal=False)
cls.test_list = nodelist.get_nodes()
cls.bts = Steem(node=cls.nodes,
nobroadcast=True,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.appbase = Steem(node=cls.nodes_appbase,
nobroadcast=True,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.rpc = SteemNodeRPC(urls=cls.test_list)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_steem_instance(cls.bts)
cls.bts.set_default_account("test")
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_nodes(
normal=True, appbase=True),
num_retries=10))
cls.bts = Steem(node=nodelist.get_nodes(appbase=False),
use_condenser=True,
nobroadcast=True,
unsigned=True,
keys={"active": wif},
num_retries=10)
cls.appbase = Steem(node=nodelist.get_nodes(normal=False,
appbase=True),
nobroadcast=True,
unsigned=True,
keys={"active": wif},
num_retries=10)
acc = Account("holger80", steem_instance=cls.bts)
comment = acc.get_blog(limit=20)[-1]
cls.authorperm = comment.authorperm
[author, permlink] = resolve_authorperm(cls.authorperm)
cls.author = author
cls.permlink = permlink
cls.category = comment.category
cls.title = comment.title
def test_rewards(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', ''])
result = runner.invoke(cli, ['rewards', 'test'])
self.assertEqual(result.exit_code, 0)
result = runner.invoke(
cli, ['rewards', '--post', '--comment', '--curation', 'test'])
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'rewards', '--post', '--comment', '--curation', '--permlink',
'test'
])
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'rewards', '--post', '--comment', '--curation', '--author', 'test'
])
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'rewards', '--post', '--comment', '--curation', '--author',
'--title', 'test'
])
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'rewards', '--post', '--comment', '--curation', '--author',
'--permlink', '--length', '30', 'test'
])
self.assertEqual(result.exit_code, 0)
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
def test_curation(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', ''])
result = runner.invoke(cli, ['curation', "@gtg/witness-gtg-log"])
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
self.assertEqual(result.exit_code, 0)
def test_importaccount(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
result = runner.invoke(cli, [
'importaccount', '--roles',
'["owner", "active", "posting", "memo"]', 'beem2'
],
input="test\ntest\n")
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'delkey', '--confirm',
'STX7mLs2hns87f7kbf3o2HBqNoEaXiTeeU89eVF6iUCrMQJFzBsPo'
],
input="test\n")
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'delkey', '--confirm',
'STX7rUmnpnCp9oZqMQeRKDB7GvXTM9KFvhzbA3AKcabgTBfQZgHZp'
],
input="test\n")
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'delkey', '--confirm',
'STX6qGWHsCpmHbphnQbS2yfhvhJXDUVDwnsbnrMZkTqfnkNEZRoLP'
],
input="test\n")
self.assertEqual(result.exit_code, 0)
result = runner.invoke(cli, [
'delkey', '--confirm',
'STX8Wvi74GYzBKgnUmiLvptzvxmPtXfjGPJL8QY3rebecXaxGGQyV'
],
input="test\n")
self.assertEqual(result.exit_code, 0)
def test_witnesscreate(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
result = runner.invoke(cli, ['-d', 'witnesscreate', 'beem', pub_key],
input="test\n")
self.assertEqual(result.exit_code, 0)
def test_disapprovewitness(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
result = runner.invoke(cli, ['-o', 'disapprovewitness', 'beem1'],
input="test\n")
self.assertEqual(result.exit_code, 0)
def setUpClass(cls):
nodelist = NodeList()
stm = shared_steem_instance()
stm.config.refreshBackup()
runner = CliRunner()
result = runner.invoke(cli,
['-o', 'set', 'default_vote_weight', '100'])
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['-o', 'set', 'default_account', 'beem'])
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(
cli, ['-o', 'set', 'nodes',
str(nodelist.get_testnet())])
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['createwallet', '--wipe'],
input="test\ntest\n")
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['addkey'], input="test\n" + wif + "\n")
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['addkey'],
input="test\n" + posting_key + "\n")
if result.exit_code != 0:
raise AssertionError(str(result))
result = runner.invoke(cli, ['addkey'],
input="test\n" + memo_key + "\n")
if result.exit_code != 0:
raise AssertionError(str(result))
def test_updatememokey(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
result = runner.invoke(cli, ['-d', 'updatememokey'],
input="test\ntest\ntest\n")
self.assertEqual(result.exit_code, 0)
def setUpClass(cls):
nodelist = NodeList()
cls.bts = Steem(node=nodelist.get_nodes(appbase=False),
nobroadcast=True,
keys={"active": wif},
num_retries=10)
cls.appbase = Steem(node=nodelist.get_nodes(normal=False,
appbase=True),
nobroadcast=True,
keys={"active": wif},
num_retries=10)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_steem_instance(cls.bts)
cls.bts.set_default_account("test")
acc = Account("holger80", steem_instance=cls.bts)
votes = acc.get_account_votes()
last_vote = votes[0]
cls.authorpermvoter = '@' + last_vote['authorperm'] + '|' + acc["name"]
[author, permlink,
voter] = resolve_authorpermvoter(cls.authorpermvoter)
cls.author = author
cls.permlink = permlink
cls.voter = voter
cls.authorperm = construct_authorperm(author, permlink)
def test_verify(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', ''])
result = runner.invoke(cli, ['verify', '--trx', '0'])
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
self.assertEqual(result.exit_code, 0)
def setUpClass(cls):
nodelist = NodeList()
stm = Steem(node=nodelist.get_nodes(),
nobroadcast=True,
num_retries=10,
expiration=120)
set_shared_steem_instance(stm)
def test_tradehistory(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', ''])
result = runner.invoke(cli, ['tradehistory'])
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
self.assertEqual(result.exit_code, 0)
def getHiveNodes():
""" Return a list of hive node URLS """
from beem.nodelist import NodeList
nodelist = NodeList()
nodelist.update_nodes()
nodes = nodelist.get_hive_nodes()
return nodes
def setUpClass(cls):
nodelist = NodeList()
cls.bts = Steem(node=nodelist.get_nodes(appbase=False),
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.appbase = Steem(node=nodelist.get_nodes(normal=False,
appbase=True),
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.account = Account("test", full=True, steem_instance=cls.bts)
cls.account_appbase = Account("test",
full=True,
steem_instance=cls.appbase)
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_nodes(
normal=True, appbase=True),
num_retries=10))
cls.bts = Steem(
node=nodelist.get_nodes(normal=True, appbase=False),
nobroadcast=True,
bundle=False,
unsigned=True,
# Overwrite wallet to use this list of wifs only
keys={"active": wif},
num_retries=10)
cls.appbase = Steem(
node=nodelist.get_nodes(normal=False, appbase=True, dev=False),
nobroadcast=True,
bundle=False,
unsigned=True,
# Overwrite wallet to use this list of wifs only
keys={"active": wif},
num_retries=10)
cls.account = Account("beembot", full=True, steem_instance=cls.bts)
cls.account_appbase = Account("beembot",
full=True,
steem_instance=cls.appbase)
set_shared_steem_instance(cls.bts)
def test_offline(self):
nodelist = NodeList()
bts = Steem(node=nodelist.get_nodes(appbase=False),
offline=True,
data_refresh_time_seconds=900,
keys={
"active": wif,
"owner": wif,
"memo": wif
})
bts.refresh_data()
self.assertTrue(bts.get_reserve_ratio(use_stored_data=False) is None)
self.assertTrue(bts.get_reserve_ratio(use_stored_data=True) is None)
self.assertTrue(bts.get_feed_history(use_stored_data=False) is None)
self.assertTrue(bts.get_feed_history(use_stored_data=True) is None)
self.assertTrue(bts.get_reward_funds(use_stored_data=False) is None)
self.assertTrue(bts.get_reward_funds(use_stored_data=True) is None)
self.assertTrue(
bts.get_current_median_history(use_stored_data=False) is None)
self.assertTrue(
bts.get_current_median_history(use_stored_data=True) is None)
self.assertTrue(
bts.get_hardfork_properties(use_stored_data=False) is None)
self.assertTrue(
bts.get_hardfork_properties(use_stored_data=True) is None)
self.assertTrue(bts.get_network(use_stored_data=False) is None)
self.assertTrue(bts.get_network(use_stored_data=True) is None)
self.assertTrue(
bts.get_witness_schedule(use_stored_data=False) is None)
self.assertTrue(bts.get_witness_schedule(use_stored_data=True) is None)
self.assertTrue(bts.get_config(use_stored_data=False) is None)
self.assertTrue(bts.get_config(use_stored_data=True) is None)
self.assertEqual(bts.get_block_interval(), 3)
self.assertEqual(bts.get_blockchain_version(), '0.0.0')
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_nodes(hive=True), num_retries=10))
cls.bts = Steem(
node=nodelist.get_nodes(hive=True),
nobroadcast=True,
keys={"active": wif},
num_retries=10
)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_steem_instance(cls.bts)
cls.bts.set_default_account("test")
acc = Account("fullnodeupdate", steem_instance=cls.bts)
n_votes = 0
index = 0
entries = acc.get_blog_entries(limit=30)[::-1]
while n_votes == 0:
comment = Comment(entries[index], steem_instance=cls.bts)
votes = comment.get_votes()
n_votes = len(votes)
index += 1
last_vote = votes[0]
cls.authorpermvoter = construct_authorpermvoter(last_vote['author'], last_vote['permlink'], last_vote["voter"])
[author, permlink, voter] = resolve_authorpermvoter(cls.authorpermvoter)
cls.author = author
cls.permlink = permlink
cls.voter = voter
cls.authorperm = construct_authorperm(author, permlink)
def claim_tokens():
username = ["ufm.reserve", "taskmanager", "tmholdings", "upfundme", "tmps"]
for username in username:
url = "http://scot-api.steem-engine.com/@" + username
r = requests.get(url)
result = r.json()
json_data = []
for token in result:
scot = result[token]
if int(scot["pending_token"]) > 0:
json_data.append({"symbol": token})
print(username + " can claim %s" % (token))
if len(json_data) > 0:
nodes = NodeList()
nodes.update_nodes()
stm = Steem(nodes.get_nodes())
try:
stm.unlock(pwd=beem_pass)
except:
stm = Steem(node=nodes.get_nodes(), keys=[pwd])
stm.custom_json("scot_claim_token",
json_data,
required_posting_auths=[username])
else:
print(username + " Has nothing to claim")
def test_steem_nodes(self):
nodelist = NodeList()
nodelist.update_nodes()
steem_nodes = nodelist.get_steem_nodes()
for node in steem_nodes:
blockchainobject = Steem(node=node)
assert blockchainobject.is_steem
def memos_blacklist(user_c, m_days):
"""
Given a steem-user and #days, returns memos in which the word blacklist appears.
:param str user_c: steem user
:param int m_days: number of days
:rtype: list str with memos containing blacklist
"""
nodes = NodeList().get_nodes()
stm = Steem(node=nodes)
set_shared_steem_instance(stm)
acc = Account(user_c, steem_instance=stm)
stop_time = datetime.now()
start_time = stop_time - timedelta(m_days)
blist = []
mem_memo = set()
for mem in acc.history(start=start_time,
stop=stop_time,
only_ops=['transfer']):
#make the text lower case
newmem = mem['memo'].lower()
# find memos which contain the word blacklist and only consider unique transaction senders
if newmem.count('blacklist') > 0 and mem['from'] not in mem_memo:
b_list = blist.append(mem['timestamp'] + '|' + mem['from'] + '|' +
mem['memo'] + ' <br>')
mem_memo.add(mem['from'])
return blist
def setUpClass(cls):
cls.nodelist = NodeList()
cls.nodelist.update_nodes(steem_instance=Steem(
node=cls.nodelist.get_nodes(normal=True, appbase=True),
num_retries=10))
cls.bts = Steem(node=cls.nodelist.get_nodes(),
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.testnet = Steem(node="https://testnet.steemitdev.com",
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.account = Account("test", full=True, steem_instance=cls.bts)
cls.account_testnet = Account("test",
full=True,
steem_instance=cls.testnet)
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_nodes(exclude_limited=False), num_retries=10))
node_list = nodelist.get_nodes(exclude_limited=True)
cls.bts = Steem(
node=node_list,
use_condenser=True,
nobroadcast=True,
unsigned=True,
keys={"active": wif},
num_retries=10
)
cls.steemit = Steem(
node="https://api.steemit.com",
nobroadcast=True,
unsigned=True,
keys={"active": wif},
num_retries=10
)
acc = Account("holger80", steem_instance=cls.bts)
comment = acc.get_feed(limit=20)[-1]
cls.authorperm = comment.authorperm
[author, permlink] = resolve_authorperm(cls.authorperm)
cls.author = author
cls.permlink = permlink
cls.category = comment.category
cls.title = comment.title
def setUpClass(cls):
stm = shared_steem_instance()
stm.config.refreshBackup()
nodelist = NodeList()
nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_nodes(
normal=True, appbase=True),
num_retries=10))
cls.stm = Steem(
node=nodelist.get_nodes(),
nobroadcast=True,
# We want to bundle many operations into a single transaction
bundle=True,
num_retries=10
# Overwrite wallet to use this list of wifs only
)
cls.stm.set_default_account("test")
set_shared_steem_instance(cls.stm)
# self.stm.newWallet("TestingOneTwoThree")
cls.wallet = Wallet(steem_instance=cls.stm)
cls.wallet.wipe(True)
cls.wallet.newWallet(pwd="TestingOneTwoThree")
cls.wallet.unlock(pwd="TestingOneTwoThree")
cls.wallet.addPrivateKey(wif)
def test_transfer(self):
runner = CliRunner()
nodelist = NodeList()
runner.invoke(cli, ['-o', 'set', 'nodes', str(nodelist.get_testnet())])
result = runner.invoke(cli, ['transfer', 'beem1', '1', 'SBD', 'test'],
input="test\n")
self.assertEqual(result.exit_code, 0)
