Forked from Steem Engine Airdrop Tool {seairdrop} by The Marky Mark.
Creating a Token on Steem-Engine dot com can be one thing, spreading the love is another. Thanks to a few fellow Steemians though, The Marky Mark and Holger80, it now has become as easy as Py(thon 3). This forked version, ATE, of the original go.py file can also load a separate config file, together with the airdrop file. Instead of go.py it could be named gogo.py.
Easy emission of any Token on Steem-Engine dot com in an airdrop alike fashion, using the Beem Python Module and Python3 on Linux. This version adds user defined loading of Config.JSON in combination with an Airdrop.dat file.
Python3 :: https://www.python.org/downloads/
Beem Python Module :: https://github.com/holgern/beem
Original version :: https://github.com/themarkymark-steem/seairdrop
It is best to use Beem(PY) to first create a (Key-)Wallet. Only to store a Post and an Active key in there. Then secure it with a password. That will be used to unlock the (Key-)Wallet, instead of using the Post and or Active key. The Beem Python Module has all kinds of easy to use commands. And in $BASH (command-line) it is even easier to use beempy to create a (Key-)Wallet. (Use "beempy --help" first.)
After all the needed setups, create a config.json file that has all the settings for a Token emission. First try a so called 'Dry-Run' by setting "dry_run" : true. It all goes well, change it to false and it goes live. Then create an airdrop.dat file in a CSV {Comma Seperated Values} fashion. In there put the name of the Steem account first, then a comma and after that the amount to send. (See the example (s) below the gogo.py source.)
This version is mainly aimed at the 'Transfer' of Steem-Engine dot com Tokens. Although it might seem relatively easy to add some functionality to it to 'Issue' and/or 'Stake'. (Suggestion: Forked code can be put in a reply at 'SteemHub') Maybe create a front-end in Kivy? In essence it is possible to use all kinds of different setups, using unique config and dat files. Even automate it more using data pulled from the Steem blockchain first.
Please note that this is software is something that comes as it is. Use at your own responsibility. And keep the time-out at 10 seconds or more.
Original copyrights by: The Marky Mark.
Some tutorials on Python3, and the usage of Beem, can be found at fellow Steemian Felixxx' his blog.
python3 gogo.py config.json airdrop.dat
import csv
import json
import sys
import time
from beem import Steem
from beem.account import Account
from beem.exceptions import AccountDoesNotExistsException
from beem.instance import set_shared_steem_instance
config = {}
user_list = []
def load_config():
global config
if len(sys.argv) == 1:
print("ERROR: Please specify a config file")
quit()
try:
with open(sys.argv[1]) as config_file:
config = json.load(config_file)
except:
print("Unable to open configuration file")
quit()
def load_users():
global user_list
if len(sys.argv) == 2:
print("ERROR: Please specify airdrop file")
quit()
try:
with open(sys.argv[2]) as user_file:
reader = csv.reader(user_file)
user_list = list(reader)
except:
print("Unable to open airdrop file")
quit()
def build_payload(user, amount):
data = {}
data['contractName'] = 'tokens'
data['contractAction'] = config['mode']
data['contractPayload'] = {}
data['contractPayload']['to'] = user
data['contractPayload']['symbol'] = config['token'].upper()
data['contractPayload']['quantity'] = f"{amount}"
data['contractPayload']['memo'] = config['memo']
return data
def send_tokens(stm, user, amount, retries=0):
data = build_payload(user, amount)
if not config['dry_run']:
try:
stm.custom_json('ssc-mainnet1', data,
required_auths=[config['account_name']])
except:
if retries < 3:
send_tokens(stm, user, amount, retries=retries)
else:
print(f"Airdrop aborted at user: {user[0]}")
quit()
def do_airdrop(stm):
estimated_time = round((len(user_list) * config['delay']) / 60, 1)
estimated_tokens = 0
for user in user_list:
estimated_tokens += float(user[1])
print("Starting Airdrop")
if config['dry_run']:
print("DRY RUN! - Tokens will not be transfered.")
print(f"Estimated Time: {estimated_time} minutes")
print(f"Estimated Tokens Used: {estimated_tokens}")
print("")
for x in range(10, -1, -1):
print(f"Starting in {x} seconds...", end='\r')
time.sleep(1)
sys.stdout.flush()
for user in user_list:
try:
Account(user[0])
except AccountDoesNotExistsException:
print(f"Skipping user {user[0]} - Does not exist")
continue
print(f"Sending {user[1]} {config['token']} tokens to @{user[0]}")
if not config['dry_run']:
send_tokens(stm, user[0], user[1])
time.sleep(config['delay'])
def main():
load_config()
load_users()
stm = Steem(node=["https://api.steemit.com"])
stm.wallet.unlock(config['ww'])
set_shared_steem_instance(stm)
do_airdrop(stm)
if __name__ == '__main__':
main()
gogo.py
config.json
{
"account_name" : "yoursteemaccount",
"ww" : "youkeywalletpwd",
"token" : "TKN",
"memo" : "Here's is some ToKeN for you to enjoy!.",
"mode" : "transfer",
"delay" : 10,
"dry_run" : true
}
config.json
airdrop.dat
holger80, 10000
themarkymark, 1000
felixxx, 1000
oaldamster, 1000
airdrop.dat
Python3 and Beem, a powerfull Steem team.
Screenshot taken at https://www.python.org/downloads/
Please note that SteemHub is merely an idea. Whomever is able to create it for real: Make it so!