def test_witness_update():
# TODO: Remove when witness_update is fixed.
return
wif = '5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3'
c = Commit(steemd_instance=Steemd(nodes=[]), keys=[wif])
signing_key = 'BMT1111111111111111111111111111111114T1Anm'
props = {
'account_creation_fee': '0.500 BMT',
'maximum_block_size': 65536,
'sbd_interest_rate': 0
}
rpc_error = None
try:
c.witness_update(signing_key=signing_key,
account='test',
props=props,
url='foo')
except RPCError as e:
rpc_error = str(e)
else:
raise Exception('expected RPCError')
assert 'tx_missing_active_auth' in rpc_error
def update_post():
s = Steemd()
now = datetime.datetime.now()
users = User.objects.all()
for user in users:
posts = s.get_discussions_by_author_before_date(
user.username, None, now.strftime("%Y-%m-%dT%H:%M"), 10)
for post in posts:
try:
steem_post = Post.objects.get(slug=post.pop('root_permlink'))
steem_post.update(post)
except Post.DoesNotExist:
pass
def sync_from_steemd():
s = Steemd()
lbound = db_last_block() + 1
ubound = s.last_irreversible_block_num
start_num = lbound
start_time = time.time()
while lbound < ubound:
to = min(lbound + 1000, ubound)
blocks = s.get_blocks_range(lbound, to)
lbound = to
process_blocks(blocks)
rate = (lbound - start_num) / (time.time() - start_time)
print("[SYNC] Got block {} ({}/s) {}m remaining".format(
to - 1, round(rate, 1), round((ubound - lbound) / rate / 60, 2)))
def test_get_block():
""" We should be able to fetch some blocks. """
s = Steemd()
for num in [1000, 1000000, 10000000, 20000000, 21000000]:
b = s.get_block(num)
assert b, 'block %d was blank' % num
assert num == int(b['block_id'][:8], base=16)
start = 21000000
for num in range(start, start + 50):
b = s.get_block(num)
assert b, 'block %d was blank' % num
assert num == int(b['block_id'][:8], base=16)
non_existent_block = 99999999
b = s.get_block(non_existent_block)
assert not b, 'block %d expected to be blank' % non_existent_block
def get_inbound_steem_transfers(account_name):
nodes = ['https://api.steemit.com', 'https://gtg.steem.house:8090']
set_shared_steemd_instance(Steemd(nodes=nodes))
acc = Account('greenman')
def filter(t):
return t['to'] == account_name and float(
t['amount'].split(' ')[0]) > .1
return [t for t in acc.history(filter_by=['transfer']) if filter(t)]
def run(self):
steemd_nodes = [
'https://api.steemit.com',
]
s = Steemd(nodes=steemd_nodes)
b = Blockchain(s)
while True:
head_block_number = b.info()['head_block_number']
end_block_num = int(head_block_number)
start_block_num = end_block_num - 1
block_infos = s.get_blocks(range(start_block_num, end_block_num))
print('start from {start} to {end}'.format(start=start_block_num,
end=end_block_num))
for block_info in block_infos:
transactions = block_info['transactions']
for trans in transactions:
operations = trans['operations']
self.data.put(operations)
time.sleep(3)
def test_transfer():
wif = '5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3'
c = Commit(steemd_instance=Steemd(nodes=[]), keys=[wif])
rpc_error = None
try:
c.transfer('test2', '1.000', 'STEEM', 'foo', 'test')
except RPCError as e:
rpc_error = str(e)
else:
raise Exception('expected RPCError')
assert 'tx_missing_active_auth' in rpc_error
def override_steemd():
"""override steemd node list for this worker"""
from steem.steemd import Steemd
from steem.instance import set_shared_steemd_instance
global _custom_node
if not _custom_node:
steemd_nodes = [
# GOLOS node
os.getenv('GOLOS_NODE', 'https://ws.golos.io'),
]
set_shared_steemd_instance(Steemd(nodes=steemd_nodes))
_custom_node = True
def health():
steemd = Steemd()
last_db_block = db_last_block()
last_irreversible_block = steemd.last_irreversible_block_num
diff = last_irreversible_block - last_db_block
if diff > app.config['hive.MAX_BLOCK_NUM_DIFF']:
abort(
500,
'last irreversible block (%s) - highest db block (%s) = %s, > max allowable difference (%s)'
% (last_irreversible_block, last_db_block, diff,
app.config['hive.MAX_BLOCK_NUM_DIFF']))
else:
return dict(last_db_block=last_db_block,
last_irreversible_block=last_irreversible_block,
diff=diff,
timestamp=datetime.utcnow().isoformat())
def test_claim_reward():
wif = '5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3'
c = Commit(steemd_instance=Steemd(nodes=[]), keys=[wif])
rpc_error = None
try:
c.claim_reward_balance(account='test',
reward_steem='1.000 STEEM',
reward_vests='0.000000 VESTS',
reward_sbd='0.000 SBD')
except RPCError as e:
rpc_error = str(e)
else:
raise Exception('expected RPCError')
assert 'tx_missing_posting_auth' in rpc_error
def run():
global start_block_num
steemd_nodes = [
steemd_url,
]
s = Steemd(nodes=steemd_nodes)
b = Blockchain(s)
while True:
head_block_number = b.info()['head_block_number']
end_block_num = int(head_block_number)
if start_block_num == 0:
start_block_num = end_block_num - 3
if start_block_num >= end_block_num:
continue
with futures.ThreadPoolExecutor(max_workers=worker_num) as executor:
executor.submit(worker, start_block_num, end_block_num)
start_block_num = end_block_num + 1
def run():
global start_block_num
steemd_nodes = [
'https://rpc.buildteam.io',
'https://api.steemit.com',
]
s = Steemd(nodes=steemd_nodes)
b = Blockchain(s)
while True:
head_block_number = b.info()['head_block_number']
end_block_num = int(head_block_number)
if start_block_num == 0:
start_block_num = end_block_num - 3
if start_block_num >= end_block_num:
continue
with futures.ThreadPoolExecutor(max_workers=worker_num) as executor:
executor.submit(worker, start_block_num, end_block_num)
start_block_num = end_block_num + 1
time.sleep(3)
def run():
global start_block_num
steemd_nodes = [
steemd_url,
]
s = Steemd(nodes=steemd_nodes)
b = Blockchain(s)
create_db()
create_table()
connect_db()
start_block_num_from_db = get_start_num_from_db()
if start_block_num_from_db != 0:
start_block_num = start_block_num_from_db
while True:
head_block_number = b.info()['head_block_number']
end_block_num = int(head_block_number)
if start_block_num == 0:
start_block_num = end_block_num - 3
if start_block_num >= end_block_num:
continue
if end_block_num - start_block_num >= 50:
while start_block_num < end_block_num:
tmp_end_block_num = start_block_num + 50
if tmp_end_block_num > end_block_num:
tmp_end_block_num = end_block_num
with futures.ThreadPoolExecutor(
max_workers=worker_num) as executor:
executor.submit(worker, start_block_num, tmp_end_block_num)
start_block_num = tmp_end_block_num + 1
else:
with futures.ThreadPoolExecutor(
max_workers=worker_num) as executor:
executor.submit(worker, start_block_num, end_block_num)
start_block_num = end_block_num + 1
def test_witness_set_properties():
wif = '5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3'
c = Commit(steemd_instance=Steemd(nodes=[]),
keys=[wif])
signing_key = 'STM1111111111111111111111111111111114T1Anm'
props = [
['account_creation_fee', 'd0070000000000000354455354530000'],
['key', ('032d2a4af3e23294e0a1d9dbc46e0272d'
'8e1977ce2ae3349527cc90fe1cc9c5db9')]
]
rpc_error = None
try:
c.witness_set_properties(
signing_key=signing_key,
props=props,
account='test')
except RPCError as e:
rpc_error = str(e)
else:
raise Exception('expected RPCError')
assert 'tx_missing_other_auth' in rpc_error
def fetch_sbd_balance(nodes, username):
steemd = Steemd(nodes)
balance = steemd.get_account(username)['sbd_balance']
balance = balance.strip(' SBD')
return float(balance)
print(config)
#########################################
# Connections
#########################################
# steemd
#nodes = [
# # 'http://192.168.1.50:8090',
# os.environ['steem_node'] if 'steem_node' in os.environ else 'http://51.15.55.185:8090',
#]
nodes = config['steemd_nodes']
s = Steem(nodes)
d = Steemd(nodes)
b = Blockchain(steemd_instance=s, mode='head')
c = Converter(steemd_instance=s)
fullnodes = [
'https://rpc.buildteam.io',
'https://api.steemit.com',
]
fn = Steem(fullnodes)
# MongoDB
ns = os.environ['namespace'] if 'namespace' in os.environ else 'eostalk'
# mongo = MongoClient('mongodb://mongo')
mongo = MongoClient(config['mongo_url'])
db = mongo[ns]
from steem.steemd import Steemd
from steem import Steem
from steem.instance import set_shared_steemd_instance
from steem.account import Account
from steembase.account import PrivateKey
from steembase.exceptions import AccountDoesNotExistsException
nodes = ['http://steemd.pevo.science']
custom_instance = Steemd(nodes=nodes)
set_shared_steemd_instance(custom_instance)
s = Steem(nodes)
w = s.wallet
file = open("k", "r")
for line in file:
account_values = line.split(",")
account = account_values[1].strip()
key = account_values[0].strip()
# print("key("+key+"),account("+account+")")
try:
acc = Account(account)
privkey = PrivateKey(key)
pubkey = privkey.pubkey
print(account + "," + str(pubkey) + "," + str(privkey) + "," +
str(w.getKeyType(acc, str(pubkey))))
except AccountDoesNotExistsException:
print("account " + account + " does not exists")
import os
# Here you can modify the bot's prefix and description and wether it sends help in direct messages or not. @client.command is strongly discouraged, edit your commands into the command() function instead.
client = Bot(description="Server-Management-Bot",
command_prefix='!',
pm_help=True)
s = Steem()
steemd_nodes = [
'https://api.steemit.com/',
'https://gtg.steem.house:8090/',
'https://steemd.steemitstage.com/',
'https://steemd.steemgigs.org/'
'https://steemd.steemit.com/',
]
set_shared_steemd_instance(Steemd(nodes=steemd_nodes)) # set backup API nodes
cmc = Market() # Coinmarketcap API call.
ste_usd = cmc.ticker("steem", limit="3",
convert="USD")[0].get("price_usd", "none")
sbd_usd = cmc.ticker("steem-dollars", limit="3",
convert="USD")[0].get("price_usd", "none")
react_dict = {}
bot_role = 'marshal' # Set a role for all of your bots here. You need to give them such role on the discord server.
allowed_channels = [
'402402513321721857', #review-linkdrop
'399691348028030989' # testing:
]
'rest_framework.pagination.LimitOffsetPagination',
'PAGE_SIZE': 20
}
import datetime
DEPLOYMENT_DATETIME = environ.get('DEPLOYMENT_DATETIME',
datetime.datetime.utcnow().isoformat())
GOOGLE_ANALYTICS_PROPERTY_ID = environ.get('GOOGLE_ANALYTICS_PROPERTY_ID')
ROCKET_CHAT_LOGIN = environ.get('ROCKET_CHAT_LOGIN')
ROCKET_CHAT_PASSWORD = environ.get('ROCKET_CHAT_PASSWORD')
ROCKET_CHAT_URL = environ.get('ROCKET_CHAT_URL')
STEEM_NODES = [node.strip() for node in environ.get('STEEM_NODES').split(',')]
set_shared_steemd_instance(Steemd(nodes=STEEM_NODES))
STEEM_NODES = [node.strip() for node in environ.get('STEEM_NODES').split(',')]
STEEM_ACCOUNT = environ.get('STEEM_ACCOUNT')
STEEM_POSTING_KEY = environ.get('STEEM_POSTING_KEY')
from steem.wallet import Wallet
Wallet(keys=[STEEM_POSTING_KEY])
PROJECT_GITHUB_REPOSITORY_URL = environ.get('PROJECT_GITHUB_REPOSITORY_URL')
if PROJECT_GITHUB_REPOSITORY_URL.endswith("/"):
PROJECT_GITHUB_REPOSITORY_URL = PROJECT_GITHUB_REPOSITORY_URL[:-1]
PROJECT_SLUG_ON_PAGE = environ.get('PROJECT_SLUG_ON_PAGE')
])
def get_block(block_num):
req = json.dumps({
"jsonrpc": "2.0",
"id": 0,
"method": "call",
"params": [0, "get_ops_in_block", [block_num, False]]
})
res = requests.post('https://api.steemit.com', data=req).json()['result']
return res
if __name__ == '__main__':
s = Steemd(nodes=["https://api.steemit.com"])
start_block_num = s.head_block_number
time.sleep(7)
last_block_num = s.head_block_number
with suppress(KeyboardInterrupt):
while True:
# 블록에서 댓글(reply)만 가져오는 처리
recent_blocks = read_block(start_block_num, last_block_num)
replies = get_replies_from_blocks(recent_blocks)
for reply in replies:
print(reply)
# 블록 번호 갱신
start_block_num = last_block_num
def reconnect(self):
"""Creates a new Steemd and Commit"""
self.steemd = Steemd(nodes=self.nodes.copy(), **self.kwargs.copy())
self.commit = Commit(steemd_instance=self.steemd,
no_broadcast=self.no_broadcast,
**self.kwargs.copy())
from steem.transactionbuilder import TransactionBuilder
from steembase import operations
from steembase.account import PrivateKey
from steembase.memo import get_shared_secret, init_aes, _pad, _unpad
from steem.utils import compat_bytes
from contextlib import suppress
from binascii import hexlify, unhexlify
from collections import OrderedDict
from datetime import datetime
import json
epoch = datetime.utcfromtimestamp(0)
steemd_nodes = ['http://127.0.0.1:8765']
set_shared_steemd_instance(Steemd(nodes=steemd_nodes))
custom_instance = Steemd(nodes=steemd_nodes)
pr = custom_instance.get_chain_properties()
wallet_instance = Wallet(steemd_instance=custom_instance)
def encrypt(priv, pub, nonce, message):
shared_secret = get_shared_secret(priv, pub)
aes, check = init_aes(shared_secret, nonce)
raw = compat_bytes(message, 'utf8')
" Padding "
BS = 16
if len(raw) % BS:
raw = _pad(raw, BS)
" Encryption "
enc_msg = aes.encrypt(raw)
def get():
# get db config
config = utils.get_config()
db_c = config['steem_config']
# connect db
db = pymysql.connect(host=db_c['host'],
user=db_c['user'],
password=db_c['pass'],
database=db_c['db'],
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor,
autocommit=True)
# check lost block first
result = checkLostBlockCache(db, config)
# get synced head_block_num
sql = 'select block_num from block_cache order by block_num desc limit 1'
with db.cursor() as cur:
cur.execute(sql)
res = cur.fetchone()
if res == None:
print('no_block_cache')
curr_cache_head = 0
else:
curr_cache_head = int(res['block_num'])
db.close()
print('curr_cache_head: ', curr_cache_head)
base_step = config['base_step']
# get lastest block_num
steemd_nodes = [
'https://api.steemit.com',
'https://rpc.buildteam.io',
#'https://steemd.privex.io',
#'https://rpc.steemviz.com',
]
s = Steemd(nodes=steemd_nodes)
b = Blockchain(s)
head_block_number = int(b.info()['head_block_number'])
print('blockchain_head', head_block_number)
if head_block_number <= curr_cache_head:
print('It is newest', head_block_number, latest_num)
return []
start_num = curr_cache_head + 1
if head_block_number > start_num + 10000:
end_num = start_num + 10000
else:
end_num = head_block_number
i = start_num
while i <= end_num:
tmp_end_num = i + base_step
if tmp_end_num >= end_num:
tmp_end_num = end_num
result.append({
"task_type": "new_block",
"content": range(i, tmp_end_num + 1)
})
i = tmp_end_num + 1
return result
print(api_url)
worker_num = env_dist.get('WORKER_NUM')
if worker_num == None:
worker_num = 5
print('Worker num: %s' % (worker_num))
worker_num = int(worker_num)
env_block_num = env_dist.get('BLOCK_NUM')
if env_block_num == None:
start_block_num = 0
else:
start_block_num = int(env_block_num)
steemd_nodes = [
steemd_url,
]
s = Steemd(nodes=steemd_nodes)
b = Blockchain(s)
def worker(start, end):
global s, b
print('start from {start} to {end}'.format(start=start, end=end))
block_infos = s.get_blocks(range(start, end + 1))
# print(block_infos)
for block_info in block_infos:
transactions = block_info['transactions']
for trans in transactions:
operations = trans['operations']
for op in operations:
if (op[0] == 'comment' and op[1]['parent_author'] != '') \
or op[0] == 'transfer' \
def test_get_version():
""" We should be able to call get_version on steemd """
s = Steemd()
response = s.call('get_version', api='login_api')
version = response['blockchain_version']
assert version[0:4] == '0.19'
import queue
import threading
import pymysql
check_point_sum = 0
config = utils.get_config()
base_step = config['base_step']
base_thread_count = config['base_thread_count']
steemd_nodes = [
'https://api.steemit.com',
'https://rpc.buildteam.io',
#'https://steemd.privex.io',
#'https://rpc.steemviz.com',
]
s = Steemd(nodes=steemd_nodes, maxsize=base_step*base_thread_count)
b = Blockchain(s)
def processor(task_queue):
global s, b, check_point_sum
while task_queue.qsize():
tasks = task_queue.get()
print('get_blocks_start', tasks)
task_start_time = time.time()
try:
block_infos = s.get_blocks(tasks['content'])
except Exception as e:
print('get_data_from_chain_failed:', tasks, e)
return
print('got_data', tasks)
def test_ensured_block_ranges():
""" Post should load correctly if passed a dict or string identifier. """
s = Steemd()
assert list(pluck('block_num',
s.get_blocks_range(1000,
2000))) == list(range(1000, 2000))
def handle(self, *args, **options):
s = Steemd()
now = datetime.datetime.now()
update_post()
from steem.blog import Blog
from steembase.exceptions import PostDoesNotExist
from textblob import TextBlob
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
from bs4 import BeautifulSoup
steemd_nodes = [
'https://api.steemit.com/', 'https://gtg.steem.house:8090/',
'https://steemd.steemitstage.com/', 'https://steemd.steemgigs.org/'
]
set_shared_steemd_instance(Steemd(nodes=steemd_nodes))
# private posting key from environment variable
POSTING_KEY = os.getenv('POMOCNIK_POSTING_KEY')
# removes markdown and html tags from text
def remove_html_and_markdown(text):
return ''.join(BeautifulSoup(text, 'lxml').findAll(text=True))
def replace_white_spaces_with_space(text):
return text.replace('\t', ' ').replace('\r', ' ').replace('\n', ' ')
def get_message_from_post(post):
def test_get_dgp():
""" We should be able to call get_dynamic_global_properties on steemd """
s = Steemd()
response = s.call('get_dynamic_global_properties', api='database_api')
assert response['head_block_number'] > 20e6