Create Your Own Cryptocurrency with JavaScript

8 min read

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

In case you have found a mistake in the text, please send a message to the author by selecting the mistake and pressing Ctrl-Enter.
Comments (0)

    No comments yet

You must be logged in to comment.

Sign In / Sign Up