Becoming a Syscoin Core Developer --- My plan and progress

einalex · May 10, 2020, 11:07am

Introduction

Hi!
I’m Alex, and I’m somewhat experienced when it comes to programming but I haven’t done significant work in C++ in some time, and I’ve never worked with Bitcoin Script, the language in which Bitcoin (and Syscoin) smart contracts are written.

So here is how I plan to get ready to become a code contributor.

Plan

Transaction Logic
- Learn Bitcoin Script
  - Learn the basics of how the language works
  - Learn what opcodes there are and what they do
- Study the existing Syscoin smart contracts
- Write some smart contracts myself
Client/Wallet Design
- Get an overview over the different parts of Syscoin’s code
- Learn how the different parts work
  - Start with consensus logic
- Fix a first bug or make a first contribution

Resources

Learning Bitcoin from the Command Line is an open book hosted on github. It’s a goldmine when it comes to learning to work with bitcoin transactions — from using the console to crafting them by hand.
Overview of Bitcoin Core 0.11 is a wiki book hosted on bitcoin.it. It’s an in-depth look at the code structure of Bitcoin 0.11, so likely a bit outdated but still a good resource to get a general idea of how things work.

What I learned

Bitcoin/Syscoin Script is written in Reverse Polish notation
- The operators to a function are located left of the function: 2 3 + instead of 2 + 3
- Code is evaluated from left to right
  - first_command second_command third_command
The evaluation of the language works in a very simple way
1. the first (leftmost) element of the script is read
  1.a. if it is data, the data is pushed to the stack,
  1.b. if it is an operation instead data on the is popped, evaluated and potentially a result is pushed.
2. the next (now leftmost) element of the script is read
3. the transaction is valid if the script isn’t terminated prematurely and after it is finished TRUE is the topmost stack element.
Bitcoin Script opcodes can be found here.
Bitcoin/Syscoin transactions have smart contracts locking the outputs and inputs
- to be able to spend some input, you first run the scriptSig of the vin of the spending transaction followed by the scriptPubKey of the vout of the funding transaction output.
  - in reality the stack produced by the scriptSig is copied to a new environment and the scriptPubKey is evaluated then, but for purely understanding the script logic one can just concatenate the two

willyk · May 11, 2020, 5:06pm

If you’re talking about learning the basic of bitcoin… this is a must-read too (also open sourced)

github.com

bitcoinbook/bitcoinbook/blob/develop/ch07.asciidoc

[[ch07]]
[[adv_transactions]]
== Advanced Transactions and Scripting

[[ch07_intro]]
=== Introduction

In the previous chapter, we introduced the basic elements of bitcoin transactions and looked at the most common type of transaction script, the P2PKH script. In this chapter we will look at more advanced scripting and how we can use it to build transactions with complex conditions.

First, we will look at _multisignature_ scripts. Next, we will examine the second most common transaction script, _Pay-to-Script-Hash_, which opens up a whole world of complex scripts. Then, we will examine new script operators that add a time dimension to bitcoin, through _timelocks_. Finally, we will look at _Segregated Witness_, an architectural change to the structure of transactions.

[[multisig]]
=== Multisignature

((("transactions", "advanced", "multisignature scripts")))((("transactions", "advanced", id="Tadv07")))((("scripting", "multisignature scripts", id="Smulti07")))((("multisignature scripts")))Multisignature scripts set a condition where N public keys are recorded in the script and at least M of those must provide signatures to unlock the funds. This is also known as an M-of-N scheme, where N is the total number of keys and M is the threshold of signatures required for validation. For example, a 2-of-3 multisignature is one where three public keys are listed as potential signers and at least two of those must be used to create signatures for a valid transaction to spend the funds.

At this time, _standard_ multisignature scripts are limited to at most 3 listed public keys, meaning you can do anything from a 1-of-1 to a 3-of-3 multisignature or any combination within that range. The limitation to 3 listed keys might be lifted by the time this book is published, so check the +IsStandard()+ function to see what is currently accepted by the network. Note that the limit of 3 keys applies only to standard (also known as "bare") multisignature scripts, not to multisignature scripts wrapped in a Pay-to-Script-Hash (P2SH) script. P2SH multisignature scripts are limited to 15 keys, allowing for up to 15-of-15 multisignature. We will learn about P2SH in <<p2sh>>.

The general form of a locking script setting an M-of-N multisignature condition is:

This file has been truncated. show original

Sebastien · May 19, 2020, 7:49pm

Great thread! Looking forward to reading about your journey and learning more as I go

einalex · May 23, 2020, 2:21pm

Update: I’m reading https://en.bitcoin.it/wiki/Bitcoin_Core_0.11_(ch_1):_Overview which is an overview of Bitcoin Core 0.11 to get an idea how things work and where I can find them.

I updated the first post.