Python3 version 0.0.1.0-beta by Oaldamster

Originally forked from Steem Engine Airdrop Tool {seairdrop} by The Marky Mark.

[+] Load Config, autoload Airdrop file

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 second version, ATE, of the original go.py file will load a separate config file, that will have the airdrop file loaded. The main file is now called gogogo.py.

About ATE (Sounds like Aid)

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 the user defined loading of a Config-'TokenName'.JSON file. That will point to an Airdrop-'TokenName'.dat file, to be loaded. It is presumed that the .dat files are in a sub-folder. Relative to the working directory.

Supported methods:

Transfer
[-] Issue
[-] Stake

Required:

Python3 :: https://www.python.org/downloads/
Beem Python Module :: https://github.com/holgern/beem

Eventually for reference:

Original version :: https://github.com/themarkymark-steem/seairdrop

How to use

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, if you are new to BEEM.)

After all the needed setups, create a config-'tokename'.json file that has all the settings for a Token emission. First try a so called 'Dry-Run' by setting "dry_run" : true. (Make that a default setting.) If it all goes well, change it to false and it goes live. Then create an airdrop-'tokenname'.dat file, in a sub-folder, 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 gogogo.py source.)

Notes

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 seAirdrop project by: The Marky Mark.

Some tutorials on Python3, and the usage of Beem, can be found at fellow Steemian Felixxx' his blog.

(Developed on a Linux driven Laptop by Oaldamster.)

[x] Use it with a combination of unique config. json and airdrop.dat files.
[-] Make it work for 'Issue' and 'Stake', right out of the box.
[-] Switch between different servers.
[-] Create a GUI, in Kivy for instance. :: https://kivy.org/#download
[-] Grab data from Steem blockchain, then create a Transfer list, completely automated.

[+] Command line

python3 gogogo.py config-tkn.json

(Where tkn is the one to be send.)

[+] FILES

gogogo.py
The main file, will do the actual airdropping
./config-'tokenname'.json
A JSON preferences file, in the same folder as gogogo.py
data/airdrop-'tokenname'.dat
A CSV data file that holds the Steem accounts and the values, in a data subfolder.

\FILE: gogogo.py

#
# Automated Token Emission, ATE, for Steem
# A fork from the Steem Engine Airdrop project, by The Marky Mark 
# Version 202002120850 - 0.0.1.0 - beta, by Oaldamster
# 

# Import some Python modules

import csv
import json
import sys
import time
import os

# Import the Beem Steem module by Holger80

from beem import Steem
from beem.account import Account
from beem.exceptions import AccountDoesNotExistsException
from beem.instance import set_shared_steem_instance

# Some global variables

config = {}
user_list = [] 

# Get the Current Working Directory
# Assume files are stored relative from here

current_Dir = os.getcwd() + "/"
print (current_Dir) 
load_Configfile = current_Dir + (sys.argv[1])

# Load the config file

def load_config():  
    global config

    if len(sys.argv) == 1:
        # Instead of this create a default?
        print("ERROR: Please specify a config file")
        quit()
    else:
        print (load_Configfile)

    try:
        with open(load_Configfile) as config_file:
            config = json.load(config_file)
            print(f"Loading emission file: {config['loadfile']}\n")

    except:
        print("Unable to open configuration file")
        quit()                 

# Load the user list to airdrop to

def load_users():
    global user_list
    
    # Add Try etc later
    if config['loadfile']:  
        get_file = current_Dir + config['data_path'] + config['data_file'] + "-" + config['token'] + "." + config['data_file_ext']
        try:
            with open(get_file) as user_file:   
                reader = csv.reader(user_file)
                user_list = list(reader)
                print("Loaded emission file.\n")
            
        except:
            print("Unable to open emission file")
            quit()

# Build from the data to store on the Steem blockchain          
            
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

# Hey Hoo, let's go! Send them Tokens

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()

# Prepare for launch, check for Dry Run.

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\n")

    if config['dry_run']:
        print("DRY RUN! - Tokens will not be transfered.\n")
    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'])

# The main file, ground control

def main():
    print("\n")

    load_config()
    load_users()

    stm = Steem(node=["https://api.steemit.com"])
    stm.wallet.unlock(config['pw'])
    set_shared_steem_instance(stm)

    do_airdrop(stm)

# Start it all

if __name__ == '__main__':
    main()

/FILE: gogogo.py ####

\FILE: config.json

{
    "dry_run" : true,
    "account_name" : "youraccount",
    "pw" : "beemwalletopenup", 
    "token" : "tokenname",
    "memo" : "A message, could be a random qoute even.", 
    "issue_first" : false,
    "mode" : "transfer", 
    "loadfile" : true,
    "data_path" : "data/",
    "data_file" : "airdrop",
    "data_file_ext" : "dat",
    "delay" : 10
}

/FILE: config.json ####

\FILE: airdrop.dat

    smasssh, 10
    meesterboom, 10
    mistakili, 5
    geekgirl, 5
    rodino, 5

/FILE: airdrop.dat ####

Testing ATE with some ENGAGE.

Screenshot taken at https://steem-engine.com

Please note that SteemHub (STMhub?) is merely an idea. Whomever is able to create it for real: Make it so!

SteemHub: Automated Token Emission 202002120850