Complete Documentation: Blockchain and Cryptocurrency Terms with Examples in JavaScript
This documentation provides a comprehensive glossary of commonly used blockchain and cryptocurrency terms, complete with definitions, examples, and JavaScript code.
1.Blockchain
Definition:
A decentralized, distributed ledger that records transactions across a network of computers.
Example:
Bitcoin's blockchain records all BTC transactions in blocks, chained together chronologically.
Code Example:
class Block {
constructor(index, previousHash, data, timestamp) {
this.index = index;
this.previousHash = previousHash;
this.data = data;
this.timestamp = timestamp;
this.hash = this.calculateHash();
}
calculateHash() {
const crypto = require('crypto');
return crypto.createHash('sha256')
.update(this.index + this.previousHash + this.data + this.timestamp)
.digest('hex');
}
}
const blockchain = [new Block(0, "0", "Genesis Block", 1637836800)];
console.log(blockchain);
2. Vesting
Definition:
A process where crypto tokens are distributed to stakeholders over a defined schedule.
Example:
A team member might receive 25% of their tokens after one year and the remaining 75% over the next three years.
Code Example:
function calculateVestedTokens(totalTokens, vestingPeriodYears, yearElapsed) {
return (totalTokens / vestingPeriodYears) * yearElapsed;
}
const totalTokens = 1000;
const vestingPeriodYears = 4;
const yearElapsed = 2;
console.log(calculateVestedTokens(totalTokens, vestingPeriodYears, yearElapsed)); // Output: 500
3. Halving
Definition:
An event where the reward for mining a block is halved, reducing the rate at which new coins are created.
Example:
Bitcoin’s halving occurs roughly every 4 years. In 2020, the mining reward was reduced from 12.5 BTC to 6.25 BTC.
Code Example:
function calculateReward(initialReward, halvings) {
return initialReward / Math.pow(2, halvings);
}
console.log(calculateReward(50, 3)); // Output: 6.25
4. Proof of Work (PoW)
Definition:
A consensus mechanism requiring miners to solve computational puzzles to validate transactions.
Example:
Bitcoin uses PoW to secure its blockchain.
Code Example:
const crypto = require('crypto');
function proofOfWork(blockData, difficulty) {
const prefix = '0'.repeat(difficulty);
let nonce = 0;
while (true) {
const hash = crypto.createHash('sha256')
.update(blockData + nonce)
.digest('hex');
if (hash.startsWith(prefix)) {
return { nonce, hash };
}
nonce++;
}
}
console.log(proofOfWork("block_data", 4));
5. Proof of Stake (PoS)
Definition:
A consensus mechanism where validators are chosen based on their stake in the network.
Example:
Ethereum transitioned to PoS in 2022, reducing energy usage significantly.
Code Example:
function selectValidator(stakes) {
const totalStake = Object.values(stakes).reduce((sum, stake) => sum + stake, 0);
const rand = Math.random() * totalStake;
let cumulative = 0;
for (const [validator, stake] of Object.entries(stakes)) {
cumulative += stake;
if (rand <= cumulative) {
return validator;
}
}
}
const stakes = { Validator1: 100, Validator2: 200, Validator3: 300 };
console.log(selectValidator(stakes));
6. Staking
Definition:
Locking up cryptocurrency in a wallet to support the network and earn rewards.
Example:
Users stake ETH to become validators in Ethereum's PoS system.
Code Example:
function calculateStakingRewards(stakeAmount, annualYield, durationYears) {
return stakeAmount * Math.pow(1 + annualYield, durationYears) - stakeAmount;
}
console.log(calculateStakingRewards(1000, 0.1, 3)); // Output: 331.00
7. Mining
Definition:
The process of validating blockchain transactions and earning rewards in return.
Example:
Bitcoin miners use hardware like ASICs to solve mathematical puzzles.
Code Example:
const crypto = require('crypto');
function mineBlock(data, previousHash) {
const block = {
data: data,
previousHash: previousHash,
hash: crypto.createHash('sha256')
.update(data + previousHash)
.digest('hex')
};
return block;
}
const minedBlock = mineBlock("transaction_data", "0000abc123");
console.log(minedBlock);
8. Gas Fees
Definition:
Transaction fees paid to miners or validators for processing transactions.
Example:
On Ethereum, users pay gas fees in ETH to execute smart contracts.
Code Example:
function calculateGasFee(gasPrice, gasUsed) {
return gasPrice * gasUsed;
}
console.log(calculateGasFee(50, 21000)); // Output: 105000 Gwei
9. Decentralized Exchange (DEX)
Definition:
A peer-to-peer platform for trading cryptocurrencies directly between users, without an intermediary. Trades are executed using smart contracts.
Example:
Uniswap is a popular DEX for decentralized token swapping.
Code Example:
class DecentralizedExchange {
constructor(reserveA, reserveB) {
this.reserveA = reserveA;
this.reserveB = reserveB;
}
getPrice(inputAmount, inputReserve, outputReserve) {
return (inputAmount * outputReserve) / (inputReserve + inputAmount);
}
swap(inputToken, inputAmount) {
let outputAmount;
if (inputToken === "A") {
outputAmount = this.getPrice(inputAmount, this.reserveA, this.reserveB);
this.reserveA += inputAmount;
this.reserveB -= outputAmount;
} else if (inputToken === "B") {
outputAmount = this.getPrice(inputAmount, this.reserveB, this.reserveA);
this.reserveB += inputAmount;
this.reserveA -= outputAmount;
} else {
throw new Error("Invalid token type");
}
return outputAmount;
}
}
const dex = new DecentralizedExchange(1000, 2000);
console.log("Swap 10 Token A for Token B:", dex.swap("A", 10));
console.log("Swap 20 Token B for Token A:", dex.swap("B", 20));
10. Centralized Exchange (CEX)
Definition:
A cryptocurrency trading platform operated by a central authority or company.
Example:
Binance, Coinbase, and Kraken are examples of centralized exchanges.
Code Example:
class CentralizedExchange {
constructor() {
this.orderBook = { buy: [], sell: [] };
}
placeOrder(type, amount, price) {
const order = { amount, price };
this.orderBook[type].push(order);
this.matchOrders();
}
matchOrders() {
this.orderBook.buy.sort((a, b) => b.price - a.price);
this.orderBook.sell.sort((a, b) => a.price - b.price);
while (
this.orderBook.buy.length > 0 &&
this.orderBook.sell.length > 0 &&
this.orderBook.buy[0].price >= this.orderBook.sell[0].price
) {
const buyOrder = this.orderBook.buy.shift();
const sellOrder = this.orderBook.sell.shift();
const tradedAmount = Math.min(buyOrder.amount, sellOrder.amount);
const tradePrice = sellOrder.price;
console.log(`Trade executed: ${tradedAmount} units at price ${tradePrice}`);
if (buyOrder.amount > tradedAmount) {
buyOrder.amount -= tradedAmount;
this.orderBook.buy.unshift(buyOrder);
}
if (sellOrder.amount > tradedAmount) {
sellOrder.amount -= tradedAmount;
this.orderBook.sell.unshift(sellOrder);
}
}
}
}
const exchange = new CentralizedExchange();
exchange.placeOrder("buy", 10, 50000);
exchange.placeOrder("sell", 10, 49000);
This documentation includes:
- Definitions of blockchain and cryptocurrency terms.
- Examples demonstrating real-world usage.
- JavaScript Code Snippets implementing concepts for developers.
This serves as a complete reference guide for blockchain developers and enthusiasts.
Top comments (0)