The Stellar Development Foundation published its Quantum Preparedness Plan in early 2026, entering stage one of a multi-phase effort to introduce NIST-approved quantum-safe signature algorithms into the Stellar protocol. The initial focus is on the Soroban smart contract layer, where new cryptographic primitives will be available before they reach the classic transaction layer. If you build on Stellar, this is your signal to start auditing how your application handles key management, transaction signing, and signature verification.

Why Quantum Preparedness Matters Now

Quantum computers capable of breaking Ed25519 and ECDSA do not exist today. But the threat model is not about today. It is about two scenarios:

NIST finalized three post-quantum signature standards in 2024:

Compare this to Ed25519, which Stellar currently uses:

The size increase is significant. A Stellar transaction envelope that currently fits in a few hundred bytes could grow by an order of magnitude. This has implications for network throughput, storage costs, and state archival.

What Changes for Stellar Developers

Stage One: Soroban Cryptographic Primitives

The first stage introduces post-quantum signature verification as Soroban host functions. This means smart contracts can verify quantum-safe signatures, but the network's consensus layer still uses Ed25519.

// Future Soroban host function (illustrative)
// Verify an ML-DSA signature inside a contract
const result = contract.call('verify_pq_signature', {
  algorithm: 'ML-DSA-65',
  message: messageBytes,
  signature: signatureBytes,
  publicKey: pqPublicKeyBytes,
});

This allows developers to build hybrid schemes: the transaction itself is signed with Ed25519 (as required by the network), but the contract payload includes an additional quantum-safe signature for sensitive operations.

Stage Two: Hybrid Transaction Signatures

In a later stage, the transaction envelope format will support hybrid signatures, where both a classical and a post-quantum signature are attached to each transaction. Validators verify both during consensus.

Stage Three: Full Migration

Eventually, the network may allow pure post-quantum signatures. This is the furthest out and depends on ecosystem readiness.

How to Monitor Signature Schemes via API

You can already start monitoring the cryptographic health of accounts and transactions on the Stellar network using the Horizon API through LumenQuery.

Check Account Signer Types

const HORIZON = 'https://horizon.stellar.org';

async function getAccountSigners(accountId) {
  const res = await fetch(`${HORIZON}/accounts/${accountId}`);
  const account = await res.json();

  return account.signers.map(signer => ({
    key: signer.key,
    type: signer.type,       // 'ed25519_public_key' currently
    weight: signer.weight,
  }));
}

// Audit: flag accounts that lack multi-sig
async function auditSignerSecurity(accountId) {
  const signers = await getAccountSigners(accountId);

  return {
    accountId,
    signerCount: signers.length,
    totalWeight: signers.reduce((sum, s) => sum + s.weight, 0),
    usesMultiSig: signers.length > 1,
    signerTypes: [...new Set(signers.map(s => s.type))],
    hasQuantumSafeSigner: signers.some(s =>
      s.type === 'ml_dsa_public_key' || s.type === 'slh_dsa_public_key'
    ),
  };
}

Monitor Transaction Signature Sizes

Track signature sizes over time to detect when quantum-safe signatures begin appearing on the network:

async function analyzeTransactionSignatures(limit = 50) {
  const res = await fetch(
    `${HORIZON}/transactions?limit=${limit}&order=desc`
  );
  const data = await res.json();

  return data._embedded.records.map(tx => {
    const envelope = Buffer.from(tx.envelope_xdr, 'base64');
    return {
      hash: tx.hash,
      ledger: tx.ledger,
      signatureCount: tx.signatures?.length || 0,
      envelopeSize: envelope.length,
      possiblePQSignature: envelope.length > 1000,
    };
  });
}

Use LumenQuery Analytics to Track Network-Wide Trends

// Monitor average transaction envelope sizes over time
const res = await fetch('https://lumenquery.io/api/analytics/network');
const metrics = await res.json();

console.log('Average tx size:', metrics.avgTransactionSize);
console.log('Current protocol:', metrics.protocolVersion);

Practical Audit Checklist

Use this checklist to assess your application's quantum readiness:

Key Management

Transaction Signing

// Example: find hardcoded Ed25519 assumptions in your code
const AUDIT_PATTERNS = [
  /signature\.length\s*===?\s*64/,     // Hardcoded sig size
  /publicKey\.length\s*===?\s*32/,      // Hardcoded key size
  /ed25519/i,                           // Direct algorithm references
  /SIGNATURE_LENGTH\s*=\s*64/,         // Constants
];

Smart Contract Design

Cost Impact Estimation

Post-quantum signatures will affect transaction costs due to larger envelope sizes:

// Future-proof fee estimation
async function estimateTransactionFee(tx, usePQSignature = false) {
  const baseFee = 100; // stroops
  const currentEnvelopeSize = tx.toEnvelope().toXDR().length;

  if (usePQSignature) {
    const pqOverhead = 3309 * tx.signatures.length;
    const adjustedSize = currentEnvelopeSize + pqOverhead;
    return Math.ceil(baseFee * (adjustedSize / currentEnvelopeSize));
  }

  return baseFee;
}

Timeline and Recommendations

What to Do Today

How LumenQuery Helps

LumenQuery provides the infrastructure to monitor the quantum transition:

*Prepare your Stellar application for the quantum transition. LumenQuery provides managed Horizon API and Soroban RPC with analytics to track the migration. Start free.*