Hydra SDKHydra SDKDocumentation
Concepts

Why Hydra?

Understanding the benefits and use cases of Hydra Layer 2 scaling solution

Hydra is Cardano's Layer 2 scaling solution that addresses the blockchain trilemma by providing high throughput, low latency, and minimal transaction costs while maintaining security and decentralization.

The Scalability Challenge

Blockchain networks face fundamental scalability limitations:

  • Limited Throughput - Layer 1 blockchains process transactions slowly (Cardano mainnet: ~250 TPS theoretical)
  • High Latency - Block confirmation times create delays (20+ seconds on Cardano)
  • Increasing Fees - Network congestion drives up transaction costs
  • Resource Constraints - Every node must process every transaction

These limitations make certain applications impractical on Layer 1:

  • Real-time gaming
  • Micropayments
  • High-frequency trading
  • Interactive DApps

How Hydra Solves This

Isomorphic State Channels

Hydra creates isomorphic state channels - off-chain environments that mirror Layer 1 capabilities:

graph TD
  A["Cardano Layer 1<br/>(Settlement Layer - Security)"]
  B["Hydra Head (Layer 2)<br/>• High throughput <br/>(1000+ TPS)<br/>• Low latency <br/>(<1 second)<br/>• Minimal fees<br/>• Full smart contract support"]
  A -- Open/Close Head --> B

Key Benefits

1. Massive Throughput Increase

  • Layer 1: ~250 TPS theoretical, ~50-100 TPS practical
  • Hydra Head: 1,000+ TPS per head
  • Multiple Heads: Linear scaling with number of heads
// Example: Processing multiple transactions rapidly
for (let i = 0; i < 1000; i++) {
  await bridge.submitTx(tx)
  // Each transaction confirms in <1 second
}

2. Near-Instant Finality

Transactions confirm in under 1 second within a Hydra Head:

MetricLayer 1Hydra Head
Confirmation Time20+ seconds<1 second
Block Time20 seconds~100ms
Finality2-3 minutesInstant

3. Minimal Transaction Costs

  • Layer 1: ~0.17 ADA average fee
  • Hydra Head: Negligible fees (only consensus overhead)
  • Cost Savings: 99%+ reduction for high-frequency operations
// Cost comparison
const layer1Cost = 1000 * 0.17 // 170 ADA for 1000 txs
const hydraCost = 2 * 0.17 + 0.001 * 1000 // ~1.4 ADA total
// Savings: ~99.2%

4. Full Smart Contract Support

Hydra Heads support the same Plutus smart contracts as Layer 1:

  • ✅ Native tokens and NFTs
  • ✅ Custom validators
  • ✅ Complex DeFi protocols
  • ✅ State machines
  • ✅ Multi-signature logic

5. Predictable Performance

Unlike Layer 1, Hydra Head performance is unaffected by:

  • Network congestion
  • Block size limits
  • Mempool competition
  • Other users' activities

Use Cases

1. Gaming & Metaverse

Requirements: Real-time interactions, frequent state updates, low costs

// In-game item transfer inside a Hydra Head — instant and feeless
const transferItem = async (fromAddr, toAddr, itemNFT, utxos) => {
  const tx = await new TxBuilder({ isHydra: true })
    .setInputs(utxos)
    .txOut(toAddr, [{ unit: `${itemNFT.policy}.${itemNFT.name}`, quantity: '1' }])
    .changeAddress(fromAddr)
    .setFee('0') // no fee inside a Head
    .complete()

  const signed = await wallet.signTx(tx.to_hex())
  await bridge.submitTxSync({ type: 'Witnessed Tx ConwayEra', description: '', cborHex: signed })
  // Confirmed in <1 second
}

Examples:

  • Player-to-player trading
  • Real-time leaderboards
  • In-game currency transactions
  • Tournament prize distribution

2. Micropayments & Streaming

Requirements: Tiny transaction amounts, high frequency, minimal fees

// Per-second streaming payment inside a Hydra Head
const streamingPayment = (creatorAddr, senderAddr, utxos) => {
  setInterval(async () => {
    const tx = await new TxBuilder({ isHydra: true })
      .setInputs(utxos)
      .txOut(creatorAddr, [{ unit: 'lovelace', quantity: '1000' }]) // 0.001 ADA
      .changeAddress(senderAddr)
      .setFee('0')
      .complete()

    const signed = await wallet.signTx(tx.to_hex())
    await bridge.submitTxSync({ type: 'Witnessed Tx ConwayEra', description: '', cborHex: signed })
  }, 1000) // pay every second
}

Examples:

  • Pay-per-second content streaming
  • Micropayment tips
  • Usage-based API payments
  • IoT device settlements

3. DeFi Trading

Requirements: Fast execution, low latency, MEV resistance

// High-frequency DEX trade: spend the pool script UTxO, swap params in the redeemer
const executeTrade = async (poolUtxo, swapRedeemer, dexScript, out, utxos) => {
  const tx = await new TxBuilder({ isHydra: true })
    .setInputs(utxos)
    .txIn(poolUtxo.txHash, poolUtxo.outputIndex)
    .txInScript(dexScript)
    .txInRedeemerValue(swapRedeemer)
    .txOut(out.address, out.amount)
    .changeAddress(out.address)
    .setFee('0')
    .complete()

  const signed = await wallet.signTx(tx.to_hex())
  await bridge.submitTxSync({ type: 'Witnessed Tx ConwayEra', description: '', cborHex: signed })
  // Trade executes in <1 second
}

Examples:

  • DEX order books
  • Automated market makers
  • Arbitrage opportunities
  • Liquidation mechanisms

4. NFT Marketplaces

Requirements: Fast auctions, batch operations, low listing costs

// Real-time NFT auction: lock the bid at the auction script with a bid datum
const placeBid = async (auctionScriptAddr, bidLovelace, bidDatum, bidderAddr, utxos) => {
  const tx = await new TxBuilder({ isHydra: true })
    .setInputs(utxos)
    .txOut(auctionScriptAddr, [{ unit: 'lovelace', quantity: bidLovelace }])
    .txOutInlineDatumValue(bidDatum) // records bidder + amount
    .changeAddress(bidderAddr)
    .setFee('0')
    .complete()

  const signed = await wallet.signTx(tx.to_hex())
  await bridge.submitTxSync({ type: 'Witnessed Tx ConwayEra', description: '', cborHex: signed })
  // Bid placed instantly
}

Examples:

  • Live NFT auctions
  • Batch minting collections
  • Rapid trading
  • Royalty distributions

5. Social & Governance

Requirements: High user interaction, voting, content moderation

// Real-time governance voting, recorded as transaction metadata
const vote = async (proposalId, choice, voterAddr, utxos) => {
  const tx = await new TxBuilder({ isHydra: true })
    .setInputs(utxos)
    .txOut(voterAddr, [{ unit: 'lovelace', quantity: '1000000' }])
    .metadataValue(1, { proposal: proposalId, vote: choice })
    .changeAddress(voterAddr)
    .setFee('0')
    .complete()

  const signed = await wallet.signTx(tx.to_hex())
  await bridge.submitTxSync({ type: 'Witnessed Tx ConwayEra', description: '', cborHex: signed })
  // Vote recorded instantly
}

Examples:

  • DAO voting
  • Social media interactions
  • Content tipping
  • Reputation systems

Comparing Hydra with Other Solutions

Hydra vs Traditional Layer 1

FeatureCardano L1Hydra Head
Throughput~100 TPS1,000+ TPS
Latency20+ seconds<1 second
Fees~0.17 ADA~0.001 ADA
Smart ContractsFull PlutusFull Plutus
SecurityLayer 1Participant consensus
Finality2-3 minutesInstant

Hydra vs Other L2 Solutions

Hydra Advantages:

  • ✅ Full smart contract support (isomorphic)
  • ✅ No separate virtual machine
  • ✅ Native multi-asset support
  • ✅ Instant finality within head
  • ✅ Predictable performance

Trade-offs:

  • ⚠️ Requires participant cooperation
  • ⚠️ Limited to participants in head
  • ⚠️ Opening/closing has Layer 1 costs

When to Use Hydra

✅ Ideal Use Cases

  • High Transaction Volume: Many transactions between known parties
  • Low Latency Requirements: Real-time or near-real-time interactions
  • Cost Sensitivity: Fees are a significant factor
  • Known Participants: Trusted or semi-trusted parties
  • Session-Based: Temporary, bounded interactions

❌ Not Ideal For

  • One-Time Transactions: Single, isolated transactions
  • Unknown Parties: No relationship or trust
  • Long-Term Storage: Permanent state without interaction
  • Public Access: Unrestricted open participation

Getting Started

Ready to integrate Hydra into your application?

  1. Set up Hydra SDK - Install required packages
  2. Follow Integration Guide - Step-by-step integration
  3. Explore Commit/Decommit - Manage UTxOs in heads
  4. Build Transactions - Create Hydra transactions

Learn More

Next: Learn how to Commit UTxOs to Hydra to start using Hydra Heads

Integrate from Cardano-CLI

Learn how to use Cardano-CLI generated keys with Hydra SDK using CardanoCliWallet.

Commit to Hydra

Learn how to commit UTxOs into a Hydra Head to enable Layer 2 transactions