ADA (Cardano)

ADA is the native cryptocurrency of the Cardano blockchain, which is a decentralized platform that aims to provide a more secure and scalable infrastructure for the development of smart contracts and decentralized applications (dApps). Cardano was founded by Charles Hoskinson, one of the co-founders of Ethereum, and it distinguishes itself from other blockchain platforms through its commitment to academic research and a scientific approach to development.

Here are some key aspects of ADA and the Cardano blockchain:

1. Proof-of-Stake (PoS) Consensus Mechanism: Cardano uses a consensus mechanism called Ouroboros, which is a proof of stake (PoS) protocol. Unlike proof of work (PoW) systems like Bitcoin, where miners compete to solve complex puzzles to validate transactions, PoS allows validators (or stakers) to create new blocks based on the amount of ADA they hold and are willing to “stake” as collateral.
2. Layered Architecture: Cardano’s blockchain is designed with a layered architecture, consisting of the Cardano Settlement Layer (CSL) for ADA transactions and the Cardano Computation Layer (CCL) for smart contracts. This separation allows for more flexibility and scalability in processing transactions and executing smart contracts.
3. Focus on Research and Peer Review: Cardano is known for its rigorous research-driven approach. The platform’s development is guided by peer-reviewed academic research and formal methods, which aim to ensure that the system is secure, reliable, and scalable.
4. Governance and Treasury System: Cardano has a built-in governance system that allows ADA holders to participate in decision-making processes, such as proposing and voting on changes to the protocol. Additionally, a portion of transaction fees goes into a treasury system, which funds the development and growth of the ecosystem.
5. Sustainability and Interoperability: Cardano emphasizes sustainability through its PoS mechanism, which is less energy-intensive than PoW systems. The platform also aims to support interoperability with other blockchains, allowing for a more connected and cohesive decentralized ecosystem.

Explain Like I’m Five Years Old (ELI5)

Imagine you have a special kind of playground where kids can play games, trade toys, and make up new rules. This playground is called Cardano, and ADA is the special kind of money that the kids use to do all these things.

1. Playground Rules: In this playground, instead of one kid being the boss, everyone gets a say. The more ADA you have, the more you can help decide what games to play or what new rules to add.
2. Safe and Secure: The playground has a really smart system that makes sure no one cheats. Instead of making kids run a race to decide things (like in other playgrounds), here, everyone just needs to promise some of their ADA money to get a turn. This is called staking, and it keeps things fair and safe.
3. Building Stuff: Cardano is also a place where you can build your own games or make up new ways to play. The smarter the game, the more fun everyone can have, and ADA helps power all of this.
4. Sharing Decisions: If the kids want to change something in the playground, they can all vote. The votes are like saying, “I want to play this new game,” and ADA is how they show they really mean it.
5. Always Getting Better: The playground isn’t finished yet. It keeps getting better because the kids who play there (and have ADA) help it grow by sharing ideas and making it more fun for everyone.

So, ADA is like the special coins you use to do cool things in the Cardano playground, where everyone gets to help make it the best place to play!

Example of an ADA Transaction

Here’s an example of how to make an ADA (Cardano) transaction using the Cardano serialization library in JavaScript:

// First, ensure you have the Cardano serialization library installed via npm:
// npm install @emurgo/cardano-serialization-lib-nodejs

const Cardano = require("@emurgo/cardano-serialization-lib-nodejs");

// Set up sender and receiver addresses
const senderAddress = "addr1q...";
const receiverAddress = "addr1q...";

// Example function to build and sign a transaction
async function createTransaction() {
  const txBuilder = Cardano.TransactionBuilder.new(
    Cardano.TransactionBuilderConfigBuilder.new()
      .fee_algo(Cardano.LinearFee.new(Cardano.BigNum.from_str("44"), Cardano.BigNum.from_str("155381")))
      .pool_deposit(Cardano.BigNum.from_str("500000000"))
      .key_deposit(Cardano.BigNum.from_str("2000000"))
      .max_value_size(5000)
      .max_tx_size(16384)
      .build()
  );

  // Example UTXO from the sender's wallet
  const utxo = Cardano.TransactionUnspentOutput.new(
    Cardano.TransactionInput.new(
      Cardano.TransactionHash.from_bytes(Buffer.from("exampleTransactionHash", "hex")),
      0 // Index of the UTXO in the transaction
    ),
    Cardano.TransactionOutput.new(
      Cardano.Address.from_bech32(senderAddress),
      Cardano.Value.new(Cardano.BigNum.from_str("10000000")) // ADA amount (10 ADA)
    )
  );

  // Add UTXO to the transaction
  txBuilder.add_input(Cardano.Address.from_bech32(senderAddress), utxo.input(), utxo.output().amount());

  // Add the receiver's output (amount to be sent)
  txBuilder.add_output(
    Cardano.TransactionOutput.new(
      Cardano.Address.from_bech32(receiverAddress),
      Cardano.Value.new(Cardano.BigNum.from_str("5000000")) // Sending 5 ADA
    )
  );

  // Calculate the minimum fee and set change output
  const minFee = txBuilder.min_fee();
  txBuilder.add_change_if_needed(Cardano.Address.from_bech32(senderAddress));

  // Build and sign the transaction
  const txBody = txBuilder.build();
  const txHash = Cardano.hash_transaction(txBody);
  const privateKey = Cardano.PrivateKey.from_normal_bytes(Buffer.from("examplePrivateKey", "hex"));

  const witnesses = Cardano.TransactionWitnessSet.new();
  const vkeyWitness = Cardano.make_vkey_witness(txHash, privateKey);
  witnesses.add_vkey(vkeyWitness);

  const signedTx = Cardano.Transaction.new(txBody, witnesses);

  // Convert the transaction to a hex string for submission to the blockchain
  const txHex = Buffer.from(signedTx.to_bytes()).toString("hex");

  console.log("Signed transaction hex:", txHex);

  // You can submit the transaction to the blockchain using a Cardano node or a third-party API.
}

// Run the function to create and sign the transaction
createTransaction();

Steps of the transaction:

1. Transaction Builder Setup: Set up a transaction builder with network parameters like fees.
2. UTxO: Add inputs from the sender’s wallet (unspent transaction outputs or UTxOs).
3. Output: Specify the receiver’s address and the amount of ADA to send.
4. Change: Calculate the minimum fee and set the change output.
5. Sign: Sign the transaction using the sender’s private key.
6. Submit: The hex-encoded signed transaction can be submitted to the Cardano blockchain.

This is just a simplified example; in a real-world application, you’d need to manage UTxOs, fee calculations, and private key storage securely.

Conclusion

ADA can be used for transactions, staking, and participating in the governance of the Cardano network. As the ecosystem continues to develop, ADA is expected to play a crucial role in facilitating a wide range of decentralized financial services and applications.