DEV Community: Alexander Gusev

What is Web3 Development? 3 Key Web3 Job Types

Alexander Gusev — Mon, 24 Apr 2023 07:21:19 +0000

As you explore the possibilities of a career in Web3 space, you might notice that different job postings often have varying requirements for the same "Web3 Developer" title.

In this article, we'll break down the three main types of Web3 programming roles to help you navigate the Web3 development world and find the right path for you.

1. Protocol Developers

Protocol developers are responsible for creating and maintaining the core protocols of blockchain platforms. They focus on improving aspects such as security, scalability, and performance.

These developers often have a strong background in programming languages like Rust, Go, or C++, as well as a deep understanding of blockchain fundamentals, cryptography, and distributed systems.

Common requirements for Blockchain Protocol Developers:

Programming languages: Rust/Go/C++
Cryptography libraries: OpenSSL/Libsodium
Networking libraries: libp2p/gRPC
Consensus algorithms: Proof of Work/Proof of Stake/Delegated Proof of Stake

2. Smart Contract Developers

Smart contract developers create self-executing contracts with the code embedded directly on a blockchain. They ensure that transactions between parties follow specific rules and conditions.

These developers should be proficient in languages like Solidity or Vyper and have a strong understanding of blockchain platforms such as Ethereum.

Common requirements for Smart Contract Developers:

Smart contract languages: Solidity/Vyper/Rust
Blockchain platforms: Ethereum/Polygon/Solana/Binance Smart Chain
Development tools: Truffle/Hardhat/Remix
Testing frameworks: Mocha/Chai

3. Blockchain Application Developers

Blockchain application developers build decentralized applications (dApps) that interact with blockchain platforms and smart contracts. They can specialize in either backend or frontend development, or both.

4.1. Backend Developers

Backend developers focus on the server-side logic of dApps, handling data storage, smart contract integration, and API development.

They should be skilled in languages such as Node.js, Python, or Ruby and have experience with database management and server architecture.

Common requirements for Web3 Backend Developers:

Server-side languages: Node.js/Python/Ruby
Database management: PostgreSQL/MongoDB/MySQL
API development: REST/GraphQL
Blockchain libraries: Web3.js/Ethers.js

4.2. Frontend Developers

Frontend developers work on the user interface and user experience (UI/UX) of dApps. They ensure that users can interact seamlessly with the underlying blockchain and smart contracts.

Frontend developers should be proficient in technologies like JavaScript, HTML, and CSS and have experience with frameworks like React, Vue or Angular.

Common requirements for Web3 Frontend Developers:

Web development technologies: JavaScript/TypeScript/HTML/CSS
Frontend libraries/frameworks: React/Angular/Vue
UI component libraries: Material-UI/Ant Design/Bootstrap
State management: Redux/MobX/Vuex
Blockchain libraries: Web3.js/Ethers.js

Conclusion

In summary, if you're interested in pursuing a career in Web3 development, it's important to understand the three main job types:

Protocol developers
Smart contract developers
Blockchain application developers

Take the time to identify your strengths and interests and choose a path that aligns with them. Then, focus on developing the necessary skills and knowledge, such as programming languages and blockchain fundamentals, to succeed in your chosen role.

This article is made by Contribute3 community. Join us if you want to find support and resources to develop your Web3 skills and professional network.

Making TLS client with Chrome-like SSL Handshake (Rust, Boring SSL, H2)

Alexander Gusev — Sat, 11 Mar 2023 18:11:46 +0000

An overview guide to building a TLS client in Rust that can simulate Chrome's SSL handshake. Plus nodejs module and proxy support in the repo.

The source code is available here — github.com/gssvv/rust-boring-ssl-client

Tools used

Rust (JavaScript cannot handle such low-level operations)
BoringSSL bindings for the Rust (Chromium uses BoringSSL)
H2 (HTTP/2 client)
Neon (to create native Node.js modules)

What's the result?

Let's take an opensea.io GraphQL for example, which uses Cloudflare WAF.

Regular axios request won't work:

const config = {
  uri: "https://opensea.io/__api/graphql/",
  host: "opensea.io",
  method: "POST",
  headers: [
    ["authority", "opensea.io"],
    ["content-type", "application/json"],
    // ...
  ],
  body: `{
    \"id\": \"NavbarQuery\",
    \"query\": \"query NavbarQuery(\\n  $identity: AddressScalar!\\n) {\\n  getAccount(address: $identity) {\\n    imageUrl\\n    id\\n  }\\n}\\n\",
    \"variables\": {
      \"identity\": \"0xf8e33110b8757e05e1db570a4528412cd907f29d\"
    }
  }`,
};

const axios = require("axios");

axios({
  ...config,
  url: config.uri,
  headers: Object.fromEntries(config.headers),
  data: config.body,
  validateStatus: () => true,
}).then((e) => console.log({ status: e.status, body: e.data }));
// {
//   status: 403,
//   body: '<!DOCTYPE html>\n' +
//     '<html lang="en-US">\n' +
//     '   <head>\n' +
//     '      <title>Access denied</title>\n' +
//     '      <meta http-equiv="X-UA-Compatible" content="IE=Edge" />\n' +
// ...

Let's try our module:

const { request } = require("./build/macos.node");

request(config, "", "").then(console.log);
// {
//   status: 200,
//   bodyJson: '{"data":{"getAccount":{"imageUrl":"https://i.seadn.io/gcs/files/27554692030796c8858c08ff5b6615a2.jpg?w=500&auto=format","id":"QWNjb3VudFR5cGU6ODY3MDYyNDQw"}}}'
// }

You can also use it in Rust:

mod lib;
use tokio;

#[tokio::main]
async fn main() {
    let body = String::from(
        "{
            \"id\": \"NavbarQuery\",
            \"query\": \"query NavbarQuery(\\n  $identity: AddressScalar!\\n) {\\n  getAccount(address: $identity) {\\n    imageUrl\\n    id\\n  }\\n}\\n\",
            \"variables\": {
              \"identity\": \"0xf8e33110b8757e05e1db570a4528412cd907f29d\"
            }
          }",
    );

    let config = lib::RequestConfig {
        body,
        method: "POST".to_string(),
        host: "opensea.io".to_string(),
        uri: "https://opensea.io/__api/graphql/".to_string(),
        headers: vec![
            vec!["authority".to_string(), "opensea.io".to_string()],
            vec!["content-type".to_string(),"application/json".to_string()],
            vec!["origin".to_string(), 
        // ...
    };

    let res = lib::request(config).await.unwrap();
    println!("res: {:?}", res);
    // res: (200, "{\"data\":{\"getAccount\":{\"imageUrl\":\"https://i.seadn.io/gcs/files/27554692030796c8858c08ff5b6615a2.jpg?w=500&auto=format\",\"id\":\"QWNjb3VudFR5cGU6ODY3MDYyNDQw\"}}}")
}

Let's build

I will cover the key points of the TLS client implementation. I will not describe the Neon interface building, Tokio runtime setup and other secondary aspects in detail.

So, here're the dependencies we need:

use h2::client;
use http::Request;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;

use boring::ssl::{ConnectConfiguration, SslConnector, SslMethod};

use once_cell::sync::OnceCell;
use std::error::Error;
use std::net::ToSocketAddrs;

use bytes::{BufMut, Bytes, BytesMut};

use neon::context::{Context, FunctionContext, ModuleContext};
use neon::prelude::*;

use tokio::runtime::Runtime;

Now we can start writing the main request function that opens a TCP connection:

pub struct RequestConfig {
    pub method: String,
    pub body: String,
    pub host: String,
    pub uri: String,
    pub headers: Vec<Vec<String>>,
}

pub async fn request(request_config: RequestConfig) -> Result<(u16, String), Box<dyn Error>> {
    let addr = format!("{}:443", request_config.host)
        .to_socket_addrs()
        .unwrap()
        .next()
        .unwrap();
    let tcp = TcpStream::connect(&addr).await?;

    connect_and_send_request(tcp, request_config).await
}

We'll get to connect_and_send_request later.
The next step is to create SSL configuration. This is where we specify ciphers and TLS extensions settings.

pub fn get_connect_config() -> ConnectConfiguration {
    let cipher_list = "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA:AES256-SHA";
    let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
    builder.set_verify(boring::ssl::SslVerifyMode::NONE);
    builder.set_grease_enabled(true);
    builder.enable_ocsp_stapling();
    builder.set_cipher_list(&cipher_list).unwrap();
    builder
        .set_alpn_protos(&[2, 104, 50, 8, 104, 116, 116, 112, 47, 49, 46, 49])
        .unwrap();
    builder.enable_signed_cert_timestamps();
    let connector = builder.build();

    let mut connect_config = connector.configure().unwrap();
    connect_config.set_verify_hostname(false);

    connect_config
}

Now we can use that config to perform a SSL handshake and initialize a client:

async fn connect_and_send_request(
    tcp: TcpStream,
    request_config: RequestConfig,
) -> Result<(u16, String), Box<dyn Error>> {
    let connect_config = get_connect_config();

    let res = tokio_boring::connect(connect_config, request_config.host.as_str(), tcp).await;
    let tls = res.unwrap();

    let (mut client, h2) = client::Builder::new()
        .initial_connection_window_size(1024 * 1024 * 1024)
        .initial_window_size(1024 * 1024 * 1024)
        .handshake::<_, Bytes>(tls)
        .await
        .unwrap();
    // ...

Now we can create our request and send it:

    // ...
    let mut request = Request::builder()
        .version(http::version::Version::HTTP_2)
        .method(request_config.method.as_str())
        .uri(request_config.uri);

    let mut i = 0;

    while i < request_config.headers.len() {
        request = request.header(
            request_config.headers[i][0].as_str(),
            request_config.headers[i][1].as_str(),
        );
        i = i + 1;
    }

    let has_body = request_config.body.len() > 0;

    if has_body {
        request = request.header("content-length", request_config.body.len());
    }

    let request = request.body(()).unwrap();
    let (response, mut send_stream) = client.send_request(request, !has_body).unwrap();

    if has_body {
        send_stream
            .send_data(Bytes::from(request_config.body), true)
            .unwrap();
    }
    // ...

When the request is sent, we can get and return its result:

    // ...
    tokio::spawn(async move {
        if let Err(e) = h2.await {
            println!("GOT ERR={:?}", e);
        }
    });

    let (res_parts, mut body) = response.await?.into_parts();
    let mut response_buf = BytesMut::new();

    while let Some(chunk) = body.data().await {
        response_buf.put(chunk?);
    }

    Ok((
        res_parts.status.as_u16(),
        String::from_utf8(response_buf.to_vec())?,
    ))
}

Now we have a working TLS client!

Proxy implementation

To make it work with proxy, we have to send extra headers before the SSL handshake. Everything else is the same:

pub async fn request_with_proxy(
    request_config: RequestConfig,
    proxy_addr: String,
    proxy_auth_in_base64: String,
) -> Result<(u16, String), Box<dyn Error>> {
    let addr = proxy_addr.to_socket_addrs().unwrap().next().unwrap();
    let mut tcp = TcpStream::connect(&addr).await?;

    let connect_request = [
        format!("CONNECT {}:443 HTTP/1.1", request_config.host).to_string(),
        format!("Host: {}:443", request_config.host).to_string(),
        format!("Proxy-Authorization: Basic {}", proxy_auth_in_base64),
        "User-Agent: curl/7.81.0".to_string(),
        "Connection: keep-alive".to_string(),
        "\r\n".to_string(),
    ]
    .join("\r\n");

    tcp.write_all(connect_request.as_bytes()).await.unwrap();
    let mut msg = vec![0; 1024];

    loop {
        tcp.readable().await?;

        match tcp.try_read(&mut msg) {
            Ok(n) => {
                msg.truncate(n);
                break;
            }
            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                continue;
            }
            Err(e) => {
                return Err(e.into());
            }
        }
    }

    connect_and_send_request(tcp, request_config).await
}

That's it!

I couldn't find a solution like that on the internet and collected information bit by bit.

I really hope this quickly-made article will save someone's time just like it would save mine.

P.S. I am not a Rust developer, so be careful using this code in production.

How I increased my typing speed from 40 to 120 WPM

Alexander Gusev — Thu, 28 Jul 2022 12:34:00 +0000

Typing 2–3 times faster than the average person is a good advantage. Especially for a writer or programmer. That’s why I got into it.

In the beginning, I had 40 WPM (words per minute). It’s ~200 symbols.

Now my speed ranges from 100 to 120 WPM.

How to make progress and not quit in a week

The whole algorithm can be boiled down to this:

Choose a service for typing practice.
Place your fingers and stop looking at your keyboard.
Make a habit (the most important part).

1. Service for typing practice

I use keybr, but you can pick any service that counts your words and allows you to customise the text.

Some programmers might want to use SpeedCoder. It allows practising typing in your favourite language’s syntax.

2. Placing fingers

This is the hardest part for the majority.

Most people don’t use all their fingers while typing. It’s okay if your speed is 30 WPM, but it’s almost unreal to type 75 WPM+ like this.

So it’s best to take care of this in the very beginning. Speed might drop down first, but it will grow faster then.

The same rule can be applied to the habit of looking at your keyboard. Don’t do that. It’s better to get used to that now than suffer from it later on.

Also, it’s not necessary to stick to the classical finger setting. For example, I always use my left little finger for shift/ctrl and pressing q/a/z only with my ring finger.

3. Making a habit

The most underrated and unobvious part.

I was surprised by how easily typing can become a part of my day.

At first, you do it because you «have to» but later… your hands are reaching out to open a tab with typing practice by themselves. And you find yourself typing having your head in the clouds.

It’s like a meditation. It’s relaxing to take some time and do some typing during the workday.

I managed to type almost every day this way.

Make the whole process as easy as possible for yourself.

I picked the simplest setting: English layout in lower case without punctuation marks.

What else?

From my own experience — you quickly reach 60–70 WPM. Then I’s much harder to grow. That’s why you need a strong habit.

My current goal is 150 WPM.

I started with this video — recommended for watching.

Feel free to share your own experience in the comments.

Good luck!