Forem: Yongchang He

Multiple developers work simultaneously using their own branch on git

Yongchang He — Sun, 20 Nov 2022 00:00:07 +0000

1. Create a new branch:

git checkout -b yong-active-members-dev

Switched to a new branch 'yong-active-members-dev'
yongchanghe@MacBookPro 868_class_project_civitas_practice_repo % git push origin yong-active-members-dev
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
remote:
remote: Create a pull request for 'yong-active-members-dev' on GitHub by visiting:
remote: https://github.com/hyc0812/868_class_project_civitas_practice_repo/pull/new/yong-active-members-dev
remote:
To https://github.com/hyc0812/868_class_project_civitas_practice_repo.git

[new branch] yong-active-members-dev -> yong-active-members-dev

2. Check Which branch is currently used:

git branch -a

master

yong-active-members-dev remotes/origin/HEAD -> origin/master remotes/origin/master remotes/origin/yong-active-members-dev

3. Develop the new branch and commit the changes

4. When complete, go back to master branch

git checkout master

Switched to branch 'master'
Your branch is up to date with 'origin/master'.
yongchanghe@MacBookPro 868_class_project_civitas_practice_repo % git pull origin master
From https://github.com/hyc0812/868_class_project_civitas_practice_repo

branch master -> FETCH_HEAD Already up to date.

5. Merge your branch to master

git merge yong-active-members-dev

Updating 98f2681..4fdc41c
Fast-forward
src/app/demo/dashboard/active-members/active-members.component.html | 1 +
1 file changed, 1 insertion(+)

6. Push to master branch

git push origin master

Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/hyc0812/868_class_project_civitas_practice_repo.git
98f2681..4fdc41c master -> master
yongchanghe@MacBookPro 868_class_project_civitas_practice_repo %

Parse RTCM 3.x correction data from serial input

Yongchang He — Tue, 20 Sep 2022 21:20:25 +0000

This article illustrates how to parse the RTCM 3.x correction data from serial port input of your GPS base station module.

Prerequisites

Have RTCM 3.x correction data streamed correctly from some serial port of your GPS module
Have python3 and pip3 installed
CLI

Getting started

First, you want to know which ports are used by your GPS base module. Run this code (The resource was found here).

Run python3 NAME_OF_CODE_1.py

import sys
import glob
import serial


def serial_ports():
    """ Lists serial port names

        :raises EnvironmentError:
            On unsupported or unknown platforms
        :returns:
            A list of the serial ports available on the system
    """
    if sys.platform.startswith('win'):
        ports = ['COM%s' % (i + 1) for i in range(256)]
    elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
        # this excludes your current terminal "/dev/tty"
        ports = glob.glob('/dev/tty[A-Za-z]*')
    elif sys.platform.startswith('darwin'):
        ports = glob.glob('/dev/tty.*')
    else:
        raise EnvironmentError('Unsupported platform')

    result = []
    for port in ports:
        try:
            s = serial.Serial(port)
            s.close()
            result.append(port)
        except (OSError, serial.SerialException):
            pass
    return result


if __name__ == '__main__':
    print(serial_ports())

Then, time to parse the streaming RTCM correction data:
(resource code from here).

Run python3 NAME_OF_CODE_2.py

Should update the serial port name and the baud rate of your application

from serial import Serial
from pyrtcm import RTCMReader

stream = Serial('/dev/ttyS10', 921600, timeout=3)
rtr = RTCMReader(stream)

for (raw_data, parsed_data) in rtr: print(parsed_data)

part of the results

You can print either raw data or parsed data

References

https://stackoverflow.com/questions/12090503/listing-available-com-ports-with-python

https://github.com/semuconsulting/pyrtcm

Wi-Fi communication using two u-blox C099-F9P application board

Yongchang He — Wed, 31 Aug 2022 17:19:48 +0000

The C099-F9P RTK Base can be set to operate as a Wi-Fi access point and UDP server to deliver RTCM correction data via a Wi-Fi link. For the Rover operation, C099-F9P can be configured to either Wi-Fi STA mode or AP mode. STA mode is suitable for one Base to one Rover communication.

This article will introduce Base AP mode and Rover STA mode configuration.

Prerequisites

Two u-blox C099-F9P application boards (evaluation kit)
u-center installed
Tera Term installed

Getting started

Base ODIN-W2 configuration in Wi-Fi AP mode

1.Configure C099-F9P ODIN-W2 to work in Wi-Fi AP mode using CLI in Tera Term terminal:

/mem_store/run wifi_ap

2.Set the C099-F9P Wi-Fi and I2C interface to support the base configuration:

/mem_store/run base

3.Restart the C099-F9P application board to apply Wi-Fi AP mode settings, and the Base ODIN-W2 will wait until a Wi-Fi STA Rover connects to it before streaming any data via the Wi-Fi link. The screenshot below shows the Base is streaming data to Rover via a Wi-Fi connection.

Rover ODIN-W2 configuration in Wi-Fi STA mode

1.Configure C099-F9P ODIN-W2 to work in Wi-Fi STA mode using CLI in Tera Term terminal:

/mem_store/run wifi_sta

2.Set the C099-F9P to support rover configuration:

/mem_store/run rover

3.Restart the Rover C099-F9P application board to apply Wi-Fi STA mode settings, and the Rover C099-F9P automatically connects to the C099-F9P Base.

RTCM data streaming

When the Rover receives RTCM correction data from Base, the Fix Mode should change from 3D to 3D/DGNSS (3D/DGNSS/FLOAT or 3D/DGNSS/FIXED), and the RTK LED blinks in green. The two screenshots show the Base was in 3D/DNGSS Fix Mode and the Rover was in 3D/DGNSS/FIXED Fix Mode.

Trouble Shooting

You may need to consult this link if there is no RTCM data streaming.

Reference

https://blog.adafruit.com/2020/06/08/eye-on-npi-u-blox-c099-f9p-application-board-for-zed-f9p-gnss-rtk-module-eyeonnpi-adafruit-digikey-digikey-ublox/?gclid=Cj0KCQjwjbyYBhCdARIsAArC6LJrPi4IL63FlciBqmsiVi17k99ISIA6yqlpx9lrUJMC3ofOh8-L4CkaAnGgEALw_wcB

Interact with ADT using Postman

Yongchang He — Mon, 01 Aug 2022 21:14:04 +0000

ADT: Azure Digital Twins

Postman is a REST testing tool that provides key HTTP request functionalities in a desktop and plugin-based GUI. You can craft HTTP requests and submit them to the Azure Digital Twins (ADT) REST APIs.

This blog describes how to configure the Postman REST client to interact with the ADT APIs (creating a request collection).

Prerequisites

knowledge about ADT
Postman installed
.NET Core installed (optional)
Azure DT instance created
Azure DT test models and graphs created and uploaded

Table of content

Using Azure CLI
Using Postman
Create your own ADT collection
Add an individual request
Set request details

Getting Started

Using Azure CLI

1. Run the following command to access Azure credentials:

az login

2. Run the following command to get a bearer token with access to the ADT service.

using data plane APIs:

az account get-access-token --resource 0b07f429-9f4b-4714-9392-cc5e8e80c8b0

using control plane APIs:

az account get-access-token --resource https://management.azure.com/

result example:
"accessToken": "eyJ0eXAiOiJ..." "expiresOn": "2022-07-2...", "subscription": "907b0d06-a...", "tenant": "24ab6cd0-487e-...", "tokenType": "Bearer"

Save the value of the accessToken and we will use it later on.

Using Postman

We can either create our own collection of ADT APIs or import an existing one. This article will be talking about creating one from scratch.

Create your own ADT collection

In My Workspace click new to create a new Collection in Building Blocks. Change the collection name if you like.
In the Authorization tag, set the Type to OAuth2.0 and paste your access token into the Token box. Click save.

Add an individual request

In My Workspace click new to create a new Request in Building Blocks.
By clicking the Save button, you can name the new request and select a collection to save it. Click save again.

The new request Query twins was saved in ADT Custom Collection directory.

Set request details

Change the type from GET to POST, and paste the URL below:

https://digitaltwins-host-name/query?api-version=2020-10-31.

Using your own digital-twins-host-name

In the Authorization tab, set the Type to Inherit auth from parent.

Check that the body shown for the request in the Body tab matches the needs described below:

Use send button to send the request.

OK! All set.

References

https://docs.microsoft.com/en-us/azure/digital-twins/how-to-use-postman?tabs=data-plane
Cover image from this link
https://aithority.com/computing/5-exciting-applications-of-digital-twin-technology/

Work With Azure Digital Twin - code a client app

Yongchang He — Mon, 25 Jul 2022 15:55:31 +0000

In this article, I will use DT for Digital Twin.

Prerequisites

knowledge about Azure DT
Any code editor (VS Code is preferable, and you don't need to install .NET Core)
.NET Core installed
Azure DT instance created

Getting Started

Project Setup

The very first is to create a minimal C# project in the created directory:

mkdir new-dt
cd new-dt
dotnet new console

Then you want to add two dependencies to your project: one is the package for the Azure DT SDK for .NET, and the other is tools to help with authentication management:

dotnet add package Azure.DigitalTwins.Core
dotnet add package Azure.Identity

Then we add the following two pieces of code to Program.cs to add necessary dependencies and authentication functionality:

Add this on the top

using Azure.DigitalTwins.Core;
using Azure.Identity;

And add this below the 'hello world' line in Main method, and do not forget to set the value of adtInstanceUrl to your instance host name:

string adtInstanceUrl = "https://<your-Azure-Digital-Twins-instance-hostName>"; 

var credential = new DefaultAzureCredential();
var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential);
Console.WriteLine($"Service client created – ready to go");

Now we can save the project (or preferablly commit to your git) and run the command below to test our previous work:

dotnet run

The console will print the following if no error occurs:
Hello World!
Service client created – ready to go

Model Upload

We can create models using Digital Twins Definition Language (DTDL, a kind of language similar with OOP programming language).

Let's create a new file named SampleModel.json, and paste the following code into it:

{
  "@id": "dtmi:example:SampleModel;1",
  "@type": "Interface",
  "displayName": "SampleModel",
  "contents": [
    {
      "@type": "Relationship",
      "name": "contains"
    },
    {
      "@type": "Property",
      "name": "data",
      "schema": "string"
    }
  ],
  "@context": "dtmi:dtdl:context;2"
}

After that, you want to add the rest of the code in Program.cs in order to interact with your DT instance (including code previously pasted):

using System;
// <Azure_Digital_Twins_dependencies>
using Azure.DigitalTwins.Core;
using Azure.Identity;
// </Azure_Digital_Twins_dependencies>
// <Model_dependencies>
using System.Threading.Tasks;
using System.IO;
using System.Collections.Generic;
using Azure;
// </Model_dependencies>
// <Query_dependencies>
using System.Text.Json;
// </Query_dependencies>

namespace DigitalTwins_Samples
{
    class DigitalTwinsClientAppSample
    {
        // <Async_signature>
        static async Task Main(string[] args)
        {
        // </Async_signature>
            Console.WriteLine("Hello World!");
            // <Authentication_code>
            string adtInstanceUrl = "https://<your-Azure-Digital-Twins-instance-hostName>"; 

            var credential = new DefaultAzureCredential();
            var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential);
            Console.WriteLine($"Service client created – ready to go");
            // </Authentication_code>

            // <Model_code>
            Console.WriteLine();
            Console.WriteLine("Upload a model");
            string dtdl = File.ReadAllText("SampleModel.json");
            var models = new List<string> { dtdl };

            // Upload the model to the service
            // <Model_try_catch>
            try
            {
                await client.CreateModelsAsync(models);
                Console.WriteLine("Models uploaded to the instance:");
            }
            catch (RequestFailedException e)
            {
                Console.WriteLine($"Upload model error: {e.Status}: {e.Message}");
            }
            // </Model_try_catch>

            // <Print_model>
            // Read a list of models back from the service
            AsyncPageable<DigitalTwinsModelData> modelDataList = client.GetModelsAsync();
            await foreach (DigitalTwinsModelData md in modelDataList)
            {
                Console.WriteLine($"Model: {md.Id}");
            }
            // </Print_model>
            // </Model_code>

            // <Initialize_twins>
            var twinData = new BasicDigitalTwin();
            twinData.Metadata.ModelId = "dtmi:example:SampleModel;1";
            twinData.Contents.Add("data", $"Hello World!");

            string prefix = "sampleTwin-";
            for (int i = 0; i < 3; i++)
            {
                try
                {
                    twinData.Id = $"{prefix}{i}";
                    await client.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(twinData.Id, twinData);
                    Console.WriteLine($"Created twin: {twinData.Id}");
                }
                catch(RequestFailedException e)
                {
                    Console.WriteLine($"Create twin error: {e.Status}: {e.Message}");
                }
            }
            // </Initialize_twins>

            // <Use_create_relationship>
            // Connect the twins with relationships
            await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-1");
            await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-2");
            // </Use_create_relationship>

            // <Use_list_relationships>
            //List the relationships
            await ListRelationshipsAsync(client, "sampleTwin-0");
            // </Use_list_relationships>

            // <Query_twins>
            // Run a query for all twins
            string query = "SELECT * FROM digitaltwins";
            AsyncPageable<BasicDigitalTwin> queryResult = client.QueryAsync<BasicDigitalTwin>(query);

            await foreach (BasicDigitalTwin twin in queryResult)
            {
                Console.WriteLine(JsonSerializer.Serialize(twin));
                Console.WriteLine("---------------");
            }
            // </Query_twins>
        }

        // <Create_relationship>
        public async static Task CreateRelationshipAsync(DigitalTwinsClient client, string srcId, string targetId)
        {
            var relationship = new BasicRelationship
            {
                TargetId = targetId,
                Name = "contains"
            };

            try
            {
                string relId = $"{srcId}-contains->{targetId}";
                await client.CreateOrReplaceRelationshipAsync(srcId, relId, relationship);
                Console.WriteLine("Created relationship successfully");
            }
            catch (RequestFailedException e)
            {
                Console.WriteLine($"Create relationship error: {e.Status}: {e.Message}");
            }
        }
        // </Create_relationship>

        // <List_relationships>
        public async static Task ListRelationshipsAsync(DigitalTwinsClient client, string srcId)
        {
            try
            {
                AsyncPageable<BasicRelationship> results = client.GetRelationshipsAsync<BasicRelationship>(srcId);
                Console.WriteLine($"Twin {srcId} is connected to:");
                await foreach (BasicRelationship rel in results)
                {
                    Console.WriteLine($" -{rel.Name}->{rel.TargetId}");
                }
            }
            catch (RequestFailedException e)
            {
                Console.WriteLine($"Relationship retrieval error: {e.Status}: {e.Message}");
            }
        }
        // </List_relationships>
    }
}

You should now interact with your digital twins using dotnet run.

Part of the result

Hello World!
Service client created – ready to go

Upload a model
Models uploaded to the instance:
Model: dtmi:example:Floor;1
Model: dtmi:example:Room;1
Model: dtmi:example:SampleModel;1
Created twin: sampleTwin-0
Created twin: sampleTwin-1
Created twin: sampleTwin-2
Created relationship successfully
Created relationship successfully
Twin sampleTwin-0 is connected to:
-contains->sampleTwin-1
-contains->sampleTwin-2
....

References

Code a client app
https://docs.microsoft.com/en-us/azure/digital-twins/tutorial-code
Cover image
https://www.ciobulletin.com/cloud/azure-digital-twins-generally-available

Deploy React app with JSON server on Heroku

Yongchang He — Mon, 18 Jul 2022 15:28:52 +0000

Prerequisites

Assuming you have already done the following:

Created a react application using create-react-app,
Installed JSON server in the root directory and created db.json database,
Your front-end application can run correctly and can access the JSON database properly,
Your app has been committed on Github,
You have a Heroku account.

Step 1:

create a file named Procfile in the root directory, and paste the following code into the file:

web: node server.js

Step 2:

create a file named server.js in the root directory, and paste the following into the file:

const jsonServer = require("json-server");
const server = jsonServer.create();
const router = jsonServer.router("./db.json");
const middlewares = jsonServer.defaults({
  static: "./build",
});
const PORT = process.env.PORT || 8000;
server.use(middlewares);
server.use(
  jsonServer.rewriter({
    "/api/*": "/$1",
  })
);
server.use(router);
server.listen(PORT, () => {
  console.log("Server is running");
});

Step 3:

(1) Commit the changes above to your Git repo. Then,
(2) Log in to your Heroku account, and create a new app:

(3) In the Deploy catalogue, select GitHub as your Deployment method, find your repo and Connect it to Heroku:

(4) Click Deploy Branch to deploy your app.

Suppose the whole procedure finishes without any problem, congrats! And now, you can click Open app to see your deployed app.

That's the end of this article. I want to share my deployed repo here, and please feel free to check interesting things, play it, fork and give stars, and leave a message below if you have questions.

hyc0812 / deploy-feedback-app

a simple feedback app demo @ https://deploy-feedback-app-with-jsv.herokuapp.com/

Feedback app demo

DemoLink

Run it locally:

npm install
npm run dev

Deploy it to Heroku:

BlogLink

The blog haven't publish yet, I will update the blog URL soon...

View on GitHub

See you!

Reference

Deployment:
https://www.youtube.com/watch?v=DAuHI7bHx1Q
Learn React.js:
https://www.skillshare.com/classes/React-Front-To-Back-2022/1541849001/projects?via=member-home-EnrolledClassesLessonsSection
Cover image:
https://blog.devgenius.io/how-to-deploy-your-first-full-stack-web-application-react-rails-heroku-17a799e78bb4

Hyperledger Fabric architecture

Yongchang He — Mon, 11 Jul 2022 20:15:48 +0000

The purpose of building this blog is to write down the detailed operation history and my memo for learning the dApps and Web3 programming.

The figure below illustrates the architecture of the Hyperledger Fabric blockchain. The application interface is the front end which will interact with the Hyperledger Fabric blockchain. This application is running on SDK which is a software development kit provided by the Hyperledger team. Currently, the most mature SDK are Node JS and Go SDK. These two are equipped with the Hyperledger Fabric system itself.

Every time a user uploads any document through this application interface, the application does not go to this blockchain directly. Instead, the application creates a future update proposal and submits a request for confirmation over the blockchain. With this request, users seek to modify the data stored in the blockchain or the current state of the blockchain. At present, the blockchain is at a stage where all the data has been sent and the users want to add one more transaction on top of that.

The proposal is sent to an endorsing peer. Endorsing peers is to verify and validate the transaction which is coming in. They execute the transaction by simulating it over the copy of the ledger. Simulating means they do not directly change the state of the blockchain but hold a copy of the state and implement the transaction proposal on that copy of the blockchain without updating it.

In Hyperledger blockchain data storage happens in a way that every transaction that is coming in or every block that is coming in are in key-value pairs, and the Hyperledger Fabric database is a key-value pair database. Endorsing peers execute the transaction on top of the copy and once the transactions are implemented, the read set and write set of the keys are changed automatically. Once the endorsing peers check that the transactions are in the correct order then they validate the transaction after verifying it. The endorsing peers sign the proposal with their certificate issued by a membership service provider MSP. After that, they send it back to the application.

Once the application receives this transaction, it checks for the satisfaction of the endorsement policies and if the endorsement policies are met, then it sends the transaction further to the ordering service. The ordering service is the central entity which updates the state of the blockchain. The ordering service receives this transaction and orders them into a block. It checks what kind of reads and writes are going to be updated within the transaction and checks whether are a part of the block or not. Once everything is examined, the ordering service puts this completed transaction change as a new block over the blockchain. It means that once the blockchain state is renewed, the transaction block is refreshed.

After that, the committing peers validate the endorsement policy and commit the new block to the chain and valid transactions to the database. Finally, all the peers who are connected to the blockchain will update their state and get the new read set and write set for the blockchain state through gossip protocol working behind the scenes.

Reference:

Cover image:
https://www.ibm.com/blogs/blockchain/2020/01/hyperledger-achieves-huge-milestone-introducing-hyperledger-fabric-2-0/

Hyperledger Fabric and MSP

Yongchang He — Mon, 04 Jul 2022 20:56:59 +0000

The purpose of building this blog is to write down the detailed operation history and my memo for learning the dApps and Web3 programming.

MSP - Membership Service Provider

What is Hyperledger Fabric?

Hyperledger Fabric, hosted by Linux Foundation, is a modular and extensible open-source system for deploying and operating permissioned and private blockchain.

It is the first truly extensible blockchain network for distributed applications written in standard, general-purpose programming languages, without systemic dependency on a native cryptocurrency. This is a sharp contrast to existing platforms requiring domain-specific programming languages or relying on a cryptocurrency.

Hyperledger Fabric also allows component pluggability, such as membership, database, and consensus. Typically, the membership layer can authenticate users and grant them access based on their access level and the system policy.

What is Hyperledger Fabric Identity Management?

Identity Management refers to the Membership Service Provider (MSP), which manages and authenticates all the participants/users on the network.

If any participants connect to the network, the owner can register them on MSP, where specific information about them will be stored. After that, a certificate will be generated and issued by the MSP, which will act as their identity over the blockchain. They will need this certificate identity for all transactions on the Fabric network. So, MSP provides you access control over the permissions.

For example, in the case of academic credentials, only universities and educational institutes have permission to create new transactions over the network, which means only they can upload the academic credentials over the network.

On the other hand, students can only have the read permissions allowing them to view their educational credentials or report cards without giving them the authority to perform any functionalities over the network.

Benefits of Hyperledger Fabric

Permissioned network

Establish decentralized trust in a network of known participants rather than an open network of anonymous participants.

Confidential transactions

Expose only the data you want to share to the parties you want to share it with.

Pluggable architecture

Tailor the blockchain to industry needs with a pluggable architecture rather than a one-size-fits-all approach.

Easy to get started

Program smart contracts in the languages your team works in today, instead of learning custom languages and architectures.

References

https://dl.acm.org/doi/pdf/10.1145/3190508.3190538
https://www.ibm.com/topics/hyperledger
https://www.hyperledger.org/use/fabric

Deploy your React App on Github in 5 minutes

Yongchang He — Mon, 27 Jun 2022 15:24:55 +0000

1. At your app root directory, run the command:

npm install gh-pages

2. Publish your app to GitHub:

Ether button is OK.
Ignore this step if you have already published your app

3. Add the following to the first line of package.json:

"homepage": "https://GIT_USERNAME.github.io/REPOSITORY_NAME",

For the URL string, you will need to replace it with your git user name and your current repository name.
TIPS: click the gear icon on the GitHub page, and the URL will show up:

4. Add the following in "scripts" in package.json:

"predeploy":"npm run build",

"deploy":"gh-pages -d build",

5. Save the app and commit the change to update your remote repo.

Alternatively, you can directly update your JSON file on the GitHub webpage and commit changes.

6. Deploy the app by running:

npm run deploy

After the deployment, some changes exist. Just commit these changes again.

7. Find your app URL at General > Pages:

8. Have fun!~

This is my React app Demo I used for this tutorial and welcome to play
Git Repo for this game

Reference

Cover Page from:
https://akhtarvahid.medium.com/setup-git-and-deploy-react-app-to-github-pages-7b5c4180fdaf

Q&A with Self-built Blockchain and Dapps (2)

Yongchang He — Mon, 20 Jun 2022 16:13:34 +0000

The purpose of building this blog is to write down my memo for learning the dApps.

Q1: brew no such file or directory?

When I want to remote access to my PC, it always tells me that brew is not properly installed.
How do i fix this problem?

-bash: /bin/brew: No such file or directory
-bash: /bin/brew: No such file or directory

A1:

Try uninstalling Homebrew and then re-installing solved issue for me.

Uninstall Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/uninstall.sh)"

Re-install Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

And better to update afterwards:

sudo apt update
sudo apt upgrade

Q2: What is the connection between IPFS and Filecoin?

A2:

Filecoin and IPFS are two separate, complementary protocols, both created by Protocol Labs. IPFS allows peers to store, request, and transfer verifiable data with each other, while Filecoin is designed to provide a system of persistent data storage. Under Filecoin's incentive structure, clients pay to store data at specific levels of redundancy and availability, and storage providers earn payments and rewards by continuously storing data and cryptographically proving it.

In short: IPFS addresses and moves content, while Filecoin is an incentive layer to persist data.

These components are separable - you can use one without the other, and IPFS already supports more self-organized or altruistic forms of data persistence via tools like IPFS Cluster (opens new window). Compatibility between IPFS and Filecoin is intended to be as seamless as possible, but we expect it to evolve. You can view the draft spec for IPFS-Filecoin Interoperability (opens new window)and ideas for future improvements (opens new window)to learn more.

Q3: Mining process

A3:

Mining is the process of recording the pending transaction by adding a new Block into the BlockChain through a mathematical puzzle. Miners get rewarded for by receiving the new crypto coins of that Blockchain.

Mining rewards are given to the miner who first finds the solution to a complicated hashing problem, and the chance of a miner finding the solution is proportional to the portion of the network's overall mining capacity.

Miners need to solve a mathematical problem when trying to add a block to the blockchain.

Block can only be added to the blockchain if its signature that is the hash output starts with a certain amount of zeros.

If the data string of the block does not generate to a signature that start with so many consecutive zeros, miners will keep changing the nonce endlessly until they randomly hit an output string that matches the signature requirements.

In mining a block is added to the blockchain after miner validates this block and confirms it.

The process of mining is not mandatory for a blockchain to exist. The mining concept is a way of validation for the transactions; that is why most public blockchains use it.

References

https://docs.ipfs.io/concepts/faq/#ipfs-and-filecoin
https://www.investopedia.com/tech/how-does-bitcoin-mining-work/
cover image:
https://stock.adobe.com/ca/search?k=q%26a&asset_id=431829099

Tutorial - Using create2 to predict the contract address before deploying

Yongchang He — Mon, 13 Jun 2022 14:52:12 +0000

This tutorial is meant for those with a basic knowledge of Ethereum and smart contracts, who have some knowledge of Solidity.
The purpose of building this blog is to write down the detailed operation history and my memo for learning the dApps and solidity programming.
If you are also interested and want to get hands dirty, just follow these steps below and have fun!~

Prerequisites

Remix for contract testing
Basic knowledge of Ethereum and Solidity

The create2 opcode gives us the ability to predict the contract address where a contract will be deployed. This opens up lots of possibilities to improve user onboarding and scalability.

contract overview



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
//Use Create2 to know contract address before it is deployed.
contract DeployWithCreate2 {
    address public owner;
    constructor(address _owner) {
        owner = _owner;
    }
}
contract Create2Factory {
    event Deploy(address addr);
    // to deploy another contract using owner address and salt specified
    function deploy(uint _salt) external {
        DeployWithCreate2 _contract = new DeployWithCreate2{
            salt: bytes32(_salt)    // the number of salt determines the address of the contract that will be deployed
        }(msg.sender);
        emit Deploy(address(_contract));
    }

    // get the computed address before the contract DeployWithCreate2 deployed using Bytecode of contract DeployWithCreate2 and salt specified by the sender
    function getAddress(bytes memory bytecode, uint _salt) public view returns (address) {
        bytes32 hash = keccak256(
            abi.encodePacked(
                bytes1(0xff), address(this), _salt, keccak256(bytecode)
            )
        );
        return address (uint160(uint(hash)));
    }
    // get the ByteCode of the contract DeployWithCreate2
    function getBytecode(address _owner) public pure returns (bytes memory) {
        bytes memory bytecode = type(DeployWithCreate2).creationCode;
        return abi.encodePacked(bytecode, abi.encode(_owner));
    }
}

We use Create2Factory to deploy the contract DeployWithCreate2. First we get the byteCode of the contract DeployWithCreate2 using the function getBytecode, and then we use byteCode and owner-specified salt to compute the address of contract DeployWithCreate2. Finally we use function deploy to deploy the contract DeployWithCreate2 to see the actuall contract address.

Contract testing steps

getBytecode

getAddress

deploy with the same salt value

check logs



logs    [
    {
        "from": "0xDA0bab807633f07f013f94DD0E6A4F96F8742B53",
        "topic": "0x55ea6c6b31543d8e2ec6a72f71a79c0f4b72ed0d4757172b043d8f4f4cd84848",
        "event": "Deploy",
        "args": {
            "0": "0x0B4f6a49C6a97B5dBB62F8A594cDefe5EabB4658",
            "addr": "0x0B4f6a49C6a97B5dBB62F8A594cDefe5EabB4658"
        }
    }

Git repository

Welcome to visit the Git repo for source code (Create2.sol or Example-44), and feel free to reach me by leaving a message below or via email found in my profile.

Thank you!

hyc0812 / solidity-essentials

Solidity programming baby examples...

Solidity-Baby Steps...

The best path for earning Solidity is to approach examples.

Here are baby examples. Typing one-by-one is recommended.

References:

MyBlog explanation for using EnglishAuction and testing.

examples

videoResource

Example-1

updateBalance & getBalance

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract MyLedger {
    mapping(address => uint) public balances;
    function updateBalance(uint newBal) public {
        balances[msg.sender] = newBal;
    }
    function getBalance() public view returns(uint) {
        return balances[msg.sender];
    }
}

Example-2

Inherited from Square

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/utils/Strings.sol";

contract Shape {
    uint height;
    uint width;

    constructor(uint _height, uint _width) {
        height = _height;
        width = _width;
    }
}

contract Square is Shape {
    constructor(uint h, uint w) Shape(h, w) {}

    function

…

View on GitHub

References

https://docs.openzeppelin.com/cli/2.8/deploying-with-create2
https://www.youtube.com/watch?v=883-koWrsO4&list=PLO5VPQH6OWdVQwpQfw9rZ67O6Pjfo6q-p&index=58
https://blog.openzeppelin.com/getting-the-most-out-of-create2/

Tutorial - play with an auction demo based on ERC721

Yongchang He — Mon, 06 Jun 2022 14:45:57 +0000

This tutorial is meant for those with a basic knowledge of Ethereum and smart contracts, who have some knowledge of Solidity.
The purpose of building this blog is to write down the detailed operation history and my memo for learning the dApps and solidity programming.
If you are also interested and want to get hands dirty, just follow these steps below and have fun!~

Prerequisites

Remix for contract testing
Basic knowledge of Ethereum and Solidity

Smart contract overview

This contract is for selling NFT. The general idea is that users (accounts) can send their bids to the contract for winning the NFT during a bidding period. The initial ownership for this NFT is the contract owner account[0] / address(0)(assume that we deploy the contract using account[0]). The highest bidder will win the ownership of the NFT. Participants can withdraw their bids when the selling ends.

Remark: This is test version not for production use.

Overview of the contract code (EnglishAuction.sol):

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;

interface IERC721 {
    function transferFrom (
        address from,
        address to,
        uint nftId
    ) external;
}

contract EnglishAuction {
    event Start();
    event Bid(address indexed sender, uint amount);
    event Withdraw(address indexed bidder, uint amount);
    event End(address highestBidder, uint amount);

    IERC721 public immutable nft;
    uint public immutable nftId;
    address payable public immutable seller;
    uint32 public endAt;
    bool public started;
    bool public ended;
    address public highestBidder;
    uint public highestBid;
    mapping(address => uint) public bids;

    constructor(address _nft, uint _nftId, uint _startingBid) {
        nft = IERC721(_nft);
        nftId = _nftId;
        seller = payable(msg.sender);
        highestBid = _startingBid;
    }
    function start() external {
        require(msg.sender == seller, "not seller");
        require(!started, "started");
        started = true;
        endAt = uint32(block.timestamp + 60); // 60 seconds should be long enough for the Demo and test.
        nft.transferFrom(seller, address(this), nftId);
        emit Start();
    }
    function bid() external payable {
        require(started, "not started");
        require(block.timestamp < endAt, "ended");
        require(msg.value > highestBid, " value < highest bid");
        if (highestBidder != address(0)) {
            bids[highestBidder] += highestBid;
        }
        highestBid = msg.value;
        highestBidder = msg.sender;
        emit Bid(msg.sender, msg.value);
    }
    function withdraw() external {
        uint bal = bids[msg.sender];
        bids[msg.sender] = 0;
        payable(msg.sender).transfer(bal);
        emit Withdraw(msg.sender, bal);
    }
    function end() external {
        require(started, "not started");
        require(!ended, "ended!");
        require(block.timestamp >= endAt, "not ended");
        ended = true;
        if (highestBidder != address(0)) {
            nft.transferFrom(address(this), highestBidder, nftId);
            seller.transfer(highestBid);
        } else {
            nft.transferFrom(address(this), seller, nftId);
        }
        emit End(highestBidder, highestBid);
    }
}

License identifier and compiler version are defined at first.
Interfaces are identified using the “interface” keyword. It contains function signatures without the function definition implementation. It can be used in a contract to call functions in another contract.
Event can be emitted in a specific function and the log can be seen in decoded output of each function call.
State variables are those whose values are permanently stored in a contract storage. Immutable state variables cannot be modified after the contract has been constructed.
A constructor is executed upon contract creation, and where we initialize the newly created NFT address, NFT ID, seller (that is contract owner account[0]) and the initial bid.
NFT ownership will be transferred from the contract owner to this contract when seller clicking "start" to execute start() function. 60 seconds is specified as the bidding period. You can always modify it as a longer time. When the bidding process started, users can send their bids with specific value by executing bid().
Function end() is used to terminate the bidding process and withdraw is to withdraw bids from this contract.

Testing process

Remix is used for contract testing.

1 - Deploy the ERC721.sol contract. findSouceCodeHere.

Mint the NFT ownership to account[0] by pasting the address(0), and specifying the nftId as your lucky number:

2 - Deploy the EnglishAuction.sol contract

ERC721 contract address, nftId and starting bids are needed:

3 - Approval for NFT ownership transmission Contract ERC721 needs account[0] to approve that the contract EnglishAuction will be able to transfer the NFT ownership from the seller to the contract itself. contract address of EnglishAuction and nftId are needed:

4 - Start the bidding process The seller can start the process by clicking start; other accounts can send bids with a specified amount of ETH:

5 - Check the Bidder information and ownership

Git repository

Welcome to visit the Git repo for source code, and feel free to reach me by leaving a message below or via email found in my profile.

Thank you!

hyc0812 / solidity-essentials

Solidity programming baby examples...

Solidity-Baby Steps...

The best path for earning Solidity is to approach examples.

Here are baby examples. Typing one-by-one is recommended.

References:

MyBlog explanation for using EnglishAuction and testing.

examples

videoResource

Example-1

updateBalance & getBalance

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract MyLedger {
    mapping(address => uint) public balances;
    function updateBalance(uint newBal) public {
        balances[msg.sender] = newBal;
    }
    function getBalance() public view returns(uint) {
        return balances[msg.sender];
    }
}

Example-2

Inherited from Square

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/utils/Strings.sol";

contract Shape {
    uint height;
    uint width;

    constructor(uint _height, uint _width) {
        height = _height;
        width = _width;
    }
}

contract Square is Shape {
    constructor(uint h, uint w) Shape(h, w) {}

    function

…

View on GitHub

References

https://cryptomarketpool.com/interface-in-solidity-smart-contracts/#:~:text=An%20interface%20in%20Solidity%20behaves,order%20for%20it%20to%20operate.
CoverPage
https://www.youtube.com/watch?v=ZeFjGJpzI7E