Cryptocurrency is a decentralized form of digital currency that operates independently of a central bank or government. A cryptocurrency development company relies on blockchain technology, a distributed ledger that records all transactions across multiple computers or nodes.
Cryptocurrency Development with JavaScript
We will simulate a blockchain using JavaScript code, where users can possess wallets containing public and private keys.Users can initiate transactions within this simulation, which are then incorporated into blocks, eventually establishing a complete blockchain structure.
For the implementation, we will have 4 classes — Transaction, Block, Wallet, and Chain.
Transaction Class
This class simulates the transaction on a blockchain
Constructor:
- The constructor method is called when a new instance of the Transaction class is created.
- It takes three parameters: amount, senderAddress, and receiverAddress.
- These fields represent the transaction amount as well as the sender and receiver addresses.
- Inside the constructor, the values are assigned to the corresponding properties of the transaction object.
toString() method:
- This method converts the transaction object to a string representation.
- It returns a JSON string representation of the transaction object using JSON.stringify(this).
- The ‘this’ keyword refers to the current transaction object.
Suggested Post | MPC Wallet Development | Enhancing Crypto Asset Security
Block Class
This class simulates the blocks on the blockchain.
Constructor:
- The constructor method is called when a new instance of the Block class is created.
- It takes three parameters: previousHash, transaction, and timestamp.
- previousHash represents the hash of the previous block in the chain.
- transaction is the transaction associated with the current block.
- timestamp is an optional parameter representing the timestamp of when the block was created. If not provided, the current timestamp (obtained using Date.now()) is used.
- Inside the constructor, the values are assigned to the corresponding properties of the block object.
getHash() method:
- This method calculates and returns the hash of the block.
- It converts the block object to a JSON string representation using JSON.stringify(this).
- The hash of the JSON string is then computed using the crypto module's SHA-256 technique.
- The resulting hash is returned as a hexadecimal string.
toString() method:
- This method converts the block object to a string representation.
- It returns a JSON string representation of the block object using JSON.stringify(this).
- The ‘this’ keyword refers to the current block object.
Also, Visit | AI Crypto Trading Bots | Reshaping Crypto Trading
Wallet Class
This class simulates the wallet on the blockchain.
Constructor:
- The constructor method is called when a new instance of the Wallet class is created.
- Inside the constructor, a key pair is generated using the crypto.generateKeyPairSync() function from the crypto module.
- The generateKeyPairSync() function generates a public-private key pair using the RSA encryption algorithm.
- The key pair is then stored in the privateKey and publicKey properties of the wallet object.
send(amount, receiverAddress) method:
- This method facilitates a transaction by creating a new Transaction object, signing it with the sender’s private key, and inserting a new block into the blockchain.
- It takes two parameters: amount (the amount to be sent in the transaction) and receiverAddress (the address of the recipient).
- Inside the method, a new Transaction object is created using the provided amount, the wallet’s publicKey as the sender’s address, and the receiverAddress as the recipient’s address.
- The crypto.createSign() function is used to create a sign object with the SHA-256 hashing algorithm.
- The update() method of the sign object is called with the transaction converted to a string using transaction.toString().
- The sign() method is then called on the sign object, passing the wallet’s privateKey to sign the transaction.
- The resulting signature is passed along with the transaction and the wallet’s publicKey to the insertBlock() method of the Chain class, adding a new block to the blockchain.​​​​​​​
Chain Class
This class simulates the blockchain itself.
Constructor:
- The constructor method is called when a new instance of the Chain class is created.
- Inside the constructor, the initial state of the blockchain is set by creating a genesis block.
- The genesis block is created using an empty string as the previous hash and a default transaction with zero amount and arbitrary sender and receiver addresses.
- The genesis block is then stored as the first block in the chain array.
getPreviousBlockHash() method:
- This method returns the hash of the previous block in the chain.
- It retrieves the last block in the chain array using this.chain[this.chain.length — 1].
- The getHash() method of the block object is called to obtain its hash.
insertBlock(transaction, senderAddress, sig) method:
- This method inserts a new block into the blockchain after verifying the integrity and authenticity of the provided transaction.
- It takes three parameters: transaction (the transaction to be included in the block), senderAddress (the address of the transaction sender), and sig (the signature of the transaction signed by the sender).
- Inside the method, a crypto.createVerify() object is created with the SHA-256 hashing algorithm to perform the verification.
- The update() method of the verify object is called with the string representation of the transaction obtained using transaction.toString().
- The verify() method is then called on the verify object, passing the senderAddress and the sig to verify the signature.
- If the signature is valid, a new block is created using the getPreviousBlockHash() method to retrieve the previous block’s hash.
- The new block is added to the chain array using this.chain.push(block).
getBalance(address) method:
- This method calculates and returns the balance of a user based on their address.
- It takes one parameter: address (the address of the user).
- Inside the method, a variable named balance is initialized to zero.
- The method iterates over each block in the chain array using forEach().
- For each block, it checks if the senderAddress of the block’s transaction matches the given address. If true, it subtracts the transaction amount from the balance.
- It also checks if the receiverAddress of the block’s transaction matches the given address. If true, it adds the transaction amount to the balance.
- Finally, the calculated balance is returned.
Check It Out | Hiring Smart Contract Developers Made Easy
const crypto = require(‘crypto’);
// Transaction class to demostrate transactions on blockchain
class Transaction {
// A transaction will have amount, sender address, reciever address
constructor(amount, senderAddress, recieverAddress) {
this.amount = amount;
this.senderAddress = senderAddress;
this.recieverAddress = recieverAddress;
}
// Convert the transaction details to string
toString() {
return JSON.stringify(this);
}
}
// Block class to demonstrate blocks in blockchain
class Block {
// A block consists of hash of previous block, transactions and time
constructor(previousHash, transaction, timestamp = Date.now()) {
this.previousHash = previousHash;
this.transaction = transaction;
this.timestamp = timestamp;
}
// Function to get the hash of the block
getHash() {
const json = JSON.stringify(this);
const hash = crypto.createHash(‘SHA256’);
hash.update(json).end();
const hex = hash.digest(‘hex’);
return hex;
}
// Convert the block details to string
toString() {
return JSON.stringify(this);
}
}
class Wallet {
constructor() {
// Create public and private keys at the time of instantiation
const keys = crypto.generateKeyPairSync(‘rsa’, {
modulusLength: 2048,
publicKeyEncoding: { type: ‘spki’, format: ‘pem’ },
privateKeyEncoding: { type: ‘pkcs8’, format: ‘pem’ },
});
this.privateKey = keys.privateKey;
this.publicKey = keys.publicKey;
}
// Function to send the transaction
send(amount, recieverAddress) {
const transaction = new Transaction(
amount,
this.publicKey,
recieverAddress
);
const shaSign = crypto.createSign(‘SHA256’);
// add the transaction json
shaSign.update(transaction.toString()).end();
// sign the SHA with the private key
const signature = shaSign.sign(this.privateKey);
Chain.instance.insertBlock(transaction, this.publicKey, signature);
}
}
// Chain class to demonstrate the blockchain itself
class Chain {
// Only instance of the chain class
static instance = new Chain();
// initializing our chain with no records
constructor() {
this.chain = [new Block(‘’, new Transaction(0, ‘abc’, ‘xyz’))];
}
// Returns the hash of the previous block
getPreviousBlockHash() {
// sending the entire block itself
return this.chain[this.chain.length — 1].getHash();
}
// Add new block in the chain
insertBlock(transaction, senderAddress, sig) {
// create verifier
const verify = crypto.createVerify(‘SHA256’);
// add the transaction JSON
verify.update(transaction.toString());
// Verify it with the sender’s public key
const isValid = verify.verify(senderAddress, sig);
if (isValid) {
const block = new Block(this.getPreviousBlockHash(), transaction);
console.log(‘Block added: ‘, block.toString());
this.chain.push(block);
}
}
// Function to get the balance of a user
getBalance(address) {
let balance = 0;
this.chain.forEach((block) => {
if (block.transaction.senderAddress === address) {
balance -= block.transaction.amount;
}
if (block.transaction.recieverAddress === address) {
balance += block.transaction.amount;
}
});
return balance;
}
}
const satoshi = new Wallet();
const vitalik = new Wallet();
const sid = new Wallet();
satoshi.send(50, vitalik.publicKey);
vitalik.send(23, sid.publicKey);
sid.send(5, vitalik.publicKey);
const vitalikBal = Chain.instance.getBalance(vitalik.publicKey);
const sidBal = Chain.instance.getBalance(sid.publicKey);
console.log(Chain.instance);
console.log(‘Vitalik has: ‘, vitalikBal);
console.log(‘Sid has: ‘, sidBal);
- Hire blockchain developer for Developing secure, decentralized cryptocurrencies using JavaScript for blockchain-based transactions and smart contracts.
#cryptocurrencydevelopmentservices
#cryptocurrencyappdevelopment
#cryptocurrencyappdevelopmentcompany
#cryptocurrencydevelopment
#cryptocurrencydevelopmentcompany
No comments yet