Python3 version 0.0.0.1-beta by Oaldamster

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

Load with Config and 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 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.

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 user defined loading of Config.JSON in combination with an Airdrop.dat file.

Supported methods:

Transfer
Issue
Stake

Required:

Python3 :: https://www.python.org/downloads/
Beem Python Module :: https://github.com/holgern/beem
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.)

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

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

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

[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 gogo.py config.json airdrop.dat

FILES

gogo.py
The main file, will do the actual airdropping
config.json
A JSON preferences file
airdrop.dat
A CSV data file that holds the Steem accounts and the values

File: gogo.py

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
}