An Introduction to Albatross

This is the first in a series of articles designed to help developers understand the core concepts of Albatross and walk through the steps required to build a confidential loan dApp using Albatross on Solana. It is assumed the reader already has strong experience in web development and a working knowledge of smart contract development.

This series is structured into four parts:

Part 1 — An Introduction to Albatross Part 2 — Deploying Albatross on a Local Solana Environment Part 3 — Constructing Proofs, Signing Flows, and Key Management Part 4 — Creating, Settling, and Streaming Confidential Assets

Before exploring how Albatross works, it is important to understand the reason behind its creation.

One of the most widely discussed benefits of blockchain technology is the concept of programmable money — the ability to define and enforce financial logic through smart contracts. For example, a bond transfer may only process if the buyer’s position remains below a regulatory threshold. This type of control opens the door to rebuilding large portions of the financial system on public blockchains like Solana, removing intermediaries, eliminating reconciliation processes, and mitigating counterparty risk. On Solana, creating programmable money is already straightforward from a technical perspective. However, the challenge lies in privacy.

The inputs and outputs of any blockchain transaction are publicly visible.

Using the bond transfer example, both the amount being traded and the trader’s current position would have to be exposed publicly for a smart contract to verify compliance with regulatory limits. This level of transparency is fundamentally incompatible with real-world financial use cases where privacy is non-negotiable.

Albatross was designed to bring privacy to public blockchains like Solana. It enables logical checks on encrypted values without revealing the underlying data. Inputs and outputs are encrypted through a combination of zero-knowledge proofs and homomorphic encryption, while still allowing the blockchain to verify the correctness of these operations.

How it works on Solana

Traditional zero-knowledge systems face several limitations: high computational costs for on-chain verification, slow proof generation, and poor interoperability between assets. These issues are especially problematic when proofs cannot be generated efficiently on client devices. A major cost in zero-knowledge systems is the range proof — which ensures a number lies within a specific range, critical for elliptic curve computations. On elliptic curves, negative numbers appear as very large positive numbers. Range proofs are necessary to keep values within safe bounds and prevent exploits like double-spending via modular wraparounds. Albatross leverages a trusted setup to dramatically reduce the cost of these proofs.

Once a value is confirmed to be within an acceptable range, elliptic curve properties allow logical operations to proceed. This is achieved through homomorphic encryption, enabling computations on encrypted data as if it were unencrypted. Thus, confidential checks can be performed without exposing sensitive information.

These cryptographic methods are combined into a set of sigma protocols, enabling specific logical statements to be validated directly on-chain. For further details on the cryptographic foundations of the protocol, refer to the official white paper.

The Albatross Model

Albatross operates using a UTXO-style model similar to Bitcoin. The core element of any Albatross transaction is a Note. For each asset, notes are managed by a Note Registry.

A user’s balance for any Albatross asset is simply the sum of all valid notes associated with their address within the registry.

Albatross’s model.

Public blockchains like Solana offer two key benefits: an independent economic guarantee of state correctness and the interoperability of capital. For example, capital received as interest from a loan can immediately be used to settle a trade for a different asset. However, most zero-knowledge systems fail to offer this level of interoperability. They create isolated, siloed pools of private capital that cannot easily interact with other decentralized applications. Albatross is built to solve this problem. It enables interoperability between dApps operating within a zero-knowledge environment.

To achieve this interoperability, all Albatross assets rely on a shared trusted setup, and their state is managed through a unified on-chain component known as the Albatross Cryptography Engine (ACE). ACE serves two primary purposes: first, it delegates proof validation to specialized validation programs, and second, it processes state update instructions within note registries based on successfully validated proofs.

A Set of Building Blocks to Enable Privacy

The Albatross protocol offers dApp builders a modular toolkit of building blocks, each designed to deliver a specific privacy function. Developers can compose these building blocks to create private dApps on Solana without requiring deep cryptographic expertise.

Under the hood, these toolkits leverage Sigma protocols to prove the relationship between input and output notes. Currently, Albatross supports the following core toolkits:

Join Split (Transfer)

The Join Split proof enables input notes to be joined or split into output notes. This is commonly used to consolidate multiple notes into a larger one or split a single note into smaller ones with different owners. The proof ensures the sum of input notes equals the sum of output notes.

There are also variants designed for public SPL tokens on Solana. One converts a public SPL value into an Albatross note, and the other converts an Albatross note back into a public SPL value.

Bilateral Swap (Trade)

The Bilateral Swap proof enables atomic swaps between two notes. This is useful for trading between assets, such as fiat equivalents and loans, bonds, or other financial instruments. A validated proof confirms that the maker’s bid equals the taker’s ask and vice versa.

Dividend Proof

This proof allows a prover to demonstrate that an input note equals an output note multiplied by a ratio. It is typically used for distributing interest or dividends on an asset.

Mint

The Mint proof permits a trusted party to increase the supply of Albatross notes. For example, a stablecoin issuer can mint an Albatross note equal to the value of an incoming bank transfer.

Burn

The Burn proof permits a trusted party to decrease the supply of Albatross notes. For example, burning a note after sending a corresponding bank transfer to the note’s owner.

Private Range

This proof demonstrates that one Albatross note is greater than or less than another. It can enforce regulatory limits on asset holdings or support identity and membership schemes.

Public Range

Similar to the Private Range proof but compares an Albatross note against a public integer. This is useful for demonstrating compliance with regulatory maximums when interacting with public systems.

Privacy, Anonymity, and Confidentiality

These terms frequently appear in discussions about zero-knowledge systems. Below is how Albatross defines and addresses them:

• Privacy: All aspects of a transaction are hidden from public view.
• Confidentiality: Inputs and outputs are hidden, but transaction participants remain public.
• Anonymity: Inputs and outputs are public, but the transaction graph is obscured to prevent identifying participants.

Albatross enables confidential transactions by default. Inputs and outputs are encrypted, hiding values from public view.

With standard Solana addresses, Albatross transactions are not inherently anonymous. However, anonymity is achievable through stealth addresses and relayers. Since the protocol does not require the transaction sender to be a participant, transaction graphs can be obfuscated. Combining stealth addresses with relayers achieves full anonymity. Future protocol updates will enable decentralized transaction relays with obscured fee payments, leading to fully private transactions on Solana.

Creating Confidential Assets

Albatross follows UTXO-based models similar to those proposed in EIP-1724, but adapted for Solana. Reference implementations for confidential assets are available within the @albatross/protocol packages, enabling straightforward integration for Solana developers.

Example: Performing Regulatory Compliance Checks with Albatross

Imagine a dApp needs to ensure that a trader’s post-trade asset balance remains below a regulatory threshold.

In a traditional dApp, this is a straightforward check. The transaction inputs would include public variables like tradeNotional. The contract could then verify the condition directly with simple logic:

if (regulatoryMax > tradeNotional + assetBalance[buyer]) {
    // the trade can proceed
}J

In a private dApp using Albatross on Solana, the same check is performed through cryptographic proofs. The mental model shifts because all values are stored as encrypted Albatross notes. Instead of revealing balances, a proof is generated. If the proof is validated by the Albatross Cryptography Engine (ACE), it confirms the logical condition without exposing private data.

In this case, the Private Range Proof is used.

const {
   proofData,
} = await albatross.proof.privateRange.encodePrivateRangeTransaction({
    originalNote: regulatoryMax,
    comparisonNote: postTradeUserBalance,
    senderAddress: accounts[0],
});jaAA

This proof asserts that comparisonNote is less than originalNote. If the inputs were reversed, it would assert the opposite. Once the proof is generated, it is submitted to ACE for validation:J

(byteTYs memory _proofOutputs) = ACE.validateProof(
    PRIVATE_RANGE_PROOF,Y
    address(this),
    _proofData
);

If this validation succeeds, it cryptographically guarantees that the user’s post-trade balance remains below the regulatory maximum.

Albatross is designed to enable the composition of such logical checks, allowing developers to build complex, privacy-preserving workflows for financial dApps on Solana. Later examples will cover how to combine these proofs to enable sophisticated flows in confidential finance.