First moments after installation of GRIDNET Core

Hi Guys
Well I’ve dived in and installed GRIDNET Core I’ve also updated my phone and been able to install the token app.
I have some screenshots of some apparent issues which would seem to be important

I am not sure if UDT is functioning , the installation does appear to have enabled TCP/UDP through the windows firewall settings and I have enabled those ports through my router.

I am also getting a critical error for the TDR.

When I attempt to check out the VI interfaces as per the ‘brief introductory for operators’ I don’t get the view described therein.

Could it be that I have misconfigured something in the enabling of TCP/UDP .
Please take the time to assist I would really appreciate your help

1 Like

Hello there Jamie, it is nice to have you around!

Let me take a look…

GRIDNET Core discovered nodes through a customized version of Kademlia protocol (similar mechanics used say by Torrent and or Bitcoin). The purpose of the protocol is discovery of other ⋮⋮⋮ Nodes, without reliance on any points of trust (which would effectively impose centralization).

⋮⋮⋮ Core has a couple of IP addresses embedded into its source code, which it uses as ‘bootstrap’ nodes, through which the entire world-view is discovered.

Now, none of the IP addresses listed on your screen snippet belong to these. Meaning? These are some stale entries maintained by (some of) the nodes, these nodes are most likely already gone, and yet your ⋮⋮⋮ Node was informed of their presumed existence and so it tries to talk to them (which fails and you get an indication in red).

The UDT is functioning, we can tell, since the log mentions at least a couple of cases in which your ⋮⋮⋮ Node received notifications about new blocks (ex. from That happened through the data-exchange sub-protocol (over UDT).

Now, as for this - the reason why ⋮⋮⋮ Core indicates the error in red and as critical is to grab the ⋮⋮⋮ Operator’s attention. Let me explain.

GRIDNET Core employs computational devices available on your computer to compute what is called as Proof-of-Work. Such operations could be carried out solely by your CPU but as you might know, floating point operations are way faster on GPUs.

Thanks to the OpenCL library - ⋮⋮⋮ Core can employ both CPUs and GPUs (and even other hardware such as compatible sound-cards) - all in the aim of securing the network with each and every computation made.

As an ⋮⋮⋮ Operator, you get to choose which devices to enable. ⋮⋮⋮ Core is rather smart about this and it prefers dedicated GPUs over integrated ones (if available).

Without going much more into the details, let of focus on the TDR value. In short, TDR is the maximum time period, the operating system allows the GPU to be doing calculations. During first launch, ⋮⋮⋮ Core would try to tweak the value all by itself (in the Microsoft Window’s Registry) so that you do not have to. Still, for this it needs to be launched as an Administrator (just as the log entry suggests above the phrase in red).

Should you not wish to grant Core administrative privileges or should you just wish to get to know more on this very topic - a good article is here.

While computing, ⋮⋮⋮ Core would constantly try to optimize what it’s doing based on the current results.

Worry not my friend, the reason why you’re not seeing what’s desired is probably rather vague.

Try typing sct testnet first. Why? ⋮⋮⋮ Core supports multiple ‘networks’ to be served by a single instance of the Software (i.e. test-net , live-net, local sandbox etc.). As an Operator, you need to specify the ‘target of your commands’. You do so through the Set Commit Target (sct) command. It needs to be done only once.

I hope this helps. Should you have additional questions, do not hesitate…

No bugs spotted here though so the conversation is being moved…

If you let Core run at least once with Administrative privileges next time it starts you would see something reassembling the line below:

Yet again, one may choose to tweak the value by hand through regedit.

1 Like

Hi Vega4
Thank you very much indeed for responding and I note what you have said .
I have then run as Administrator I did not see

1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2 on the start up .
the system however seemed to be running well and my node appeared to be participating as it should and I have also been able to access the vi interfaces as per your reminder on ‘sct testnet’ first.

I have today attempted to generate an ID token however I got this far

Have I missed something in the process ?

There’s a tutorial covering the process of Identity Tokens’ deployment.

Now, let me take a look…

The terminal says that there’s no code to commit. For code which is to permanently affect the system, you want to use the Begin Transaction -> Commit Transaction pattern. How? Simple.

  1. First run BT (for Begin Transaction).
  2. Run any other instructions (these would be compiled on the fly).
  3. Finally type CT (for Commit Transaction) to commit.
  4. The system would request your authentication (QR Intent would need to ba scanned by the mobile app).

In your case you’ve most likely forgotten the BT part.

You may use VT (View Transaction) anytime to view what’s being compiled.

The rabbit goes way deeper, but that’s enough to know when compiling a single (the default) decentralized thread spawned in a single SSH session.

If you choose not to follow the Begin Transaction -> Commit Transaction pattern, instructions that you type affect the sandbox only. Sandbox is a virtual state of the entire system spawned for your very session only. The interesting part is that GRIDNET OS is very efficient in generating such virtual states.

You may then see the results, but these would never affect the system. If you want to affect the system, follow the aforementioned pattern.

Hope that was of some help.

Hi CodesInchaos
Your response was indeed helpful and
Thank you for it.
Yes I did previously follow that tutorial and yes it appears that I did miss entry ‘BT’, so I’ve just tried again and managed to get to the final stages ,I was happy ,but then …

Aside from my general ineptitude as you can see , I eventually got round to inputting the public key from my mobile app and receipt ID.
what I don’t get is why my public key is not recognised as it originates from the mobile app and is that associated with the address and I inputted the receipt ID as shown on the screen.

we’ve all started somewhere and we’ve all got further paths to pave.

am I right to assume that you’ve used the -p switch as a standalone command a couple of times?

-p is a switch to the genid command, used to set the public-key parameter.

One needs to provide it to genid (along with any other required parameters).

genid -p PUBLIC_KEY

Well I’m the path, I want to see decentralisation we must have it and I want to be part of that even if I stumble from time to time .
I will assimilate what you have said ,try again and report.

… on the path I meant :grimacing:
Now I’m pretty sure I’ve done it right this time
however I have the following :

I generated ID -p that is my public key from the mobile app(and obviously associated with my address ) , -f name , -r the receipt 3hHj…g94WF
I did the above but transaction was aborted due to an error.

Next time kindly do paste the commands you’ve tried to run in text so that we do not need to rely on image-to-text recognition software to reproduce the situation.

Let’s take a look:

the error says that the transaction receipt is wrong (so it probably is), - the value which you’ve passed through the ‘-r’ switch.

I’ve used the getresult command followed by tte receipt id you’ve provided.

getresult 3hHjRNL4nmqBcM2xfZVofo3x9fat8gVo6B5n8WVcBBj4Yg94WF
that’s what I got:

The ‘sacrificial’ transaction must have failed to be even broadcasted throughout the network, which is why the genid utility is unable to retrieve it, just like it reports.

The receipt is is generated as soon as the transaction is generated and transmitted to full-nodes for processing. It does not mean that the transaction went through though.

The fact that it is even unknown means that:

  • either it did not make its way to full-nodes for processing at all (network down etc).

  • nodes were unable to even authenticate the transaction (invalid signature etc). which is when it wouldn’t be even included into the history of events.

Were the above not true, you would have received a reason for why it was deemed to be invalid, when executing getresult.

Yes next time I will paste the commands in text ,I sent the screenshot so you could know what I had inputted
was correctly done on the system.
What do you suggest I do ,try again?

try again, and

*make sure the ‘sacrificial transaction’ went through just fine (use the getresult command)

*only then, try to register the Identity Token

Thanks will do and thanks for being patient with this useless neophyte.

It is not that. You are helping us and all the others, through testing.
Even if you fail, it is a sign to us that some things could be made either more intuitive or improved in any other possible way.
Keep in mind that we are building all the time; the reliability and/or stability might not be top-notch at all times, and also all the typical wonders of decentralization do apply i.e. - a transaction might not get processed due to a variety of reasons.

What I’m trying to say is - thank you for being with us and thank you for testing. Each and every day brings all of us closer towards the Glory of Decentralization.

Hello vega4
I appreciate your words and I am happy to help and to be a tiny part of your epic journey.
Well over the past couple of weeks I have been attempting to succeed in the registering of the ID token ,again I have not been successful.
I feel that I have been following the process correctly, each time I do so it appears that another different issue manifests I enclose a couple of such attempts for your consideration in txt .
transaction terminal (32.7 KB)

@jamie ok, I will take a look and report.

Hello @jamie , it is wonderful to be hearing back from you!:sparkles:

Let me relate to the logs you’ve provided.

First log ends with:

:warning:Killing your session due to inactivity…

$ Connection to closed by remote host.

Connection to closed.

If you stop typing for a certain amount of time, the ⋮⋮⋮ Node you are connected with, it would terminate the connection to save on resources. That is normal.

Second log is way more interesting - let us take a look, shall we…
Notice @jamie that we have made the ‘Preformatted text’ image formatting tool-button, - the one available here at Talk GRIDNET, compatible with the output coming from GRIDNET Core.

So next time, you may copy-paste from GRIDNET Core directly over here and it would render the very same way as seen on your own computer.

~~ Welcome Anon2721😻! Wizards🧙 wishing you a nice stay 🙏 ~~

Fetching recent Wall messages..
Your session is currently the only active one. Feel at home☕.
I'm initializing your remote session, please hold on..
Initializng #GridScript VM
[Transaction Manager]: Waiting for myself to become ready..
GridScript 1.0.0
Type "about"for more information. Type "bye"to exit.
Entering SandBox mode.
You've got 10000000 ERG💰 available.
[Transaction Manager]: I'm ready, commencing further..
[Transaction Manager]: Running
Your Decentralized Terminal(DTI) is now ready.  You may proceed.
Views: [CTRL+Q] - chat, [CTRL+W]) - events [CTRL+E] - Shell
Type 'logmein' to authenticate with your 📱
$ cd 1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2
Welcome!🦄 Access to local security storage not granted.
You'll need to authenticate with GRIDNETToken🔑 on commit.
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ bt
Ad-Hoc Transaction formulation began. You may proceed.
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ vt
[Printing source-code]:
0: cd
-> 1: '/1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2/'
Word Count: 1 Length: 41 Bytes
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ sacrifice 1
✅ Sacrifice made!
Previous Balance: 15.20 GNC (15200000000000000776 Atto Units)
 New Balance: 15.20 GNC (15200000000000000775 Atto Units)
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ ct
Attempting to Commit the Transaciton..
Sacrificial Transaction of 1 GBUs has ✓valid semantics.
🙏Commencing further..
About to show the QR Intent. Resize ↕ the Terminal if needed.
----  SCAN the QR-code below with your GRIDNEToken  ----
 █ ▄▄▄▄▄ █▀ ▄███▄  ▀▀▄▄▄ ▄▄  █▀ ▄ ▀  ███▀▀ █ ▄▄▄▄▄ █
 █ █   █ █▄█ ▄█ ▄▄▀▄▄ ▀  █████▄  ▄█▀ ▄▄██ ▄█ █   █ █
 █ █▄▄▄█ █ █▀▄▄█▀▀██▄▀ █ ▄▄▄ ▀▄▀ █ ▄█▀▀ ▀███ █▄▄▄█ █
 █▄▄▄▄▄▄▄█ ▀▄█▄▀ █▄█▄█▄▀ █▄█ ▀ ▀▄█ █ █ █ █▄█▄▄▄▄▄▄▄█
 █▄▄█ ▀▀▄▄▀ ▀▄▀█▀█▄▀▄▄█▀▄ ▄ ▄▄▄▄█▄█▄▄█ █▄███▄  ▀▄▄▀█
 █▀▀█▄▀▀▄▄▀ ▄█ █ ▄ ▄▄ ▀▄█▄██▀██▀█▄▀▄███▄▀▀▀▀██▄█▄█ █
 █▄██ ▄▀▄█▄█ ▄▀  █    ▄ ▀ ▄ █▄  ▄ ▄█▀▄  ▄█ █▄█ ▀█▀▀█
 █▀ █ ██▄▄▄ █  █▄▄ ▀▀ ▄ █▀▄██  ▀█ ▀▀▄▀▄ ▄█▀█  █▀▄▀▄█
 █▄▀ ▀▄▄▄  ██▀▄█▄█▄▄ █▀ ▄▄▄ ▀▄█ ▄▀▄▄█▄ █ ▄▄ ▄█▄▄▄█▄█
 ██▀▄ ▀█▄█ ▀ ▀██▀▀█▄█ █▄▀█  █▄▀▀█▀▀ ▄█▀▀▄▀▀██▀▄▄▀ ▄█
 ██▀▀ ▄▀▄▄▀▄  ▄ ▀███▄█▄ ██ █▄ ▄█▄▀▀██ ▄▄██▄▄█▄█  ▄██
 ██▄▄█ ▄▄▄ ██▄▀▀▄█▄▄ ▀▄  ▄▄▄ ▀ ▄ ▀▄████ ██ ▄▄▄ ██ ▄█
 ██▀▄  █▄█  ▄▄▀ ▄█ ▄ ▀▄█ █▄█ ▄ ▀▄▄ █   ▀██ █▄█ ▀   █
 █▄ ▀█▄▄▄▄ ██▄█ ██▄▀ █    ▄▄▄█▀▀█▄▀███▀▄▀▄▄  ▄▄█▄▀▄█
 █▀██▀ ▀▄▄▀█ █▄▄▄█▄  ▀▀ ▀ ▄▄  ▀ ▄▀▄█▄▄▄█▀█ █▀█ █▄███
 █▀ ▄▀▀▀▄██▄▄ ▄██▀█▀▀▄▄██ █  ███▄  ▀▀ ▄▄█▀▄▄▄▀██   █       ↕ WINDOW IF NEEDED
 █ █▄ ▀▀▄ ▀██▄█ ▀█▄█▄██▀ ▀█▀▄▄ ▀█▀▀███ █▄██▄  ▄  ▄▄█
 █ █▄██ ▄▀ █▄ ▄▀▄▀▀ ▄▀   ▀██▄ █▄▀▄▄█▄    █▀▀ ▄▀▄▄ ▄█
 █▀   ▀ ▄ █ ▄█ █▄█▀█  ▄▀████▄▄▄█▄  █ ▄▄ █████ █ ▀█ █
 ██ ▀▀█▄▄█ ▀█▄▀▄█▄█  ██▀█▄▀▄▀▄  ▀▄▀▄▄▀ █▀▀ █ ▄▀▄▄▄▄█
 █▄▄▄███▄▄▀██ ▄▀▄▄█▀ ▄ ▄ ▄▄▄ ██▀▄▀ ▀▄  █ ▀ ▄▄▄    ██
 █ ▄▄▄▄▄ █▄▀█ █▄▀  ▄ ▀▄  █▄█ █▄  ▀▀ ▀ ▀▀██ █▄█ █▀ ▄█
 █ █   █ █▀ ▀▀▄ ▄██▀ ██▄    ▄▄ ▄▄▀█▄██ ▄▄█  ▄▄▄▀█▄ █
 █ █▄▄▄█ █▀█ ▄▄█ ▄▄█ ▄ ▀▄  █ █▀▀▄ █▄██ ▄█ ▀ █▀ ▄████
✅ Success. Valid QRIntent-Response received.
✅ Transaction registered at the Local Miner.
Receipt🔖: 3L3aCHSwA2AkfcpKAyQshgKvr1k9GhuLonYeXdXKa73WBipgot
Attempting to publish transaction within the TestNet Network..
✅ Success: Transaction Published.
[⚠WARNING #1]: Your session is about to end in 30 seconds due to inactivity..
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ genid
-p - base58-encoded pubKey (required)
-f - friendly ID (optional)
-r - receiptID of the Sacrificial Transaction (optional)
-n - nonce (optional) if PoW is to be registered
-i - additional (optional) info
-m - IoT address (optional)
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ genid -p 21qResD7JWQZwKzzr2SQpfBYGytY7QqM
TEVtRigaXQbm6TuPtV -f lavender -r 3L3aCHSwA2AkfcpKAyQshgKvr1k9GhuLonYeXdXKa73WBi
Base58-Encoded ID-Token put onto the stack. Type 'regID' to register
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ regid
✅ Successfully registered an ID Token for 8J1QYGQgo8PXqQBf7XfjFSW8EkbZhnv31Q8U
1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ ct
Attempting to Commit the Transaciton..
❎There's no code to commit in nested VMs.
[Blockchain Manager]: Exception v: False (There's no code to commit in nested VM

Dear @jamie I so much appreciate your will and stubbornness of not having given up.

Let me say, that as I had proposed in our previous encounter, it is always good to check whether the transaction was not only ‘published’ but also whether it was ‘processed’ and if so - to check for the ‘processing result’ .

Like I had advised previously, one may use the getresult GridScript command/utility for the very that.

I took the receipt identifier from the log which you’ve been so kind to provide.

Let us see:

$ getresult 3L3aCHSwA2AkfcpKAyQshgKvr1k9GhuLonYeXdXKa73WBipgot
Receipt 🔖 retrieved: 3L3aCHSwA2AkfcpKAyQshgKvr1k9GhuLonYeXdXKa73WBipgot
Transaction result : ✅ Valid Transaction

Wonderful, congratulations Operator! :sparkles:

Seems like your Sacrificial Transaction was successfully processed.

This means - it was not only processed by the full-node to which you were connected to over SSH, but the full-node compiled the code, and broadcasted the resulting (signed by you) code bundle (compiled bytecode) to other nodes and thus the instructions which you have executed during a SSH session affected the entire Network. Congratulations !

Sacrificial transactions serve as a kind of a Proof of Stake.

Your money is never truly lost.

It always serves a purpose , still that shall not be the topic here, as we have a task at hand which is to aid you - a highly respected Operator, with the trouble you are having at hand, and to do so at once

So the question is, - why did the latter parts fail?

The answer is - Operator, as had been explained to you previously, at least so I do recall, after you’ve committed the first Transaction, you need to initiate a new Begin Transaction (BT) ↔ Commit Transaction (CT) sequence if you will the results of your further actions to still be affecting the entire decentralized state machine. That is of in utmost importance.

Otherwise, no ‘broadcastable’ code would be being generated, as you interact with the system, and thus your actions would only be able to affect the ephemeral Sandbox,- one spawned for your SSH session only. As yet again, no broadcastable byte-code is being formulated.

After each commit the transaction formulation state - it terminates. It is assumed to be Completed. You need a new one.

So, when do you need to begin a new Begin Transaction (BT) ↔ Commit Transaction (CT) sequence ?

The answer is - right after the the node said:

✅ Success: Transaction Published.

Notice: you might always want to wait and check for the result of processing (getresult, remember? :cowboy_hat_face:), before proceeding with a new one. Also, before initiating a new BT command, it would be also good to use the sync command to ensure that the state of your ⋮⋮⋮Terminal is synchronized with the current state of the ⋮⋮⋮ Decentralized State Machine! Why? Some other events might have taken place, Operator you might not the only person, issuing actions concerning your State Domain and it is always good to ensure you see it’s current state.

Yet again, if you do not begin a new transaction, no code would be being generated under the hood, and so there would be nothing to Commit, through the Commit Transaction (CT) command! The one which you have tried to execute for a second time by the end of your log. Such an operation is indeed doomed to fail, just as the node you are connected to reports:
❎There's no code to commit in nested VMs.

@jamie would you be so kind to point me to the tutorial you’ve been following? I’ll tripple check if the process was described right.

Yet again, thank you @jamie for you work, let us keep striding further - towards the Glory of Freedom and Decentralization!

Hi Vega4
Well thank you very much for your gentle manner and kind words and for the full and quick response.
Yes, the point in me providing the first log was not to query the time out it was to illustrate the fact that the session would not proceed at all, from the usual process of inputting my address which leads to …

Welcome!🦄 Access to local security storage not granted.

You'll need to authenticate with GRIDNETToken🔑 on commit.

1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ bt

Ad-Hoc Transaction formulation began. You may proceed.

1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ vt 

No joy, no return value to proceed with…

You can see I then tried ( as the session text directs ‘Type ‘logmein’ to authenticate with your’ )
$ cd logmein

No joy again

I note that I had never used that command before and then I re inputted

$ cd1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2

No joy
This kind of situation happened quite a lot the sessions would not be allowed to re set and start again which I presume one should be able to do given that we are in a sandbox environment .

The second log, This is the tutorial I followed
I know you had advised me re the ‘getresult’ and it was my intention to do so
my understanding (rightly or wrongly) was that when the token ID had been successfully registered all the sandbox data would be present and would then be committed to the DSM by the (CT) command.
You advise that I needed to have begun a new Begin Transaction (BT ) ↔ Commit Transaction (CT ) sequence right after
✅ Success: Transaction Published

Does that mean I have to input all the previous steps to register again, I am somewhat confused as from the tutorial I followed it appears that after …

1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ regid
✅ Successfully registered an ID Token


1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ ct
Attempting to Commit the Transaciton..

the process is done however as you know from the log I was presented with…
❎There's no code to commit in nested VMs

If that had been successful my thinking would have been to input ‘getresult’ I would then have proceeded with the mob app as per the tutorial and would then type sync.
Thanks for your time Vega4 Glory and freedom shall prevail :smile:

@jamie, I just took a look at your first log.

the log has this:

$ cd logmein

which has not point at all.
logmein is a command used to … well… log you in. Instead what try to achieve is to use cd to enter a directory whose name is expected to be ‘logmein’ - as you understand - that cannot work.

Below, is the output of a proper usage of legemein command.

$ logmein
About to show the QR Intent. Resize ↕ the Terminal if needed.
----  SCAN the QR-code below with your GRIDNEToken  ----
 █ ▄▄▄▄▄ █▄ ▀█▄██ █ █▀▀▄▄▄▄ ██▀ ▄▀█▀█▀▄█ ▄▄▄▄▄ █
 █ █   █ █  ▄▄▄▄▄█  ▀ ▀  █ ████▀█▀███ ▀█ █   █ █
 █ █▄▄▄█ █▄▀▄ ▄▄▀▄█ ▄▀ ▄▄▄   ▄▀▀▀▀▄▄▄▄▄█ █▄▄▄█ █
 █▄▄▄▄▄▄▄█▄█ ▀▄█▄█▄█▄▀ █▄█ ▀ ▀ █▄█ █▄█▄█▄▄▄▄▄▄▄█
 █  ▄ ▀█▄█▄  █ █▄█▄ ▀▀▄▄▄▄ █▄█▄▀ █▀▄▄▀▀ ██ ▄ ▀▄█
 █ ▄  ▄█▄▄  ▀▄   ▄▀  ▄▄▀ █▀▄██▀ █▄ ▄█ ▄ ▄▄▄▀█ ▄█
 █ ▄▀▀▄▀▄▀▀▀ ▀█▄▀▀█ ▄█▀▄▄▄▀▀ ███▄▄█ ▄ █ ▀▀█▀▄▀ █
 ██ ██ ▀▄█▄ █ ▀ █▀ █▄ █▄█▄██▄▄▄▀▄██ ▀▄███▀  ▀▀██
 █▀ ▀▀▄▀▄▄█ █▄▀█▄▄  ▀█▄▄█▄█▄█ ███  ▀▀▀▄▀▄ ▀█▄▀██
 █ ▀ █▄█▄▄▄ █ ██▄▄▄ ▄ ▀▀█  █  ▀▄█▀█▄█ █▄  ▀▄▄▄██
 █▄█▀▀ ▄▄▄ ▄█▄ ██ █ ▀█ ▄▄▄ ▀█ ▄ ▀██▄█  ▄▄▄ ▄▄█▀█
 █  █▀ █▄█ ███▄ ▀██▀▀█ █▄█ ▄▀▄▀▄█▀▀▄█▄ █▄█ ▄█  █
 █ ▀  ▄▄▄▄  ▄ ▄▄  █▄▄▀▄   ▄  ▀███▄█▀▄▀▄ ▄ ▄ █▄ █
 █  ▀█▄▄▄ █ ▀▄▀  ▄ ▀█ ██▄ ▀ ▄█▀▄▄██ ▄ █ ▀▀ ▀ ▀▀█           ↕ WINDOW IF NEEDED
 ████▄█▀▄  ▄▄▀█▄▄▀ ▀██ ▄▀ ▄▄█ ▀█▄▄▄ ▀ ▀▀█ ▀▄▄▀██
 █▀▄▀▀▄█▄ █▀▀  ▀▀█▀▀█▀██▀█▄█ ▀█ █▀██ ██ ▀ █▄▄ ██
 █ █▀ ▀▀▄▀▀ █▀█ ███▄▀▀  ▄▀▀▀█   ▀ █▄▄█▄▄▄ ██▄▄▄█
 ██▀▀▀ █▄▄▄▄█  ▀▀▄▀▀█▀█▄ ▀█▀█ █ ▄▀█▄█▄ █ █  █  █
 █▄██▄▄█▄▄ █▀▄█ ▀▀█▄ ▄ ▄▄▄   ▄▀▀█ █ ▄▀ ▄▄▄  ████
 █ ▄▄▄▄▄ ██▀▀▄ █ ▄▀▀▄  █▄█ █▄  ▄▄ ▀▀█  █▄█  ▀███
 █ █   █ █▀█ ██ █ ▀ ▀█▄   ▄██▄█▀▄▀ █        ▄▄▄█
 █ █▄▄▄█ █  █ ▄ ▀ ▄   █ ▄█▄█ █▄██ █▀  ▄▀ ▀▀█▄█ █
|-[ 📱Scan QR [172] ]-|

As you may see above, once logmein is invoked alone (without any parameter) it would show a QR Intent. The QR Intent, once scanned through the GRIDNET Token mobile app, - it would take you automatically to your home directory.

@jamie kindly remember to wrap outputs from GRIDNET Core with image :pray: You may it within the upper toolbar, visible while editing your posts.


@jamie notice that it is perfectly normal for VT to report no code (which could be compiled and broadcast afterwards) right after having used the BT - as indeed - there is not code yet.

Notice that in your case there’s no need for you to use logmein whose sole-purpose is to authenticate you with the node, to set your nickname within the global chat, load all your customizations and to take you to your home directory… however for our task at hand… there is no need for that.

you forgot about white space after ‘cd’, not?

I’ve just checked the Tutorial. Seems like there’s one step missing indeed.

See this?

Before proceeding with the above

  1. make sure your transaction is committed by using getresult (we already know it is).

  2. cd into your home-directory.

  3. use bt to begin a new code sequence.

  4. proceed further with the tutorial as seen below:

$ cd 1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2

Welcome!🦄 Access to local security storage not granted.

You’ll need to authenticate with GRIDNETToken🔑 on commit.

1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ genid -p 23ZBwZfGcwSykunTd61CGzmkDuXdJTqf

4AfBHpkpDXtKcwc7KN -f HappyDuck -r 3L3aCHSwA2AkfcpKAyQshgKvr1k9GhuLonYeXdXKa73WB


Base58-Encoded ID-Token put onto the stack. Type ‘regID’ to register

1MmshiakvDJWJ5GMGSavzR9SYDXCzLmoW2:/ $ regid

I’ve tried to proceed in Sandbox with your sacrificial transaction just like you may see above and it worked. Make sure to use a public-key of your own though! after having used regid , simply use ct just like the Tutorial instructs. You would be then asked to scan a QR Intent again.

Let me know how it works for you.

Nope. The tutorial is simply missing the need to begin a new code-sequence after the sacrificial transaction was issued and broadcasted across the network.

See, the tutorial effectively is about broadcasting two code packages. Thus, one needs to commit procedures. Two Begin Transaction (BT) ↔ Commit Transaction (CT) sequences, as each results in a new code-bundle being broadcasted across the network. Why so? Code in the second part of the tutorial needs to reference the Sacrificial Transaction, which already needs to be registered and processed by the decentralized state machine! Thus, the process needs to be split across two entirely separate steps.

In other words, you first need to make a sacrifice. You sacrifice a certain amount of assets. Right? The sacrificial transaction would need to be processed by the entire network. So you use a dedicated Begin Transaction (BT ) ↔ Commit Transaction (CT ) sequence during which you make the sacrifice. The Begin Transaction (BT ) ↔ Commit Transaction (CT ) sequence sort of records what you type. After you are done you use CT to compile code and to broadcast it (in our case, instructions used for making a sacrifice) across the entire network.

After the transactions has been processed (if might had not!) which is why I’ve advised you to use getresult, - you then use the receipt identifier (the very same you use with getresult) with the genid utility.

But now you are to be formulating yet another code-bundle which is to be processed by the entire network.

The new code bundle is entirely separate from the previous one (which contained the sacrificial transaction). In fact it needs to be, as a code bundle containing a Sacrificial Transaction may the the only one - for security reasons.

The genid utility is used to generate the actual Identity Token. Still, genid needs a reference to the previously issued Sacrificial Transaction (which already need to be known by the entire network of nodes). You provide it through the -r arguyment passed to genid.

I hope that is clear now? Let me know.

and indeed, it shall…