DEV Community: Staking7pc

Ewasm with Parastate

Staking7pc — Thu, 05 Aug 2021 18:16:08 +0000

Every decentralised blockchain ecosystem requires a virtual machine to process and execute their operations. The higher the complexity of the smart contract higher the execution time and the computational power required.

EVM (Ethereum Virtual Machine)

The EVM pretty much acts like this global computer, accessible by multiple nodes throughout the world.
So if a developer wants to host their dApp on Ethereum he can do so by deploying it on the Ethereum blockchain.The charges for doing so, is paid as the gas fee.

Whats the problem?

As with any new ecosystem, the blockchain world has evolved so rapidly and has so much adoption the EVM is

not as fast as it can be
not as cheap as it should be

Whats the solution?

As with any natural system improving the performance will reduce the cost and push the ecosystem to the next level. In comes WASM or the Ethereum flavour EWASM.

EWASM stands for Ethereum Web assmebly

WASM is quick

WASM has a stack-based, low-level binary format that’s small by default, it can load and execute quickly.

EWASM can be precompiled

Precompiles are unique bits of EVM bytecodes, making efficient cryptographic computations without consuming a tremendous amount of gas

EWASM supports multiple Programming languages

From having to develop smart contracts only in Solidity, WASM lets you develop your contracts in Rust, solidity etc.

EWASM is the new JS

eWASM enjoys native support from all the major JavaScript engines

So whats the significance of Parastate in all this?

Given multi chain is the next obvious step, there is a need for the bridge to connect the dapp's to run in multiple blockchains.

Thats where parastate comes in

Parastate has the ability to run contracts developed in ethereum on substrate platform.

It does so by using SSVM the fastest software execution as recognized by IEEE

Solpad - All you need to know

Staking7pc — Sat, 15 May 2021 09:04:42 +0000

Ok, what do we have here. It's the new entrant and yet very promising project Solpad.

They offer 3 major services as shown below, let's take a look at each of them.

The token price for the public sale varies from $0.014 to $0.016 based on the tier.

                          LAUNCH PAD

There are a number of launch pads these days and yet Solpad is something that's interesting to watch out for. Why? read below

----------------------------Tier structure-----------------------------

Let's consider a new project X that's being launched by solpad say with 100 tokens.

48 tokens will be allocated to the whales' pool. To be a part of the whales pool you must have at least 280,000 PAD (solpad tokens).

Take a look at the various tiers that are available.

No matter how many whales are there the maximum that they can get is 48 and the distribution is amongst the whales not the ones in other tiers.

Of course, they can be part of the other pools too, but hey! at least we are given a fair chance.

Maybe the shrimp pool will be crowded. Crabs can have less than whales, anything can happen.

You formulate your own strategy to give yourself the best chance.

Everybody gets a chance is all I am trying to say.

----------------Supports different blockchains----------------

Solpad is built on Solana but its wings spread far and white to even other blockchain ecosystems.

Needless to say, they are no one-trick pony!

Currently supported: Solana
In the near future: BSC and Ethereum

The number of blockchains that they will support will constantly increase.

------------------------PAD tokenomics------------------------

You can get more data from this official link

------------------------------Liquidity------------------------

The initial liquidity will start at 57.7M PAD tokens and from then on it will increase based on the schedule published here

We have depicted our understanding below

--------------------------Token Utility-----------------------

What makes Solpad stand out from the rest of the fundraising platforms is the token utility.

PAD token holders apart from being able to participate in the ICO's based on the number of tokens held can also vote in the DAO with the tokens.

This gives PAD token holders the ability to decide how the platform moves forward like deciding the number of tokens needed for tiers, which IDO's will be conducted in the platform by voting in the governance proposals.

                          AMM DEX

The next obvious question is after I buy tokens on Solpad how can we trade the tokens. Let's take a look

--------------------------------SOLSWAP------------------------

Let's say you have participated in the IDO sale for project Y from the Solpad IDO.

Usually to trade them you will have to wait until the tokens are listed on exchanges or on decentralized exchanges like Uniswap and wait for the teams to provide sufficient liquidity to be able to trade them. But in Solpad its different

This is where SOLSWAP comes in.

SOLSWAP is the multichain DEX and will connect between Solana and other platforms. Projects which conduct their IDO on Solpad will be instantly listed on SOLSWAP.

This means you will be able to trade instantly on SOLSWAP

Solswap will also act as a bridge between different blockchains for example between the Solana and BSC chain where the tokens can be instantly swapped between the chains and solswap will take care of the burning the tokens in one chain and minting them in another to maintain the total supply constant.

--------------------------Impermanent loss--------------------

Liquidity mining is one of the major components of the Defi space but it comes with its own risk called Impermenant loss.

To put it in a few words Impermanent loss happens when you provide liquidity to a liquidity pool, and the price of your deposited assets changes compared to when you deposited them.

To learn more about Impermanent loss refer to this article from Binance academy

-----------------------------Rewards---------------------------

So to protect token holders from Impermanent loss, liquidity providers of PAD tokens will be rewarded with PAD tokens so they don't lose tokens in case of price appreciation of PAD.

This provides a good incentive for token holders to provide liquidity

                          WALLET

The pain point with supporting multiple chains is that each chain has its own set of wallets and if you hold tokens in multiple chains it becomes difficult to manage multiple wallets.

Sol wallet will allow storing tokens belonging to multiple tokens in the same wallet. Not only storing them but you can also swap the tokens between chains using the swap that will be implemented in the SOl wallet.

ONE WALLET TO STORE THEM ALL

Below are some of the features offered

Store and transfer digital assets irrespective of their native chains.
Connect to blockchain applications on different chains
Swap seamlessly between protocols.
Manage and track digital assets on different chains.

                          INVESTORS

There is an impressive list of investors who have backed this project big time. Here are a few

List of 404 on Parastate

Staking7pc — Sun, 09 May 2021 17:08:31 +0000

1 - https://github.com/ParaState/pallet-ssvm

The link Substrate on this page as shown in screenshot shows 404

2 - https://medium.com/ethereum-on-steroids/an-improved-paper-with-go-to-market-strategies-471e45c42dbb

In this article the white paper is no longer accessible.

https://www.parastate.io/assets/wp.pdf

Create Dapps and deploy smart contract with Parastate

Staking7pc — Sat, 01 May 2021 20:38:23 +0000

In this post, we will discuss how we can create Dapp and deploy Smart contracts in Parastate.

Watch this created here in the below video

*Step1: Create a Metamask account for Parastate
*Step2: Fund the account and connect
*Step3: Write a Smart contract
*Step4: Compile and deploy
*Step5: Write Dapp with Web3.js
*Step6: Connect Web3 with Smart contracts

Step 1: Create a Metamask account for Parastate

There are numerous articles on this, you can refer one here.
Few things to note is the

RPC url: https://rpc.parastate.io:8545/
chain id: 123
Currency symbol: STATE

Step 2: Fund the account and connect

To fund the account, you need to take the account created from step1 and go to the faucet here and request STATE tokens

Step3: Write a Smart contract

To write a smart contract you need 2 things
1 - IDE
2 - Language

We use Buidl a Online IDE developed by Secondstate

And for the language, we have to use Solidity.

An example smart contract can be found below

pragma solidity >=0.4.0 <0.6.0;

contract BasicContract {
  int s_amount;
  address s_owner;
  constructor() public {
  s_owner = msg.sender;
  s_amount = 0;
}

modifier onlyOwner() {
  require(msg.sender == s_owner);
  _;
}

function deposit(int v) public   {
  require(v >= 0);
  s_amount = s_amount + v;
}

function withdraw(int v) public onlyOwner { require(v >= 0);
  require(s_amount >= v);
  s_amount = s_amount - v;
}

function getBalance() constant public returns (int retVal) { 
  return s_amount;
}

function getAddress() constant public returns (address a) { 
  return s_owner;
}
}

Step4: Compile and deploy

Once the smart contract is written you have to compile it and deploy it.

To compile, click on the Compile button then you will get the ABI and the BYTECODE created, these two are important for us to connect the Smart contract code with the Dapp that we will create with Web3

Once these two are done we will tap on deploy to chain.

So to test the Smart contracts, you do not need the Dapp.
You can see clearly there are 4 tabs, currently we should on the contracts section.

After compiling and deploying, now tap on the Deployed tab.

Here you will see all the functions inside the smart contract exposed. In this example we can see a deposit, withdraw, get balance and get address sections.

You can click on get balances to see your balance and then you can enter an amount and tap on the deposit button.

Now move to the logs section, you can see something like this

This is a confirmation that your smart contract was successfully deployed.

Step5: Write Dapp with Web3.js

To write a Dapp UI, we need the usual suspects HTML, CSS and JS.

Here is the HTML and JS code for your reference

<html>
<body>
    <h1> Parastate Spartan Task </h1>
    <p></p>
    <label id = "AccNo-lbl"></label>
    <p></p>
    <div>
        <label>Enter the amount</label>
        <input id="Enter_amount"/> 
    </div>
    <p> </p>
    <div>
        <label>Select action</label>        
        <button id="Deposit">Deposit</button>
        <button id="Withdraw">Withdraw</button>    
    </div>
    <p> </p>
    <label> Options available </label>
    <p> </p>
    <div>
        <button id="balance">Get-balance</button>        
    </div>
    <p></p>
    <label id = "balance-lbl"></label>
</body>
</html>

Javascript. i have explained below how to get the values for the three variables abi bytecode and cAddr

var abi = ''
var bytecode = '';
var cAddr = '';

var instance = null;
window.addEventListener('web3Ready', function () {
  var contract = web3.ss.contract(abi);
  instance = contract.at(cAddr);
  document.getElementById('AccNo-lbl').innerHTML = "Account No : "+instance.getAddress()
});


document.querySelector("#Deposit").addEventListener("click", function () {
  var amount = document.getElementById('Enter_amount').value
  instance.deposit(amount)
});

document.querySelector("#Withdraw").addEventListener("click", function () {
  var amount = document.getElementById('Enter_amount').value
  instance.withdraw(amount)
});

document.querySelector("#balance").addEventListener("click", function () {  
  var curr_bal=instance.getBalance()
  document.getElementById('balance-lbl').innerHTML=curr_bal;  
});

Step6: Connect Web3 with Smart contracts

In the JS section we need the connectivity between the Smart contract with the help of web3.

Here in this example we have 3 variables

var abi
var bytecode
var cAddr

you can get abi and bytecode by tapping on the Contracts tab and clicking on the Compiled section
cAddr can be taken from the Deployed tab as shown in figure below

Once you have the above set, the below lines code gives you the smart contract instance in the variable instance.

var instance = null;
window.addEventListener('web3Ready', function () {
  var contract = web3.ss.contract(abi);
  instance = contract.at(cAddr);
  document.getElementById('AccNo-lbl').innerHTML = "Account No : "+instance.getAddress()
});

All you have to do is call the function from the instance as shown below.

document.querySelector("#Withdraw").addEventListener("click", function () {
  var amount = document.getElementById('Enter_amount').value
  instance.withdraw(amount)
});

Now you can play around with the Dapp you have created.
Happy Coding!