While at TLG (Telos Launch Group) we are busy in preparations and rehearsals for launching a new live Telos Blockchain Network (TBN), I thought I should explain how it works. It is probably based on more SIMPLE, EASY & TRANSPARENT steps than you have ever imagined.

The steps are easy, straight forward, and no rocket science is needed. Technically it is a simple and straight forward process. However it is sensitive work, and minor mistakes can cause huge implications. Error margin is 0%. So thorough testing, validation, and tests-of-time is needed. The more testing is done prior to go live, the better… It is more complicated to agree on administrative processes, administrative parameters, token metrics, and 100% accuracy in TLOS Token values allocations and appropriate Resources (CPU, NET, RAM) allocations.

I will probably publish couple of posts and videos (if time allows me) on these aspects:

Please you may refer to https://developers.eos.io/eosio-nodeos/docs/bios-boot-sequence for details of these standard steps/principals!

  • Build & Install EOSIO (e.g. Telos) Code
  • Launch an EOSIO (e.g. Telos) Genesis node
  • Create Important System Accounts
  • Install/Push system contracts
  • Create and Allocate Tokens with agreed distribution
  • Transition from single Producers to multiple Producers
  • Create and Inject EOSIO Blockchain Network (e.g. Telos Genesis Snapshots)
  • Create any Special Accounts (as needed) and inject any pre-decided Tokens/Currency (e.g. Community, and Founders rewards if any…)
  • Freeze LIB
  • Share genesis file and genesis node with closed users group and sync
  • Share closed user groups node IPs and genesis file with general public
  • Allow time for BPs and public to AUDIT, VALIDATE, and INSPECT contracts and accounts on chain for correctness and integrity
  • Unfreeze LIB
  • β€œRetire” EOSIO account
  • BPs create their accounts and register as producers (regproducer)
  • Start of Initial Voting

Purpose

The purpose of these posts is to help both TLG (Telos Launch Group) and general public to follow the process and validate the “CORRECTNESS”, and “INTEGRITY” of any EOSIO Blockchain Network. Again the focus is on Processes, Steps, Procedures, “not” on individual parameters (as they are subject to change). It will also make it easy for anyone to launch a new EOSIO Blockchain Network or sister Telos Chain (if needed).

Note 1:

Please note that the focus is on principles and process. The focus is not on parameters, configurations, token distribution as they will be different in different cases. Also in case of Telos, some of the settings have not yet been agreed (& they are subject to change) .

Note 2:

Telos development team(s) have implemented several demanding and amazing features and capabilities on top of EOSIO source code base. That is a huge work and has been thoroughly function tested by them. In these posts I am “not” talking about development related testing. These posts are focusing on purely launch related activities.

Today, in this post let’s go through some of the above steps. I am using ubuntu 18.04 VM.

Build & Install TELOS (EOSIO) Code

For details you may also refer to https://developers.eos.io/eosio-nodeos/docs/bios-boot-sequence , but, remember these pages my not be updated as often as code changes. So there may be some syntax issues. Moreover when it comes to Telos some of the commands have been changed (not the same as EOSIO). But you can get very clear understanding about launching a test and live network from this link.

First you need to download/clone Telos master branch

git clone https://github.com/Telos-Foundation/telos

Checkout the latest tag. At the time of writing this post it is dev2.7

cd telos/
git checkout tags/dev2.7

Pull down the files.

git submodule update –init –recursive

Build Telos by following command:

./telos_build.sh

Once build is completed you will see this:

Finally install Telos utilities by:

sudo ./telos_install.sh

After successful install you will see this window

Launch a TELOS (EOSIO) Genesis node

Now you are almost ready to launch a TELOS (EOSIO) Genesis node. The “genesis” node is the first nodeos that we need to start. It will give birth to a new blockchain. All other nodes will derive from this genesis node.

First you need to create a wallet, then generate a Key-Pair for the eosio account. Please note that the same wallet can be used for all key management for all accounts in test cases (however it is not recommended). In this demonstration we will use only one wallet. In a distributed deployment, wallet management should be only a local activity.

nodeos comes pre-configured with a default key pair. Do not use this default key pair. Create a new key pair to be used for the eosio account when starting the genesis node.

./build/programs/teclos/teclos –wallet-url http://127.0.0.1:4999 wallet create -n {wallet-name} –file {wallet-filename}
./build/programs/teclos/teclos create key –file {filename}

Let’s import the key in the wallet:

./build/programs/teclos/teclos –wallet-url http://127.0.0.1:4999 wallet import -n {wallet-name} –private-key {private-key}

Configure the “genesis.json” file.

The genesis.json file defines the initial chain state. All nodes must start from the same initial state. Two properties in particular are important:

  • The initial_timestamp: It represents the start time of the blockchain.
  • The initial_key is used by the genesis node to start producing. It needs to be the same among all nodes.
  • The initial_key property in genesis.json must match the public key of the genesis nodeos. The nodeos key pair can be specified using the –private-key argument on the nodeos command line, or by setting the private-key property in the config.ini file.

This is our genesis.json:

{
“initial_key”: “EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh”,
“initial_configuration”: {
“max_transaction_delay”: 3888000,
“min_transaction_cpu_usage”: 100,
“net_usage_leeway”: 500,
“context_free_discount_net_usage_den”: 100,
“max_transaction_net_usage”: 524288,
“context_free_discount_net_usage_num”: 20,
“max_transaction_lifetime”: 3600,
“deferred_trx_expiration_window”: 600,
“max_authority_depth”: 6,
“max_transaction_cpu_usage”: 150000,
“max_block_net_usage”: 1048576,
“target_block_net_usage_pct”: 1000,
“max_generated_transaction_count”: 16,
“max_inline_action_size”: 4096,
“target_block_cpu_usage_pct”: 1000,
“base_per_transaction_net_usage”: 12,
“max_block_cpu_usage”: 200000,
“max_inline_action_depth”: 4
},
“initial_timestamp”: “2018-10-25T09:35:00.000”
“initial_chain_id”: “0000000000000000000000000000000000000000000000000000000000000101”
}

Configure the “config.ini” file.

Before we start the genesis node, using the above generated key pair, let’s configure some parameters in

config.ini file. If you do not have existing config.ini file, then run nodeos to generate a default config file. To generate a config.ini file in the current directory if none exists, execute:

nodeos –config-dir ./

You can also download a sample config file from https://github.com/eossweden/Telos-EOSIO-Scripts/blob/master/config.ini

Here are some of the important parameters (for details, please look at above link)

roducer-name = eosio
signature-provider = EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh=KEY:{Private-Key}
agent-name = “swedencornet eosio (TELOS/EOS Sweden)”
blocks-dir = “./blocks_Genesis_node”
wallet-dir = “/media/sf_sharefolder/wallet/telos/test/telos_TEST_Wallets”
http-server-address = 0.0.0.0:4001
p2p-listen-endpoint = 0.0.0.0:4002
p2p-server-address = XXX.XXX.XXX.XXX:4002

Start the genesis nodeos node

Now you should be ready to start the genesis nodeos node by:

nodeos –delete-all-blocks –genesis-json genesis.json

You can check if the nodeos process is running:

Create Important System Accounts

Now it’s time to create several system accounts (that are needed). These are standard EOSIO system accounts:

  1. eosio.bpay
  2. eosio.msig
  3. eosio.names
  4. eosio.ram
  5. eosio.ramfee
  6. eosio.saving
  7. eosio.stake
  8. eosio.token
  9. eosio.vpay

in addition to them, Telos has implemented additional system accounts (this list is subject to change):

  1. eosio.trail
  2. eosio.amend
  3. eeosio.arb
  4. eosio.bpmins or/and eosio.bpadj [as said above subject to change]
  5. eosio.arb
  6. eosio.exrsrv

NOTE: For most general accounts, it is a good practice (and recommended) to use separate and unique key-pairs for owner and active. However for this demonstration we will use the same key-pair for all of the “eosio.*” accounts (as well as for both the account owner and active keys).

./build/programs/teclos/teclos create key –file {filename}
./build/programs/teclos/teclos –wallet-url http://127.0.0.1:4999 wallet import -n {wallet-name} –private-key {private-key}

There is a script at https://github.com/eossweden/Telos-EOSIO-Scripts/blob/master/create_system-accounts.sh and it looks like this:

#!/bin/bash
NODEOS_BINDIR=”/home/telos-latest/telos/build/programs”
API_HOST=”127.0.0.1″
API_PORT=”4901″
WALLET_HOST=”127.0.0.1″
WALLET_PORT=”4999″
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.bpay EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.vpay EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.msig EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.names EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.ram EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.ramfee EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.saving EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.stake EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.token EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.trail EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.amend EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.work EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.arb EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.exrsrv EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT create account eosio eosio.bpmins EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]

Install/Push system contracts

We now need to Install/Push following system contracts (some of them are subject to change due to ongoing Telos development):

Note that the contracts are located under folder build at ./telos/build/contracts/ directory.

  • eosio.token contract
  • This contract enables you to create, issue, transfer, and get information about tokens.
  • eosio.msig contract
  • This contract enables and simplifies defining and managing permission levels and performing multi-signature actions.
  • eosio.system contract
  • This contract provides the actions for pretty much all token-based operational behavior. Prior to installing the system contract, actions are done independent of accounting. Once the system contract is enabled, actions now have an economic element to them. Now resources (cpu, network, memory) must be paid for, new accounts must be paid for, etc. The system contract enables:
  • -> tokens to be staked and unstaked,
  • -> resources to be purchased,
  • -> potential producers to be registered and subsequently voted on,
  • -> producer rewards to be claimed,
  • -> privileges and limits to be set, and more.

Telos specific contracts (subject to change)

  • eosio.amend contract
  • This contract is about ratify, amend functionalities.
  • eosio.bpmins contract
  • This contract is about enforcing BP minimum requirements.
  • eosio.trail contract
  • eosio.savingwork contract
  • This is about Worker Proposal Fund.
  • eosio.arb contract
  • This contract is about arbitration.

Telos specific contracts mentioned above are under function/code testing (at the time of writing this). Let’s push these contracts and generate needed TLOS tokens in a single small script written below.

Let’s Install/Push system contracts with the commands/scripts as shown below with TLOS Token creation.

Create and Allocate Tokens with agreed distribution

Create and Issue TLOS Tokens with appropriate memos and agreed distribution (All of these numbers are subject to change)

  • Create 10,000,000,000.0000 –> (subject to change)
  • Issue 178473249.3124 – Genesis Snapshot Issue –> (subject to change)
  • Issue 6M – Telos Founders Reward Pool Issue –> (subject to change)
  • Issue 1M – Telos Community Reward Pool Issue –> (subject to change)
  • Issue 140279973 – Exchange Pool Issue –> (subject to change)
  • Issue 6M – Telos Foundation Issue –> (subject to change)
  • Issue 25000 – for RAM Buy –> (subject to change)

#!/bin/bash
NODEOS_BINDIR=”/home/telos-latest/telos/build/programs”
CONTRACTS_DIR=”/home/telos-latest/telos/build/contracts”
API_HOST=”127.0.0.1″
API_PORT=”4901″
WALLET_HOST=”127.0.0.1″
WALLET_PORT=”4999″
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT set contract eosio.token $CONTRACTS_DIR/eosio.token
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT set contract eosio.msig $CONTRACTS_DIR/eosio.msig -p eosio.msig
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token create ‘[ “eosio”, “10000000000.0000 TLOS”, 0, 0, 0]’ -p eosio.token
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token issue ‘[ “eosio”, “178473249.3124 TLOS”, “Genesis Snapshot” ]’ -p eosio
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token issue ‘[ “eosio”, “6000000.0000 TLOS”, “Telos Founders Reward Pool Issue” ]’ -p e$
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token issue ‘[ “eosio”, “1000000.0000 TLOS”, “Telos Community Reward Pool Issue” ]’ -p $
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token issue ‘[ “eosio”, “6000000.0000 TLOS”, “Telos Foundation Issue” ]’ -p eosio
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token issue ‘[ “eosio”, “140279973.0000 TLOS”, “Exchange Pool” ]’ -p eosio
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio.token issue ‘[ “eosio”, “25000.0000 TLOS”, “Genesis Account RAM Issue” ]’ -p eosio
$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT set contract eosio $CONTRACTS_DIR/eosio.system -p eosio

Transition from single producer to multiple producers

Now it is time to transition from a single block producer (the genesis node) to multiple producers. Up to this point, only the built-in eosio account has been privileged and can sign blocks. However, we need to manage the blockchain by a collection of elected producers operating under a rule of 2/3 + 1 producers agreeing before a block is final.

As you know Producers are chosen by election. So, the list of producers can change. We should never give privileged authority directly to any producer. We must associate governing rules with a special built-in account named eosio.prods. This account represents the group of elected producers. The eosio.prods account (effectively the producer group) operates using permissions defined by the eosio.msig contract.

We must, as soon as possible after installing the eosio.system contract, make eosio.msig a privileged account so that it can authorize on behalf of the eosio account. As soon as possible, eosio should resign its authority and eosio.prods should take over.

Make “eosio.msig” a privileged account

$NODEOS_BINDIR/teclos/teclos –url http://$API_HOST:$API_PORT –wallet-url http://$WALLET_HOST:$WALLET_PORT push action eosio setpriv ‘[“eosio.msig”, 1]’ -p [email protected]

Create and Inject Telos Genesis Snapshots

Now it is time to take EOS Genesis Snapshot and create a Telos Snapshot based on agreed criteria (as stated in Telos Whitepaper)

The EOS Genesis Snapshot can be found here: https://github.com/Telos-Foundation/snapshots

You can use script to create Telos Snapshot based on agreed criteria (as stated in Telos Whitepaper). The mathematics behind to calculate TLOS tokens per account is following (subject to change):

To figure liquid:

  • if amt <=3 then .1
  • if amt >3 and <=11 then 2
  • if amt > 11 then 10

To figure CPU and BW Stake

  • Total amt – liquid = remainder
  • Remainder / 2 = CPU
  • Remainder – CPU = BW

Each created account should get 4KiB of memory on injection

You can get the script from here: https://github.com/eossweden/Telos-EOSIO-Scripts/blob/master/generate_Telos_Account_Ballances_csv.py

import csv
import math
f = open(‘/opt/TELOSmainNet-2-dev2.5/snapshots/tlos_genesis_snapshot.csv’)
csv_f = csv.reader(f)
i = 1
TLOS_LIQ = 0
TLOS_CPU = 0
TLOS_NET = 0
TLOS_TOTAL = 0
def roundup(a, digits=0):
n = 10**-digits
return round(math.ceil(a / n) * n, digits)
for row in csv_f:
genesis_account = row[2]
EOS_PubKey = row[3]
TLOS_TOTAL = float(row[4])
TLOS_LIQ = 0.1
if TLOS_TOTAL > 3 and TLOS_TOTAL <= 11:
TLOS_LIQ = 2
if TLOS_TOTAL > 11:
TLOS_LIQ = 10
remainder = TLOS_TOTAL – TLOS_LIQ
TLOS_CPU = float(‘{0:.4f}’.format(remainder / 2))
TLOS_NET = remainder – TLOS_CPU
print str(i) +’,’+ genesis_account + ‘,’ + EOS_PubKey + ‘,’ + ‘{:.4f}’.format(float(TLOS_TOTAL)) + ‘,’ + ‘{:.4f}’.format(float(TLOS_CPU)) + ‘,’ + ‘{:.4f}’.format(float(TLOS_NET)) + ‘,’ + ‘{:.4f}’.forma$
i+=1

Inject TLOS Tokens and accounts

Once you have created TLOS Snapshot, it is now time to Inject TLOS Tokens and accounts. How do you do that? You have to do this with script and it could take some time depending on computing resources available.

Again you can get the script from here: https://github.com/eossweden/Telos-EOSIO-Scripts/blob/master/inject_Telos_snapshot.py

import csv
import os
f = open(‘/opt/TELOSmainNet-2-dev2.5/scr-snapshots/telos_snapshot_generatecsv_JT.csv’)
csv_f = csv.reader(f)
NODE_HOST = “/home/telos-sources-dev2.5/telos/build/programs”
i=1
for row in csv_f:
EOS_account = row[1]
EOS_key = row[2]
total = row[3]
CPU = row[4]
NET = row [5]
LIQ = row[6]
create_Account = NODE_HOST + “/teclos/teclos –url http://127.0.0.1:9001 system newaccount -x 100 –transfer –stake-net “” + NET + ” TLOS” –stake-cpu “” + CPU + ” TLOS” –buy-ram-kbytes 4 eosio ” + EOS_account + ” ” + EOS_key
transfer_Balance = NODE_HOST + “/teclos/teclos –url http://127.0.0.1:9001 transfer eosio ” + EOS_account + ” “” + LIQ + ” TLOS” “Telos Liquid tokens from genesis balance. You are Welcome to Telos echo system!””
os.system(create_Account)
os.system(transfer_Balance)
i+=1

Now you are almost done.

Create any Special Accounts (as needed) and inject any pre-decided Tokens/Currency (e.g. Community and Founders rewards)

The final step remaining in the genesis node preparation is to create any Special Accounts (as & if needed) and inject any pre-decided Tokens/Currency (e.g. Community and Founders rewards). Now for Telos, the special accounts to be created with pre-decided Tokens/Currency have (and will be) published at (subject to change):

https://github.com/Telos-Foundation/snapshots

https://github.com/Telos-Foundation/snapshots/blob/master/telos_special_accounts.csv

Let’s create these 4 special accounts and transfer agreed TLOS amounts:

tf (6M – Telos Founders Reward Pool) –> subject to change
tf.frp (6M – Telos Foundation Issue) –> subject to change
tf.crp (1M – Telos Community Reward Pool)
tf.exrsrv (140279973 – Exchange Pool) –> subject to change

Again, you can find the script here: https://github.com/eossweden/Telos-EOSIO-Scripts/blob/master/special-accounts.sh

#!/bin/bash
NODEHOST=”127.0.0.1″
NODEPORT=”4901″
WALLETHOST=”127.0.0.1″
WALLETPORT=”4999″
NODEOS_BINDIR=”/home/telos-latest/telos/build/programs”
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT system newaccount -x 100 –transfer –stake-net “2999995 TLOS” –stake-cpu “2999995 TLOS” –buy-ram-kbytes 4 eosio tf EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT transfer eosio tf “10 TLOS” “Let’s make JERRY Happy. He is a GREAT Man”
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT system newaccount -x 100 –transfer –stake-net “2999995 TLOS” –stake-cpu “2999995 TLOS” –buy-ram-kbytes 4 eosio tf.frp EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT transfer eosio tf.frp “10 TLOS” “Let’s make JERRY Happy. He is a GREAT Man”
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT system newaccount -x 100 –transfer –stake-net “499995 TLOS” –stake-cpu “499995 TLOS” –buy-ram-kbytes 4 eosio tf.crp EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT transfer eosio tf.crp “10 TLOS” “Let’s make JERRY Happy. He is a GREAT Man”
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT system newaccount -x 100 –transfer –stake-net “70139981.5 TLOS” –stake-cpu “70139981.5 TLOS” –buy-ram-kbytes 4 eosio tf.exrsrv EOS8fbkx2bWToPZd3s8MT5esMYvcECftmDYWnq8Rh3eNBA2fRd1qh “[email protected]
$NODEOS_BINDIR/teclos/teclos –url http://$NODEHOST:$NODEPORT –wallet-url http://$WALLETHOST:$WALLETPORT transfer eosio tf.exrsrv “10 TLOS” “Let’s make JERRY Happy. He is a GREAT Man”

After you have created all the needed accounts and transferred agreed TLOS tokens, you are ready to share genesis file and genesis node with TLG (Telos Launch Group) and sync. Once done properly it can be shared for the general public to perform any AUDIT, VALIDATION, and INSPECTION of contracts and accounts on chain for correctness and integrity checks.

I will probably post additional posts for these steps and as stated above many parameters are subject to change.

NOTE: As said earlier it is more or less straight forward and easy process technically to launch a new EOSIO Blockchain Network. However due to sensitive nature, lot of testing is needed to ensure zero errors. There is no room for any errors. And if any errors are detected, then, the above process has to be repeated until everything is 100% accurate.

15 votes, average: 5.00 out of 515 votes, average: 5.00 out of 515 votes, average: 5.00 out of 515 votes, average: 5.00 out of 515 votes, average: 5.00 out of 5 (15 votes, average: 5.00 out of 5)
You need to be a registered member to rate this.
(1533 total tokens earned)
Loading...

Responses

    1. GobieDesertCanoePro

      I understand to collect TLOS tokens we need to interact with the TLOS network, which means via the SQRL wallet I assume. Is there another way to get the tokens? Anyway, do we need to input genesis EOS private keys into the SQRL wallet? If so, couldn’t you guys have crafted a less scary way to go about things?

      (0)