delta

delta is an integrity layer: any existing system can connect to the settlement layer via a gateway, define custom settlement rules, and thereby get automated verification workflows that are:

• programmable,
• gated on settlement,
• externally auditable.

In other words, delta lets any application, platform, or company get cryptographic guarantees similar to those of smart contracts, with the following unique benefits:

• No rewrite: business logic remains unchanged;
• Built for the real world: settlement guardrails can use real-world data and verification flows;
• Privacy-preserving: proprietary data and algorithms can be used, and transactions remain hidden. Only the changes to state are public.

Each user-initiated action goes through three layers, mirroring existing real-world flows:

1. Execution changes state: move funds, update a ledger, deliver an asset.
2. Verification checks authorization, compliance, correctness, and policy.
3. Settlement finalizes the state change resulting from the execution, assuming verification passed.

Building with delta

Define custom logic

Your domain's execution logic can be written in any programming language. Using the provided delta Gateway as a base, your application logic runs independently and communicates through an OpenAPI interface that exposes all required domain operations (debits, transaction submission, state queries, and proof handling).

This separation means you can build in your preferred language and framework while the Gateway handles the integration with delta's settlement layer.

// Your execution logic (any language) calls the Gateway
function executionLogic(userTxs, state) {
  for tx in userTxs {
    // add payout transaction to the txs base on state
    executionResult.push(...)
  }
  return executionResult
}

executionResult = executionLogic(userTxs, state)
IntentsService.intentsExecute(executionResult)

Define Custom Guardrails

Guardrails are cryptographic constraints that govern valid state transitions for your system. The constraints can enforce any property you require (financial invariants, game mechanics, or compliance policies).

Guardrails are currently written in Rust.

As an example, the below guardrail proves that a swap satisfied the user's slippage tolerance and maintained correct pool mathematics, without requiring validators to re-execute the AMM logic.

// Define constraint for a swap transaction
fn verify_swap(
    amount_in: u64,
    min_amount_out: u64,
    pool_state_before: PoolReserves,
    pool_state_after: PoolReserves,
) -> bool {
    // Calculate actual output from the swap
    let actual_output = calculate_output(
        amount_in,
        pool_state_before.reserve_x,
        pool_state_before.reserve_y
    );
    
    // Constraint 1: Slippage protection
    assert!(actual_output >= min_amount_out);
    
    // Constraint 2: Constant product formula (x * y = k)
    let k_before = pool_state_before.reserve_x * pool_state_before.reserve_y;
    let k_after = pool_state_after.reserve_x * pool_state_after.reserve_y;
    assert!(k_after >= k_before);
    
    true
}

Deploy on delta

Building with delta is that simple. Take any existing codebase, use the delta Gateway to connect to the delta settlement layer, build your application in whatever language is optimal, and optionally design guardrails to cryptographically enforce constraints.

Build with the Gateway
🛠️

Architecture + Purpose
🧠

Follow the Quickstart
🚀