Our system was based on the following stacks:

Frontend: Reactjs
Backend: Nodejs
Architecture: Microservices
db: AWS RDS: Mysql
Deployment :Amazon Elastic Kubernetes Service
Queue service : Rabbit Mq (for eventbased approach)
Elastic Search for CQRS approach to store complex recurring datas
Auth0 
Docker
Jenkins : CI/CD
AWS ECR : ECR, for pushing docker images from jenkins
AWS ECS :Elastic Container Service 
Inter service communication : GRPC protocol

How were we deploying our application?

We have 6 services dedicated to the inventory management system where I was Leading the team of 4 backend developers and 1 DevOps. I was supposed to take the technical decision. The development process was pretty clear :

• Developers work in their personal branch , they send Merge Requests to develop branch
• Ones merged in develop , CI/Cd triggered creating the docker image of service and pushing it to ECR
• Jenkins triggered EKS build process. EKS was pre-setup and was served with Helm, deploying the application

EKS removes the need to architect high availability and scalability for our master nodes. EKS automates load distribution and parallel processing faster and efficiently.

The Helm is a package manager for Kubernetes helps you install and manage applications on your Kubernetes cluster using which we can install and manage charts using the Helm CLI on our EC2 instances.

This was doing the job fine but seems like EKS is very expensive. It was $ 3448.

As a team lead, I had to take care of both the business and technical sides. When it was serving fine with EKs it was very expensive on the other hand. I needed to find a better solution for it, this was then I got a chance to look into ECS.

Amazon ECS is a fully managed container orchestration service that makes it easy for you to deploy, manage, and scale containerized applications.

Why did I choose ECS over EKS?

Pricing:

It depends on the number of clusters needed for application deployment. On EKS, you pay a fee of $0.10 per hour for each cluster you operate. ECS is likely to cost significantly less because there are no per-cluster charges.

Networking

EKS provides a better networking configuration when running on EC2 instances but when your containerized application will run on Fargate, ECS will just do the work fine. There was nothing much we could lose by switching to EKS

Simplicity

As I was in the middle of a running project, we could not lose a lot of time in learning the new process from scratch. ECS was very easy to build, deploy, or migrate our containerized applications.

For example, if you need a load balancer, AWS Application Load Balancer (ALB) integrates seamlessly with Amazon ECS.

Auto-scaling:

We can define the number of tasks we want to run during service configuration. Increase or decrease the number of tasks that your service runs based on a target value.

ECS Deployment works in 3 basic steps.

1. Defining task
2. Defining service
3. Define env variable
4. Deploy

This is the difference in cost we experienced after a month of switching to ECS.

My Conclusion

EKS could be better in many ways but ECS with Fargate did work just fine as per my project need.

Problems so far:
1. Keyboard issue: video here
2. Distorted Sound: video here
3. MagSafe not working: video here
4. The device stopped charging with the new charger too


It has been a very bad experience so far with Mac Book Pro 14" as well as Apple Support Staff. The problem started after 5 months of buying this laptop on 28 Dec 2021.

First was the keyboard Issue which you can check here: (May 2022)

Issues:
1. Mistyped keys as shown in the video
weird key noise

I went to this Apple service center, diagnosed the test, and find out that it was some inbuilt issue with hardware and since the device was under warranty they replaced the new keyboard.

2. Distorted Sound from Speake: check the video here

This was discovered along with the above-mentioned keyboard issue, which they told will be fixed along with the keyboard, but it never happened.
This is so irritating, you get such weird noise every time you play some music or video/voice call using this device

3. Flickering Display: check the video here

Isn’t it so irritating to see such flickers on your screen all the time when you use your device?

4. Mag Safe stopped charging: video here

When there were already soo many issues with this device, it stopped charging.

5. Device was not charging with any other charger as well

My experience throughout the process till today: from May 2022 to Aug 2022

After I noticed the first issue discovered 5 months after purchase of the new MBP pro 14", I went to Apple support based in Kathmandu, Nepal. They did some internal testing and found out that there was some inbuilt issue with the keyboard. It took 3 weeks for them to replace the new keyboard. 3 weeks without a laptop for someone working in the IT field is a big issue. I work on this laptop for more than 8 hrs a day and it was not easy for me to manage a replacement device to work on.

Now, the keyboard was working fine after a replacement but the distorted speaker persists, which I considered and move on. After some time, the display starts flickering. I was very frustrated at this point. I again went to the same customer care, they told me to contact Apple support as I was asking if my faulty device could be replaced as there were multiple issues arising within 6 months of buying it.

I was assigned this ticket number ==> 101707747857 and appointed me a senior technical assistant. They said they won’t be able to call me in my current location i.e Nepal so asked me to go to India, Banglore.

Can you imagine, for just phone support, I had to make arrangements to go to India? I did all of it, visa processing, flight ticket, accommodation, and went to India with the hope of getting justice for this device.

First, I went to a support center near my hotel, but they refused to take my device for my replacement request see the video here. I believe they should have been empathetic rather than showing such behavior as this is very basic we expect from Apple. They were harsh with their behavior and I was all alone. Some of their customers came to support me and speak in my favor, which you can hear in the background of this video. Since I was not allowed to make the video, I did an audio recording which I can release if someone wants to hear the full conversation.

I came back to the hotel and reach out to Apple support Via the chatting system and told them about my problem. One of them asked me to arrange a sim card so that they can assign a senior consultant to call me. It took me 4+ days to arrange the sim card and when I reach them back with a phone number, they asked me to perform some basic stuff which they guided me over the support chat itself, and for the time being those issues went off.

Probably this should have been the very first step rather than me flying abroad with the hope of getting phone support where the problem was fixed via the chat support itself. I don’t know why there was no coordination among the support staff because of which I had to go through unnecessary trouble.

I returned back home thinking at least my problem is now resolved.

But, after 3 weeks of using this device, all of these issues started again.

I was helpless and was doing nothing until my charger stopped charging my device. Again took the device to a support center based in Kathmandu, and showed them that it was no longer charging my device. They tried with their charger and still, it was not charging so they asked me to leave my device to them so that they can test further.

I got a call after 2 days from them i,e today 12 Aug 2022 saying no issue encountered again. The same employee who tested my device before asking me to leave it to them said they are not able to reproduce the same issue so they are returning it back to me without any action.

What am I supposed to do in this case?

As per this link's 2nd and 3rd points, I believe I should get a replacement. Or is it a geographical barrier that is stopping them to extend replacement services or even phone call services to my country?

Someone, please suggest to me what shall I do next. I hope you understand my frustration.

Kind Regards,

Well, so it has been quite a time since I have last published something technical stuff here, yes there are so many of them in the draft which I will publish in a while. Most of them are under microservice architecture as for quite a time I have been involved in such a fascinating software development technique. There is a lot to share under that hood but for now, let’s get this Hd address thing done in bitcoin.

You can explore theoretical aspects of HD wallet in this article here. But in short, HD wallet is the approach of generating N number of bitcoin wallet using the same key phrase so-called as mnemonics.

Private Key, Public Key, and bitcoin Address

The private key provides a signature that proves you are the owner of a particular bitcoin address and is simply nothing but a random number generated between 1 to N-1 where N = 2²⁵⁶ (approx). If you ever thought about how the randomness is created, you should check this link, where you are asked to randomly move your mouse cursor a number of times (which will create a random pattern which is no way going to be the same all the time you initiate the process ). We feed this random string to the sha256 hash algorithm and the output of 256 bit is our private key.

The public key is a cryptographic key generated by Elliptic Multiplication on the private key

And address is the outcome of one-way hash function SHA256 applied over public key and RIPEMD applied over the result.

i.e Public Key = RIPEMD160(SHA256(Pvtkey))

So much technical stuff right ?? let’s wrap it up with the following image

I will be using Nodejs for this demo and We shall be using the following libraries :

var bitcoinLib = require("bitcoinjs-lib");
var bip39 = require('bip39');
var bip32 = require('bip32');

bitcoinjs is a javascript Bitcoin library for node.js

bip39 is mnemonic code for generating deterministic keys

bip32 is the Bitcoin Improvement Proposal which introduced the standard of HD wallets and extended keys to Bitcoin.

Mnemonics :

Mnemonics are randomly generated 12 to 24 words from a fixed list of 2048 (proposed in BIP39)potential words. Each word is represented by an integer from 0 to 2047 corresponding to its position in the list. These random numbers are used as the seed used to derive a deterministic wallet.

You can generate seed with the following library :

const mnemonic = bip39.generateMnemonic(); //generates string 
const seed = await bip39.mnemonicToSeed(mnemonic);

The mnemonics are used as a backup to regenerate the entire wallet family.

HD path :

Since our topic itself is HD which stands for Hierarchical Deterministic, we should be able to find some Hierarchy and that’s where the HD path comes into play. This is the hierarchy using which we can generate N number of addresses. Every coin has its own unique HD path which you can check out here. For now, let’s check it for ETH and BTC,

btc_test_hd_path = m/44'/1'/0'/i
btc_main_hd_path = m/44'/0'/0'/i
eth_hd_path = m/44’/60’/0’/i

Now what is this fuss all about is >>

m’ / purpose’ / coin_type’ / account’ / change / address_index

For sure you have seen this a lot of times, but what is this all about ??

It is all about BIP0044 which proposes a multi-account structure as “purpose” number 44'. All HD wallets following the BIP0044 structure are identified by the fact that they only used one branch of the tree: m/44'/. So :

purpose’ → always remains 44'.

coin_type’ → for btc its 0/1 , for eth its 60, and you can find it for other altcoins here

account’ → This is your business need, let’s say the account I give to the public forum for donation is > m/44'/0'/1 and for my personal use is m/44'/0'/0’

change → is for change address

address_index → is the index of Nth position of your generated address.

Probably this is all theory is required for you to good to go with HD addresses. For sure it’s a never-ending topic, so ever you want to explore more on this topic I would highly recommend Mastering Bitcoin. This is the best book i have ever read.

Time for coding !!!!

var index = 1 // this is address_index

const mnemonic = await bip39.generateMnemonic();

var hd_path = m/44'/1'/0' // for testnet

const seed = await bip39.mnemonicToSeed(mnemonic);

const root = bip32.fromSeed(seed, network);

const account = root.derivePath(hd_path);

const accountXPub = account.neutered().toBase58();

const node = bip32.fromBase58(accountXPub, network);

const child = node.derive(0).derive(index);

const address = bitcoinLib.payments.p2pkh({ pubkey: child.publicKey, network }).address;

let pvtKey = account.derive(0).derive(index);
pvtKey = pvtKey.toWIF();  // this is the private key

const account_details = { address: address,  mnemonic : mnemonics, index: index});

console.log(account_details)

output >>

{
   "address":"mierjL7fxLE3QAoAn52EibxMDnorqUXqQM",
   "index":8,
   "mnemonic":"index doll town issue reflect colla rose kiss zero  brass library town"
}

And this is it !!

You have address generated, the private key of it, the mnemonics , what all you need ? Now you can generate N number of such addresses and get to remember single thing i,e mnemonics .

This is the beauty of HD addresses.

Cheers for the life !!!

I will see you in next one!!

For instance, we will be using very simple smart contract

pragma solidity ^0.4.25;

contract Test {    
    uint256 a;
    
    constructor (uint256 val) public {
         a = val;
    }
    
    function printAll() public view returns(uint256){
        return a;
    }

function setA(uint256 val) public {
        a = val;
    }
}

Now let's deploy above contract using only web3 js

Deploy process

1)Initializing the process

1) First, we require web3js make sure to have installed the newest version.
Refer this and this document for more details.

2) Since our contract will be fetched via a file(test.sol) we need filesystem (fs ) as well.

3) We will be using ganache cli for the deployment

const Web3 =  require('web3')  
const fs = require('fs');
const ganache_cli = "http://localhost:8545";
var web3 = new Web3(Web3.currentProvider || ganache_cli);

2) compile the source code and fetch its abi and byte code

const sourceCode = fs.readFileSync('test.sol','utf8').toString();
const compiledCode =  compiler.compile(sourceCode,1).contracts[':Test']
const interface = JSON.parse(compiledCode.interface);
const bytecode =  compiledCode.bytecode;

3) deploy contract

After you have bytecode and abi(in above code interfact is the abi) you are ready to go for deployment process all you need is a address which you can fetch from ganache account.

function deploy_contract(){
    const myContract = new web3.eth.Contract(interface);
    myContract.deploy({data:bytecode,arguments:[45]}).send({
        from:"0x1ca9e8C97cb0fA5Ec6b49DF7501A23212a4b9d2d",
        gas: 4700000
    },(err,res) => {
        if(err){
            console.log(err);
        }
        if(res){
            console.log(res);
        }
    })
    
}

in the above code myContract.deploy() is the rpc we need to understand.

It takes data as bytecode and if your constructor need to be passed some argument you need to pass here, IN our contract we need to pass uint as constructore argument so we are passing lets say 45 here,

myContract.deploy({data:bytecode,arguments:[45]}).send({
        from:"0x1ca9e8C97cb0fA5Ec6b49DF7501A23212a4b9d2d",
        gas: 4700000
    }

After you invoke deploy_contract() function you will get a txid in your console :

0xe744bf3462a0cbf4a35d9e33cf2150d435aef84cf6e499ca9905d87a14d2ac95

That mens your contract is deployed and you get the receipt of it.

to verify the receipt you can invoke RPC all getTransactionReceipt i.e

const txid = "0xe744bf3462a0cbf4a35d9e33cf2150d435aef84cf6e499ca9905d87a14d2ac95"

async function  getTransactionReceipt(){
const receipt =  await web3.eth.getTransactionReceipt("txid");
    console.log(receipt)
}

which will give you the following output with your contract address:

{ 
transactionHash:
   '0xe744bf3462a0cbf4a35d9e33cf2150d435aef84cf6e499ca9905d87a14d2ac95',
  transactionIndex: 0,
  blockHash:
   '0xa7e82a28fb5a20534da240673ea192d84fc63a783f1dfe4a0933599ae4527972',
  blockNumber: 1,
  from: '0x0d849ad6868eae598e02aac966680c5b6e2d2f76',
  to: null,
  gasUsed: 125097,
  cumulativeGasUsed: 125097,
  contractAddress: '0xD264C0F2Bfc6eb43c2e3C9a0A97363E4B3568C86',
  logs: [],
  status: true,
  logsBloom:
   '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
  v: '0x1b',
  r:
   '0xac5c255178d065578f6d8597fe35642a9c8efd77325adf2f8f3a9b8c96c8de9f',
  s:
   '0x74c27849e4d4fdb076fd63db5ea0b50522da08249530177cfcb43013c7792573' }

Interact with contract

First, create the contract interface of our deployed contract address with the given abi

function interract_contract(){
    const contract_address = "0xD264C0F2Bfc6eb43c2e3C9a0A97363E4B3568C86";
    const abi = interface;
    var contract_interfact = new web3.eth.Contract(abi,contract_address,{
     from: "0x0aed251C576fF1214567cad627aBf4693243e45f",
     gasPrice: '20000000000'   
    });
}

now using the newly created interface you will call the methods inside the contract, for now, we have 2 methods printall and setA which we will call in the following manner:

1. printAll() → will print the value initialized in the constructor
2. setA(uint256) → will update the value
3. printAll() → to verify if value is updated

we will be using contract_interfact.methods.method.call/send RPC :

contract_interfact.methods.printAll().call({from:"0xc00fF6eD9aa292BFA422D6E05eA7d7dc4336269c"},(err,res) => {
        if(err){
            console.log(err);
        }else{
            console.log('constructor param before updating it is: '+ res);
        }
    });

contract_interfact.methods.setA(356).send({from:"0xc00fF6eD9aa292BFA422D6E05eA7d7dc4336269c"}).then(function(receipt){
        console.log(receipt);
    });

contract_interfact.methods.printAll().call({from:"0xc00fF6eD9aa292BFA422D6E05eA7d7dc4336269c"},(err,res) => {
        if(err){
            console.log(err);
        }else{
            console.log('constructor param after updating it is  : ' +res);        }

});

You will be getting the output as

constructor param before updating it is: 45

constructor param after updating it is : 356

Thats it!!!

Ever wonder how much time you spend in a day watching at the price of various cryptos. I was one of you, so i thought of creating something that makes my life little easier,

git clone https://github.com/bluppfisk/coinprice-indicator

create venv: my case coin_widget

1)virtualenv -p python3 venv_name

user in my case is parin

Find new python executable in /home/parin/Documents/parin/Documents/coinprice-indicator/coin_widget/bin/python3

Also creating executable in /home/parin/Documents/parin/Documents/coinprice-indicator/coin_widget/bin/python

cd /home/parin/Documents/parin/Documents/coinprice-indicator/coin_widget/bin

Activate new virtual env with :

source activate

(coin_widget) parin@paarin:~/Documents/parin/Documents/coinprice-indicator/coin_widget/bin$

Install dbus-python from following link & follow user cryptoktm (yes thats me again)

Install Python-Dbus in virtualenv

install further dependencies from requirement.txt in master branch

cat requirements.txt

install -r requirements.txt

pip freeze

Ones required packages are insalled cross check the manager with

pip freeze

you should meet following dependencies:

certifi==2018.8.24
chardet==3.0.4
dbus-python==1.2.8
idna==2.7
notify2==0.3.1
pycairo==1.17.1
pygame==1.9.4
PyYAML==3.13
requests==2.20.0
ruamel.base==1.0.0
ruamel.yaml==0.15.64
urllib3==1.23
vext==0.7.0
vext.gi==0.7.0
websockets==6.0
certifi==2018.8.24
chardet==3.0.4
dbus-python==1.2.8
idna==2.7
notify2==0.3.1
pkg-resources==0.0.0
pycairo==1.17.1
pygame==1.9.4
PyYAML==3.13
requests==2.20.0
ruamel.base==1.0.0
ruamel.yaml==0.15.64
urllib3==1.23
vext==0.7.0
vext.gi==0.7.0
websockets==6.0

After the required settings, you are good to go with executing the executable with with:

cd /home/parin/Documents/parin/Documents/coinprice-indicator ./run.sh

And if everything goes well shoud see a ticker strap on top of your desktop

Bitcore is a SAAS infrastructure that helps us to create Bitcoin-based application, allowing us to easily interact with Litecoin Blockchain. Litecore comes with a package allowing us to easily setup Litecoin full node and provides APIs to interact with it. Here is the list of the functionality provided by bitcore:

1. Bitcoin wallet service (client and server)
2. Bitcoin explorer
3. Full node setup

Lets start with the setting up Bitcore in Ubuntu 16.04

1) Installing Nodejs v>8.x

There are soo many ways to deal with it, I will be guiding for the simplest one

a) Create nodesource.list

sudo vim /etc/apt/sources.list.d/nodesource.list

b) Add following lines(you can replace 8.x with whichever version of Nodejs you want to install)

deb https://deb.nodesource.com/node_8.x xenial main
deb-src https://deb.nodesource.com/node_8.x xenial main

c) Download the GPG Signing Key from Nodesource for the repository

curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | sudo apt-key add -

d) sudo apt-get update

Just to verify if everything is going well you can check with the following command:

apt-cache policy nodejs >>>

Version table:
8.2.1-1nodesource1~xenial1 500
500 https://deb.nodesource.com/node_6.x xenial/main amd64 Packages
4.2.6~dfsg-1ubuntu4 500
500 http://archive.ubuntu.com/ubuntu xenial/universe amd64 Packages

e) sudo apt-get isntall nodejs

You will be having an updated version of NodeJs installed in your system

$ nodejs — version
v8.15.0https://github.com/litecoin-project/insight-lite-api

And your nodejs is installed.

2) Installing Bitcore

To install the latest version of bitcore ,BTC node version till 0.12.1 is required, let's download the same

sudo npm install -g bitcore  — unsafe-perm=true

You might encounter following error

fatal error: zmq.h: No such file or directory

For this your need to install libzmq3 in your local machine, which can be done with following command:

apt-get install libzmq3-dev

Bitcore uses zeromq internally, Now what is Zeromq?

ZeroMQ is a high-performance asynchronous messaging library, aimed at use in distributed or concurrent applications. It provides a message queue, but unlike message-oriented middleware, a ZeroMQ system can run without a dedicated message broker. Click here for detail

After zeromq has been installed in your system, try downloading the bitcore library with the above-mentioned command.

3) API consumption

To start the API services, you first need to download bitcoin node in your local machine for that first create a directory where your node will be downloaded and start synchronizing process with the following command :

bitcore create mynode_btc
cd mynode_btc
bitcore start

For API details please follow their official github

This problem can be resolved with a combination of AI and Blockchain.

Malware: software that is specifically designed to disrupt, damage, or gain unauthorized access to a computer system.

The task of malware detection is done with private node following the constellation protocol as provided by quorum and deep belief
neural network (DBN) as the detection engine.

Our approach is to detect Malware embedded code/file into two classes being affirmative or negative using DBN.

Approach:

An extensive data set of positive as well as negetive data is used to train the DBN and the dataset set is provided to each node as transactions. The blockchain architecture of quorum is being used to make sure the that no single corrupt node will be able to compromise the network.

Procedure

Any new file added to a node in the network have detection engine (DBN [trained model]) that helps to detect the malware using deep belief neural network (DBN).
The numeric result produced by a engine represents the probability of the file being malicious or not.
The numeric probability along with the hash of the file is boradcasted to blockchain and at the same time the copy of the file is being transmitted to each constellation node for respective
validation.
By this point it has only been broadcasted but not validated by other peer nodes so the file is still not accepted by the network.
When other peer node get the transaction in blockcahin, they check if the equivalent file has been received by their constellation node or not. After getting the positive response
every constellation node, make the file run through the detection engine. All the nodes possess unique but similar detection engines of their own and they produce their own probability.
if the calculated probability is more the the minimum threshold then the file is not mallecious and the respective node accepts the file otherwise they decline the file .
Accordingly if maximum node validate the transaction then the file is not mallecious and is included in the network else its is descarded by the entire network.

This is how you can protect your network from being compromised from possible maleares added in the network by intruders.

This is just a approach from my side. If any one liked my approach and is interested in R&D on this topic feel free to contact me. I would be happy to help you with my knowledge and contribution regarding it.

Regards,

The address by which you deploy a contract now becomes a owner address,When you deploy a ERC20 contract you first transfer all of the total supply to owner address in my case it is

owner : 0xca35b7d915458ef540ade6068dfe2f44e8fa733c

code source : https://ethfiddle.com/5WOwwx4u05

1.Total Supply

Gives the total supply of the particular ERC20

initially the total supply is defined to be :

uint256 private constant totalsupply_ = 1000000000

When we deployed the contract, we have mentioned in our constructor that

constructor() public{

balanceof_[msg.sender] = totalsupply_;
owner = msg.sender;
}

total supply is assigned to the balance of owner address,
so at this point(just after deploying a contract) balance of my owner address is 1000000000

2. Transfer

function transfer(address to_, uint256 value_) external returns (bool){

This function transfer tokens from one address to another

ip:

to_address → the receiver address (for instance our to_address is : 0xdd870fa1b7c4700f2bd7f44238821c26f7392148 )

value → no of token to be sent

eg:

ip parameters:

“0xdd870fa1b7c4700f2bd7f44238821c26f7392148",10

op:

true/false

3)BalanceOf(address)

Function gives the balance of particular address

earlier balance of to_address(0xdd870fa1b7c4700f2bd7f44238821c26f7392148 )was 0

now after i called transfer function my balance of to_address(0xdd870fa1b7c4700f2bd7f44238821c26f7392148) address is 10

4) approve

In some cases owner can approve thrid party address to transfer balance from owner’s address to xyz address. For that first of all owner need to assign third party address the right , and he can do so by calling approve function..

function approve(address spender_, uint256 value_) external returns (bool){

here spender_ is the third party address that need to be given rights of owner

lets say that address is : 0x583031d1113ad414f02576bd6afabfb302140225 , and he wants to allow spender to send 5000 coins

to do so owner need to call approve function with following parameter

ip: approve(“0x583031d1113ad414f02576bd6afabfb302140225”,5000)

op: true

5) allowance

This function validate how many tokens are actually allowed by owner to third_party address so that he can transfer on behalf of owner:

for eg: in step 4 we assign 5000 tokens as sendable by address : 0x583031d1113ad414f02576bd6afabfb302140225 which we can validate using allowance function

ip: allowance (“0xca35b7d915458ef540ade6068dfe2f44e8fa733c”,”0x583031d1113ad414f02576bd6afabfb302140225")

op: 5000

here

0xca35b7d915458ef540ade6068dfe2f44e8fa733c → address of owner

0x583031d1113ad414f02576bd6afabfb302140225 → address of sender

6) transferFrom

the use of this function is kind of trikky,

If you think this is normal function where from and to address is given and by calling this function you can transfer funds from one address to another address then thats wrong. You cannot manipulate balance from other address though you are the contract owner, unless someone approves you by calling approve function(like we did it before)

Now to test this function:

instead of ower calling the function we should call the function with the third_party address(0x583031d1113ad414f02576bd6afabfb302140225) but and we will transfer funds from owner address to xyz address i.e (0xdd870fa1b7c4700f2bd7f44238821c26f7392148). So lets transfer 4 tokens

ip:

transferFrom(“0xca35b7d915458ef540ade6068dfe2f44e8fa733c”,”0xdd870fa1b7c4700f2bd7f44238821c26f7392148”,4)

op: true

** point to remember: we have allowed third party address 5000 tokens to transfer but here he only sent 4 token, so now if you check allowance then 5000–4 = 4996 tokens(he can tranfer to other address as well as his own address)

This is how a ERC20 works.

Now after having clear understanding about ERC20, we can move ahead to undersatand how the concept of locking is achived in smart contracts.

7) lock_erc(value,releasetime)

Only owner can use this functionality i.e in ower case if any other address invoke this function other than 0xca35b7d915458ef540ade6068dfe2f44e8fa733c then that will throw exception

to envoke this functionality you need to call lock_erc function with following ip:

a) total tokens you want to lock

b) total time in epoch you want to lock the contract till

you can convert date time to epoch time anytime using : https://www.epochconverter.com/

lets say i want to lock 5000 tokens till 1552315106(this is the date time of today)

then i will envoke function like:

ip: lock_erc(5000,1552315106)

op: index (1,2,3….)

now after response is some integer, 5000 tokens has been locked, and if you check the balance of owner it is reduced by 5000.

lets say we locked output of above lock_erc(5000,1552315106) is 1

i.e in 1 index 5000 tokens are locked till epoch time 1552315106

• *imp point: The index no that is returned by the function lock_erc is very crucial to release the token, while releasing the locked tokens you need to pass the index no where you initially locked the n no of tokens

8)release_erc(index_no)

to release erc all you need to remember is the index no that is returned when we invoked lock_erc() function, that mens you tokens are locked on particular indexes .

if the op of lock_erc(5000,1552315106) was 1

then our current ip would be:

release_erc(1)

op: true / false

if its true: if the release time satisfy the condition then automatically 5000 tokens would be allocated to owners address i.e 0xca35b7d915458ef540ade6068dfe2f44e8fa733c in our case.

and if you check the balance of owner now it will show incresed balance by 5000

thanks all!!

What is Litecore and what is it used for?

Litecore is a SAAS infrastructure that helps us to create Litecoin based application , allowing us to easily interact with Litecoin Blockchain. Litecore comes with a package allowing us to easily setup Litecoin full node and provides APIs to interact with it. Here is the list of the functionality provided by litecore:

1. Litecoin wallet service (client and server)
2. Litecoin explorer
3. Full node setup

Lets start with the setting up Litecore in Ubuntu 16.04

1) Installing Nodejs v>8.x

Installing/Upgrading

There are soo many ways to deal with it, I will be guiding for the simplest one

a) Create nodesource.list

sudo vim /etc/apt/sources.list.d/nodesource.list

b) Add following lines(you can replace 8.x with whichever version of Nodejs you want to install)

deb https://deb.nodesource.com/node_8.x xenial main
deb-src https://deb.nodesource.com/node_8.x xenial main

c) Download the GPG Signing Key from Nodesource for the repository

curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | sudo apt-key add -

d) sudo apt-get update

Just to verify if everything is going well you can check with the following command:

apt-cache policy nodejs >>>

Version table:
8.2.1-1nodesource1~xenial1 500
500 https://deb.nodesource.com/node_6.x xenial/main amd64 Packages
4.2.6~dfsg-1ubuntu4 500
500 http://archive.ubuntu.com/ubuntu xenial/universe amd64 Packages

e) sudo apt-get isntall nodejs

You will be having an updated version of NodeJs installed in your system

$ nodejs — version
v8.15.0https://github.com/litecoin-project/insight-lite-api

And your nodejs is ready to go !!!

2) litecore setup

a) install litecore library

sudo npm install -g litecore-node — unsafe-perm=true

After successful installation create a directory to store litcoin fullnode for now lets say its mynode_ltc

litecore-node create mynode_ltc
cd mynode_ltc

Now its time to start synching litcoin node, which can be done with command:

litecore-node start

If everything going ok then you will see similar logs:

After the node synchronizes completely, APIs are ready to use, to see list of APIs available reference Github link is attached below:

• litecore-node on NPM
• litecoin-project/litecore
• litecoin-project/insight-lite-api