def withdraw(self, account, amount):
"""Widthdraw STEEMP to account as STEEM.
:param str account: account name
:param float amount: Amount to withdraw
Withdraw example:
.. code-block:: python
from steemengine.market import Market
from beem import Steem
active_wif = "5xxxx"
stm = Steem(keys=[active_wif])
market = Market(steem_instance=stm)
market.withdraw("test", 1)
"""
wallet = Wallet(account, api=self.api, steem_instance=self.steem)
token_in_wallet = wallet.get_token("STEEMP")
if token_in_wallet is None:
raise TokenNotInWallet("%s is not in wallet." % "STEEMP")
if float(token_in_wallet["balance"]) < float(amount):
raise InsufficientTokenAmount("Only %.3f in wallet" % float(token_in_wallet["balance"]))
token = Token("STEEMP", api=self.api)
quant_amount = token.quantize(amount)
if quant_amount <= decimal.Decimal("0"):
raise InvalidTokenAmount("Amount to transfer is below token precision of %d" % token["precision"])
contract_payload = {"quantity":str(quant_amount)}
json_data = {"contractName":"steempegged","contractAction":"withdraw",
"contractPayload":contract_payload}
tx = self.steem.custom_json(self.ssc_id, json_data, required_auths=[account])
return tx
def check_config(config, necessary_fields, stm):
config_cnt = 0
token_config = {}
token_list = Tokens()
for conf in config:
config_cnt += 1
# check if all fields are set
all_fields_ok = True
for field in necessary_fields:
if field not in conf:
logger.warn("Error in %d. config: %s missing" %
(config_cnt, field))
all_fields_ok = False
if not all_fields_ok:
continue
# Check if scot_account exists (exception will be raised when not)
Account(conf["scot_account"], steem_instance=stm)
# Check if scot_token exists
if token_list.get_token(conf["scot_token"]) is None:
logger.warn("Token %s does not exists" % conf["scot_token"])
continue
scot_wallet = Wallet(conf["scot_account"], steem_instance=stm)
scot_token = scot_wallet.get_token(conf["scot_token"])
logger.info("%s has %s token" %
(conf["scot_account"], str(scot_token)))
token_config[conf["scot_token"]] = conf
if len(token_config) == 0:
raise Exception("Broken config, shutdown bot...")
logger.info("%d configs were found." % len(token_config))
return token_config
def sell(self, account, amount, symbol, price):
"""Sell token for given price.
:param str account: account name
:param float amount: Amount to withdraw
:param str symbol: symbol
:param float price: price
Sell example:
.. code-block:: python
from steemengine.market import Market
from beem import Steem
active_wif = "5xxxx"
stm = Steem(keys=[active_wif])
market = Market(steem_instance=stm)
market.sell("test", 1, "ENG", 0.95)
"""
wallet = Wallet(account, api=self.api, steem_instance=self.steem)
token_in_wallet = wallet.get_token(symbol)
if token_in_wallet is None:
raise TokenNotInWallet("%s is not in wallet." % symbol)
if float(token_in_wallet["balance"]) < float(amount):
raise InsufficientTokenAmount("Only %.3f in wallet" % float(token_in_wallet["balance"]))
token = Token(symbol, api=self.api)
quant_amount = token.quantize(amount)
if quant_amount <= decimal.Decimal("0"):
raise InvalidTokenAmount("Amount to transfer is below token precision of %d" % token["precision"])
contract_payload = {"symbol": symbol.upper(), "quantity":str(quant_amount), "price": str(price)}
json_data = {"contractName":"market","contractAction":"sell",
"contractPayload":contract_payload}
tx = self.steem.custom_json(self.ssc_id, json_data, required_auths=[account])
return tx
import six
import requests
import getpass
beem_pass = "" # Password to unlock beem wallet
api = Api()
tokens = Tokens()
token = Token("TMPS")
stm = Steem()
market = Market(steem_instance=stm)
wallet = Wallet("tmps", steem_instance=stm)
wallet2 = Wallet("market", steem_instance=stm)
stm.wallet.unlock(pwd=beem_pass)
blacklist = ["market", "tokens", "null", "tmps"]
dragon_token = wallet.get_token("TMPS")
wallet.refresh()
upvote_account = "ufm.pay"
adjusted_dragon = float(dragon_token["balance"]) * 0.95
balances = token.get_holder()
info = token.get_info()
max_post_age_days = 6
min_post_age = 5
whitelist = []
blacklist_tags = []
only_main_posts = True
sell_tokens = ["SPORTS", "NEOXAG", "PHOTO", "PAL"]
def seller():
print("started selling")
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import sys
from datetime import datetime, timedelta
import time
import io
import logging
from beem import Steem
from steemengine.wallet import Wallet
from beembase import transactions, operations
log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
if __name__ == "__main__":
stm = Steem()
stm.wallet.unlock(pwd="wallet_pass")
wallet = Wallet("beembot", steem_instance=stm)
dragon_token = wallet.get_token("DRAGON")
if dragon_token is not None and float(dragon_token["balance"]) >= 0.01:
print("balance %.2f" % float(dragon_token["balance"]))
print(wallet.transfer("holger80", 0.01, "DRAGON", "test"))
else:
print("Could not sent")
time.sleep(15)
wallet.refresh()
dragon_token = wallet.get_token("DRAGON")
print("new balance %.2f" % float(dragon_token["balance"]))
wallet = Wallet("ufm.pay")
# edit here
upvote_account = "ufm.pay"
upvote_token = "KITTENS"
token_weight_factor = 1 # multiply token amount to get weight
kitten_ratio = 20
stm = Steem()
stm.wallet.unlock(pwd="")
wallet = Wallet(upvote_account, steem_instance=stm)
stamps = []
whitelist = []
blacklist = ["market", "tokens"]
last_steem_block = 1950 # It is a good idea to store this block, otherwise all transfers will be checked again
while True:
main_token = wallet.get_token("CATS")
history = api.get_history(upvote_account,
upvote_token,
limit=1000,
offset=0,
histtype='user')
for h in history:
if int(h["block"]) <= last_steem_block:
continue
if h["to"] != upvote_account:
continue
last_steem_block = int(h["block"])
if len(whitelist) > 0 and h["from"] not in whitelist:
print("%s is not in the whitelist, skipping" % h["from"])
continue
if len(blacklist) > 0 and h["from"] in blacklist:
def run(self, start_block):
self.stm.wallet.unlock(self.config["wallet_password"])
self.blockchain = Blockchain(mode='head', steem_instance=self.stm)
stop_block = self.blockchain.get_current_block_num()
if start_block is not None:
last_block_num = start_block - 1
self.log_data["start_block_num"] = start_block
for op in self.blockchain.stream(start=start_block,
stop=stop_block,
opNames=["comment"],
max_batch_size=50):
self.log_data = print_block_log(self.log_data, op,
self.config["print_log_at_block"])
last_block_num = op["block_num"]
if op["type"] == "comment":
token = None
for key in self.token_config:
if op["body"].find(
self.token_config[key]["comment_command"]) >= 0:
token = key
if token is None:
continue
if op["author"] == self.token_config[token]["token_account"]:
continue
try:
c_comment = Comment(op, steem_instance=self.stm)
c_comment.refresh()
except:
logger.warn("Could not read %s/%s" %
(op["author"], op["permlink"]))
continue
if c_comment.is_main_post():
continue
if abs((c_comment["created"] -
op['timestamp']).total_seconds()) > 9.0:
logger.warn("Skip %s, as edited" % c_comment["authorperm"])
continue
already_replied = False
for r in c_comment.get_all_replies():
if r["author"] == self.token_config[token][
"token_account"]:
already_replied = True
if already_replied:
continue
muting_acc = Account(self.token_config[token]["token_account"],
steem_instance=self.stm)
blocked_accounts = muting_acc.get_mutings()
if c_comment["author"] in blocked_accounts:
logger.info("%s is blocked" % c_comment["author"])
continue
# Load bot token balance
bot_wallet = Wallet(self.token_config[token]["token_account"],
steem_instance=self.stm)
symbol = bot_wallet.get_token(
self.token_config[token]["symbol"])
# parse amount when user_can_specify_amount is true
amount = self.token_config[token]["default_amount"]
if self.token_config[token]["user_can_specify_amount"]:
start_index = c_comment["body"].find(
self.token_config[token]["comment_command"])
stop_index = c_comment["body"][start_index:].find("\n")
if stop_index >= 0:
command = c_comment["body"][start_index +
1:start_index + stop_index]
else:
command = c_comment["body"][start_index + 1:]
command_args = command.replace(' ', ' ').split(" ")[1:]
if len(command_args) > 0:
try:
amount = float(command_args[0])
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn("%s - %s - %s" %
(str(exc_type), str(fname),
str(exc_tb.tb_lineno)))
logger.info("Could not parse amount")
if self.token_config[token][
"maximum_amount_per_comment"] and amount > self.token_config[
token]["maximum_amount_per_comment"]:
amount = self.token_config[token][
"maximum_amount_per_comment"]
if not self.config["no_broadcast"] and self.stm.wallet.locked(
):
self.stm.wallet.unlock(self.config["wallet_password"])
self.log_data["new_commands"] += 1
wallet = Wallet(c_comment["author"], steem_instance=self.stm)
token_in_wallet = wallet.get_token(
self.token_config[token]["symbol"])
if token_in_wallet is not None:
balance = float(token_in_wallet["balance"])
if "stake" in token_in_wallet:
balance += float(token_in_wallet['stake'])
if 'delegationsIn' in token_in_wallet and float(
token_in_wallet['delegationsIn']) > 0:
balance += float(token_in_wallet['delegationsIn'])
if 'pendingUnstake' in token_in_wallet and float(
token_in_wallet['pendingUnstake']) > 0:
balance += float(token_in_wallet['pendingUnstake'])
if balance > self.token_config[token][
"min_token_in_wallet"]:
if self.token_config[token][
"token_in_wallet_for_each_outgoing_token"] > 0:
max_token_to_give = int(
balance / self.token_config[token]
["token_in_wallet_for_each_outgoing_token"])
else:
max_token_to_give = self.token_config[token][
"maximum_amount_per_comment"]
else:
max_token_to_give = 0
else:
max_token_to_give = 0
db_data = read_data(self.data_file)
if "accounts" in db_data and c_comment["author"] in db_data[
"accounts"] and token in db_data["accounts"][
c_comment["author"]]:
if db_data["accounts"][c_comment["author"]][token][
"last_date"] == date.today(
) and self.token_config[token][
"token_in_wallet_for_each_outgoing_token"] > 0:
max_token_to_give = max_token_to_give - db_data[
"accounts"][c_comment["author"]][token]["amount"]
if amount > max_token_to_give:
amount = max_token_to_give
if amount > self.token_config[token][
"maximum_amount_per_comment"]:
amount = self.token_config[token][
"maximum_amount_per_comment"]
if token_in_wallet is None or float(
token_in_wallet["balance"]
) < self.token_config[token]["min_token_in_wallet"]:
reply_body = self.token_config[token]["fail_reply_body"]
elif max_token_to_give < 1:
reply_body = self.token_config[token][
"no_token_left_for_today"]
elif c_comment["parent_author"] == c_comment["author"]:
reply_body = "You cannot sent token to yourself."
elif float(symbol["balance"]) < amount:
reply_body = self.token_config[token]["no_token_left_body"]
else:
if "{}" in self.token_config[token]["sucess_reply_body"]:
reply_body = (self.token_config[token]
["sucess_reply_body"]).format(
c_comment["parent_author"])
else:
reply_body = self.token_config[token][
"sucess_reply_body"]
if "{}" in self.token_config[token]["token_memo"]:
token_memo = (
self.token_config[token]["token_memo"]).format(
c_comment["author"])
else:
token_memo = self.token_config[token]["token_memo"]
sendwallet = Wallet(
self.token_config[token]["token_account"],
steem_instance=self.stm)
try:
logger.info(
"Sending %.2f %s to %s" %
(amount, self.token_config[token]["symbol"],
c_comment["parent_author"]))
sendwallet.transfer(c_comment["parent_author"], amount,
self.token_config[token]["symbol"],
token_memo)
if "accounts" in db_data:
accounts = db_data["accounts"]
else:
accounts = {}
if c_comment["author"] not in accounts:
accounts[c_comment["author"]] = {}
accounts[c_comment["author"]][token] = {
"last_date": date.today(),
"n_comments": 1,
"amount": amount
}
elif token not in accounts[c_comment["author"]]:
accounts[c_comment["author"]][token] = {
"last_date": date.today(),
"n_comments": 1,
"amount": amount
}
else:
if accounts[c_comment["author"]][token][
"last_date"] < date.today():
accounts[c_comment["author"]][token] = {
"last_date": date.today(),
"n_comments": 1,
"amount": amount
}
else:
accounts[c_comment["author"]][token][
"n_comments"] += 1
accounts[c_comment["author"]][token][
"amount"] += amount
store_data(self.data_file, "accounts", accounts)
logger.info(
"%s - %s" %
(c_comment["author"],
str(accounts[c_comment["author"]][token])))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn(
"%s - %s - %s" %
(str(exc_type), str(fname), str(exc_tb.tb_lineno)))
logger.warn("Could not send %s token" %
self.token_config[token]["symbol"])
continue
reply_identifier = construct_authorperm(
c_comment["parent_author"], c_comment["parent_permlink"])
if self.config["no_broadcast"]:
logger.info("%s" % reply_body)
else:
try:
self.stm.post(
"",
reply_body,
author=self.token_config[token]["token_account"],
reply_identifier=reply_identifier)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn(
"%s - %s - %s" %
(str(exc_type), str(fname), str(exc_tb.tb_lineno)))
logger.warn("Could not reply to post")
continue
if self.token_config[token]["usage_upvote_percentage"] > 0:
try:
c_comment.upvote(self.token_config[token]
["usage_upvote_percentage"],
voter=self.token_config[token]
["token_account"])
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn("%s - %s - %s" %
(str(exc_type), str(fname),
str(exc_tb.tb_lineno)))
logger.warn("Could not upvote comment")
time.sleep(4)
return last_block_num
def run(self, start_block):
self.stm.wallet.unlock(self.config["wallet_password"])
self.blockchain = Blockchain(mode='head', steem_instance=self.stm)
stop_block = self.blockchain.get_current_block_num()
if start_block is not None:
last_block_num = start_block - 1
self.log_data["start_block_num"] = start_block
for op in self.blockchain.stream(start=start_block, stop=stop_block, opNames=["comment"], max_batch_size=50):
self.log_data = print_block_log(self.log_data, op, self.config["print_log_at_block"])
last_block_num = op["block_num"]
if op["type"] == "comment":
token = None
for key in self.token_config:
if op["body"].find(self.token_config[key]["comment_command"]) >= 0:
token = key
if token is None:
continue
if op["author"] == self.token_config[token]["scot_account"]:
continue
try:
c_comment = Comment(op, steem_instance=self.stm)
c_comment.refresh()
except:
logger.warn("Could not read %s/%s" % (op["author"], op["permlink"]))
continue
if c_comment.is_main_post():
continue
if abs((c_comment["created"] - op['timestamp']).total_seconds()) > 9.0:
logger.warn("Skip %s, as edited" % c_comment["authorperm"])
continue
already_replied = False
for r in c_comment.get_all_replies():
if r["author"] == self.token_config[token]["scot_account"]:
already_replied = True
if already_replied:
continue
# Load scot token balance
scot_wallet = Wallet(self.token_config[token]["scot_account"], steem_instance=self.stm)
scot_token = scot_wallet.get_token(self.token_config[token]["scot_token"])
# parse amount when user_can_specify_amount is true
amount = self.token_config[token]["maximum_amount"]
if self.token_config[token]["user_can_specify_amount"]:
start_index = c_comment["body"].find(self.token_config[token]["comment_command"])
stop_index = c_comment["body"][start_index:].find("\n")
if stop_index >= 0:
command = c_comment["body"][start_index + 1:start_index + stop_index]
else:
command = c_comment["body"][start_index + 1:]
command_args = command.replace(' ', ' ').split(" ")[1:]
if len(command_args) > 0:
try:
amount = float(command_args[0])
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno)))
logger.info("Could not parse amount")
if not self.config["no_broadcast"] and self.stm.wallet.locked():
self.stm.wallet.unlock(self.config["wallet_password"])
self.log_data["new_commands"] += 1
wallet = Wallet(c_comment["author"], steem_instance=self.stm)
token_in_wallet = wallet.get_token(self.token_config[token]["scot_token"])
if token_in_wallet is None or float(token_in_wallet["balance"]) < self.token_config[token]["min_staked_token"]:
reply_body = self.token_config[token]["fail_reply_body"]
elif c_comment["parent_author"] == c_comment["author"]:
reply_body = "You cannot sent token to yourself."
elif float(scot_token["balance"]) < amount:
reply_body = self.token_config[token]["no_token_left_body"]
else:
if "%s" in self.token_config[token]["sucess_reply_body"]:
reply_body = self.token_config[token]["sucess_reply_body"] % c_comment["parent_author"]
else:
reply_body = self.token_config[token]["sucess_reply_body"]
if "%s" in self.token_config[token]["token_memo"]:
token_memo = self.token_config[token]["token_memo"] % c_comment["author"]
else:
token_memo = self.token_config[token]["token_memo"]
sendwallet = Wallet(self.token_config[token]["scot_account"], steem_instance=self.stm)
try:
logger.info("Sending %.2f %s to %s" % (amount, self.token_config[token]["scot_token"], c_comment["parent_author"]))
sendwallet.transfer(c_comment["parent_author"], amount, self.token_config[token]["scot_token"], token_memo)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno)))
logger.warn("Could not send %s token" % self.token_config[token]["scot_token"])
continue
reply_identifier = construct_authorperm(c_comment["parent_author"], c_comment["parent_permlink"])
if self.config["no_broadcast"]:
logger.info("%s" % reply_body)
else:
try:
self.stm.post("", reply_body, author=self.token_config[token]["scot_account"], reply_identifier=reply_identifier)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno)))
logger.warn("Could not reply to post")
continue
if self.token_config[token]["usage_upvote_percentage"] > 0:
try:
c_comment.upvote(self.token_config[token]["usage_upvote_percentage"], voter=self.token_config[token]["scot_account"])
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno)))
logger.warn("Could not upvote comment")
time.sleep(4)
return last_block_num