Forem: SinachPat

POKT Token: History and DePIN tokenomics

SinachPat — Thu, 06 Jun 2024 11:21:14 +0000

Introduction

You and I will agree that blockchain is no longer a new story in town; it is here to stay, probably forever, and has received a lot of interest.

But if you’re new to it, blockchain is a decentralized and secure digital ledger used to record transactions. It is typically public, allowing anyone to view them to establish transparency and trust within the system.

Blockchain technology has also greatly impacted various industries with its decentralized and secure approach.

However, of course, there will always be problems and challenges that go beyond just how beautiful and sweet it may sound. Two among them are scalability and infrastructure costs.

Because of the attraction blockchain has gotten in recent years, this has led to congestion, especially during the transaction process. As more users join the network, things can slow down. This is because blockchains can only handle a certain amount of activity at a time, and it has become a major challenge for blockchains. It makes them less suitable for applications that need things to happen fast.

Also, setting up and maintaining blockchain infrastructure can be really expensive for application developers.

This is where the POKT Network comes in as a solution to these challenges by providing a decentralized network for relaying blockchain traffic. POKT Network offers high-performance and low-cost infrastructure for developers to build and scale their blockchain applications.

What is the POKT Token?

POKT Network is a blockchain network specifically designed for Web3 applications. It operates as the RPC (Remote Procedure Call) Base Layer in the Web3 infrastructure, contributing to a dependable, cost-effective, and high-uptime solution for data access and management while ensuring its decentralized nature.

POKT Network offers low latency and high accuracy in data handling, connecting data transfer between different blockchains through two major players: a network of thousands of computers (nodes) and the application. The nodes are used for storing data and communicating information.

The POKT Network uses a native token called POKT. This token serves an important role in incentivizing various participants within the network and creating a stronger and more secure blockchain network. By holding and utilizing POKT tokens, users contribute to the network's functionality and its overall growth.

Use Cases of POKT Token

We will categorise POKT into 4 use cases:

For staking: This process involves locking up a certain amount of POKT tokens for a specified period as a means of supporting the network and participating in its operations. In return for securing the blockchain and processing transactions, POKT stakers are rewarded with additional Pocket Network tokens, $POKT. Staking greatly contributes to the security, transparency, and stability of the network. The more a user stakes, the more rewards they get, and the more voting power they hold, allowing them to participate in network governance decisions.
For Developers: A simplified process has been created for developers to integrate their applications with decentralized node infrastructure. This grants them access to cost-effective infrastructure, allowing them to request, retrieve, and store data essential for blockchain-enabled application development without managing expensive nodes. Developers can access Pocket's open-source code and make contributions to the community.
For node runners: The node runners act as infrastructure providers for the POKT Network. They play a major part in being a big intersection for Web3 applications, linking different blockchains using thousands of computers also run by node runners, and connecting developers in need of blockchain-enabled applications with infrastructure providers operating full nodes, known as Service Nodes. All the work in this Pocket Network boils down to relays, where apps send requests and Service Nodes check them on different blockchains. When it's verified that a task has been done, these node runners are compensated with POKT tokens for providing access to reliable blockchain application programming interfaces (APIs).
Holders: Community members and contributors can get POKT tokens as rewards for contributing to the foundation and making an impact in the ecosystem, governance of the community, and the protocol. These people grow their holdings by continuous impact and are called POKT Holders.

DePIN Tokenomics

The focal points of blockchain have always been transparency, decentralization, scalability, and verifiable infrastructure. DePIN, which stands for Decentralized Physical Infrastructure Networks, takes these principles and applies them to the real world. In the POKT Network, DePIN represents a significant advancement in how blockchain technology can manage and scale physical infrastructure such as communication networks, the energy grid, and transportation systems using the decentralized and scalable model.

DePIN offers incentives for resource contributions for specific actions within the network operations, such as data delivery and arbitration. In DePIN, participants contribute physical assets such as data storage, wireless connectivity, sensors, or energy grids. In exchange, they receive rewards based on the network’s incentive structure. DePIN platforms enable decentralized sharing and management of both hardware and software resources among users. One of the most important roles of DePIN is ensuring the security and efficiency of physical infrastructure by removing single points of failure and reducing the risks of tampering or manipulation. Data exchanges are protected by cryptography, and the distributed database guards against attacks or unauthorized access.

As blockchain continues to gain traction every single day, there will always be a demand for an efficient and scalable network, and POKT, I believe, stands in a position to address this growing need by offering effective solutions. The continuous and ongoing development of this network definitely holds promise and its future looks bright both in its integration and protocol enhancement.

Additional information

For more read on POKT and how far this project is going, you might have to check out this links below

POKT Network Website: https://www.pokt.network/
What is DePIN: https://medium.com/bru-finance/what-is-depin-decentralized-physical-infrastructure-network-9cd4247db608
POKT overview: https://messari.io/project/pocket-network-2/profile
POKT for Developers: https://www.pokt.network/blog/pocket-core-mvp-for-developers
What is POKT staking: https://docs.pokt.network/pokt-token/stake-pokt

Look forward to the next post in the series about the POKT token in the Shannon Era.

Dart - Variables & Challenges

SinachPat — Tue, 04 Apr 2023 21:37:48 +0000

This is the beginning of a series on Dart/Flutter that will have me sharing bits of Dart/Flutter every now and then on the fundamentals of building cross-platform applications using the language and framework. The purpose of this is to provide a summarized reference for the Flutter Roadmap which shows a path for learning Flutter towards mastery. I’ll provide this content with well-commented codes so beginners will be able to make references to these resources and not just learn about the Dart/Flutter language but really understand how it works.

Every programming language has a way of storing values, objects and methods. In Dart, variables are a way of storing values. These values can be called References. You can always use the value of the variable by calling on the variable.

Variables in Dart are defined with the type clearly indicated as String, Object, Int, bool etc.

// Here a variable is defined with name as myFirstName which stores 

// my first name which is Osinachi 

String myFirstName = "Osinachi";

bool confirmName = true;

You can use the variable type Object for variables that can have changing values. For example you can define a value to be a String and later change it to be an Int depending on the flow of the program.

When defining a variable which value can be Null, the code should be able to show the bear a question mark which ensures that the code doesn’t throw an error when used later in the program and a state in the program assigns it a null value. The format for defining a nullable value in Dart/Flutter is shown below.

int? age;
//the assert here confirms that this variable can be null throughout the program
assert(age == null);

String? chainName;
//the assert here confirms that this variable can be null throughout the program
assert(chainName == null);

Late Variables

If you declare a non-nullable variable and wish not to assign in a value at the initial declaration, the late modifier is used to tell the program “Hey, this is a value store in this program. I would be using it later to store a value so just keep it for me as late.”

In programming, variables are used to store values or objects. In Dart, variables are defined with the type clearly indicated as String, Object, Int, bool, and others. When you declare a variable, you must assign a value to it immediately. However, there are instances when you need to declare a variable but do not wish to assign a value to it immediately. This is where the late modifier comes in handy.

The late modifier is used to defer the initialisation of a non-nullable variable until it is accessed for the first time. This is useful when you need to declare a variable that will be assigned a value later in the program, but you don't want to initialise it with a dummy value at the time of declaration. This can help to make your code more efficient and easier to read.

For example, if you have a variable that will be initialised with the result of an asynchronous operation, you can declare it as a late variable to avoid having to initialise it with a default value that will be immediately replaced. Instead, you can simply declare it as late and assign a value to it later in the program. This can help to reduce clutter in your code and make it easier to understand.

It's worth noting that late variables must be initialised before they are accessed, or an exception will be thrown. This means that you should be careful when using late variables to ensure that they are initialised correctly and in a timely manner. If you attempt to access a late variable before it has been initialised, your program will throw an exception, which can cause your program to crash or behave unexpectedly.

late String nameHint;

//Here the variable is now initialized and assigned a value.

void main() {
String nameHint = "Os";
}

While this is for variable declarations you would want to change later, there are variables we use in our program that we wish to declare just once and not change again. We would talk about constants and finals in the next section.

Const and Final Variables

You can define variables you don’t want to change throughout the program with the keywords final or const. This stores values permanently in a program that can’t be changed anywhere in the program.

const String nameHint = "Os";
final String fullName = "Osinachi Patrick"

You can use final in Instance Variables (variables declared within a class) for representing values that can’t change.

class Person {
  String? firstName; // Declare instance variable x, initially null.
  String? lastName; // Declare y, initially null.
  final int age = 21; // Declare z, initially 0.
}

In summary, we use variables in many instances in our programs and it’s important we understand how it works fundamentally.

To understand the concept of variables more deeply, let’s have some challenges to work on.

See you in my next article 💙

Generate Random Password for users in your App — Building with Flutter

SinachPat — Fri, 03 Mar 2023 16:28:24 +0000

Security is one of the important features that are built into any mobile app where users have to create an account before interacting with the able and using it’s other features. From experience the process of creating an account password has been something people do without sometimes giving some deep thoughts. Some users create their own password while some prefer to get a suggestion of a strong password from the app.

The purpose of a password in an app is for user account security.

Let me take some lines to explain the concept of user account security.

User Account Security

User account security refers to the protection of user accounts from unauthorised access, misuse, and abuse. It is essential to ensure that only authorised users have access to sensitive information, systems, and applications. Here are some key concepts to understand when it comes to user account security:

Passwords: A password is a secret combination of characters that a user must provide to access their account. Passwords should be strong, unique, and regularly changed to prevent unauthorised access. Users should avoid sharing their passwords with others and never use the same password across multiple accounts.
Two-Factor Authentication (2FA): 2FA is a security mechanism that requires users to provide two different types of authentication factors before they can access their account. This typically involves a password and a secondary factor, such as a fingerprint or a one-time code sent via SMS or email.
Access Controls: Access controls are mechanisms that limit who can access certain resources or information. Access controls can include things like user roles, permissions, and restrictions based on location or device.
Monitoring: Monitoring is the process of tracking user activity to detect potential security threats. This can include monitoring login attempts, user behavior, and system logs to identify suspicious activity and potential security breaches.
Education and Training: Education and training are crucial components of user account security. Users need to understand the risks of insecure practices such as weak passwords, phishing scams, and malware attacks. Organizations should provide regular training and awareness campaigns to ensure that users are aware of these risks and know how to avoid them.

Overall, user account security is an ongoing process that requires a combination of technical controls, policies, and user education. By implementing best practices and staying vigilant, organisations can help protect their users and sensitive information from potential security threats.

In the rest of this tutorial I’ll be looking at guiding the reader through a simple way of baking in app generated random characters which the user can use as their account password. This is tutorial would be relevant to you if you are building with Flutter (with Dart Programming Language).

Basic Requirements

Knowledge of Dart Programming Language.
Have Dart/Flutter installed using this video (this is a series, so follow through).
A windows laptop of minimum 4GB RAM for running your Android studio or making use of DartPad.

I won't be writing on how to setup Dart/Flutter in your PC because this article would be too long to have that and the main tutorial of the article. So let's get down to writing a program that can help you generate random password for your users.

For first time test, The next thing to do is to create a new flutter project:

flutter create random-password

This creates the well structure flutter project file where you have to locate your lib folder to write your first codes to test the solution on your own PC.

While solving some problems using Dart we need some libraries that help you build on some specific features of the language like dart:maths, dart:core etc.

In this program we will be importing the Dart library for maths operation:

import 'dart:math';

This imports the Dart maths library: It helps you in using Mathematical constants and functions, plus a random number generator.

The next thing we have to do is to go under this block of code in your lib folder main.dart file and add a new function for your solution.

import 'package:flutter/material.dart';
import 'dart:math';

void main() {
  runApp(const MyApp());
}

// Add your own function here.
void testPassword() {

}

This makes it possible for you to easily call your testPassword() function in the application root. This way in your code:

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    testPassword();
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        // This is the theme of your application.
        // Try running your application with "flutter run". You'll see the
        // application has a blue toolbar. Then, without quitting the app, try
        // changing the primarySwatch below to Colors.green and then invoke
        // "hot reload" (press "r" in the console where you ran "flutter run",
        // or simply save your changes to "hot reload" in a Flutter IDE).
        // Notice that the counter didn't reset back to zero; the application
        // is not restarted.
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

You call the testPassword() function within the build() this logs your program result to the debug console when you run your code in Debugging mode.

Let's write the core program for generating the random password, I'd do a breakdown of each line of the code.

We need to first declare the number of characters the password should be and this would be constant for all generated passwords.

const int passwordLength = 20;

We then provide the program with some characters to choose from in generating the random password:

const String digits = 'StanruteTechnologies0123456789!@#\$%^&*()_-+={}[]|;:,.<>?';

Now we go ahead and write the main code go generate the random password, here we make use of the different methods the dart:math library provides like Random():

Random random = Random();
  String password = '';
  for (int i = 0; i < passwordLength; i++) {
    password += digits[random.nextInt(digits.length)];
}

// To print your random password to the debug console.
print(password);

After this you can run the main.dart file to keep generating multiple random passwords.

Bring the whole code together we have something that looks like:

This is written in a beginner friendly manner but any further questions can be directed to me here.

Thanks for Reading 💙