# Introduction

Intent-based Execution Network

Ditto Network is a decentralized, chain-agnostic automation and intent-execution protocol. It turns complex multichain actions into simple, trustless workflows that apps and wallets can utilize across EVM blockchains.

Ditto supports both instant and conditional execution in one place—single-token gas payments, enabling a wide range of automations billed from unified balance. Ditto enable app developers to create cross-chain limit orders, DCA/TWAP, liquidation protection, portfolio rebalancing, autocompounding, protocol operations, and AI-agent tasks.&#x20;

The protocol empowers builders to create and execute complex workflows under predefined conditions, unlocking new possibilities for decentralized automation.<br>


# Why Ditto?

Decentralized Execution, Maximum Security, Cross-chain Capabilities

Ditto is a secure, decentralized execution engine for multichain automation — designed to run complex, intent-based workflows in a verifiable, consensus-driven environment.

| Feature                  | Description                                                                                                                          |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
| Maximum Security         | Restaking (Symbiotic/EigenLayer) backs execution with real economic guarantees.                                                      |
| Smart Execution          | Intent-based “Execution Engine” supports instant & conditional flows abstracting gas management to the established ERC4337 standard. |
| True Decentralization    | Permissionless, stake-secured validator set with rotating leaders and quorum attestations.                                           |
| Cross-Chain Capabilities | Chain-agnostic by design: EVM-first, enabling reliable read/write automation.                                                        |

> The Ditto Network provides a public compute engine operated by decentralized nodes that monitor, simulate, and execute conditional logic. It enables seamless developer integration through ERC-7579 modules and the [Ditto SDK](https://github.com/dittonetwork/ditto-workflow-sdk).


# Protocol Overview

Here we cover the general flow: Dev/SDK → Blockchains → Runner Nodes ↔ IPFS → Performer → Consensus → AA

<figure><img src="https://258555021-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0oqis4JDhDSIVRhBEmPf%2Fuploads%2FaKxuKFrTQQVoSDabwDH1%2Fimage.png?alt=media&amp;token=bfd10aea-e817-43f9-b1f0-f8d0bc7fb059" alt=""><figcaption></figcaption></figure>

Developers utilise Ditto **TypeScript SDK** to define **deferred, multi-chain workflows, create** [**ZeroDev Smart Sessions**](https://zerodev.app/) and register them on-chain. **Ditto Runner Nodes** watch multiple chains for registration events, pull **workflow metadata from IPFS**, keep a live schedule of active workflows, and **process/simulate** them at the right time. Each runner **reports to the Performer**, which aggregates results. Runner attestations are used to reach **consensus on settlement**. Final, agreed outcomes are executed through the **Account Abstraction (AA) layer** (ERC-7579 modules), producing on-chain settlements and receipts back to the dApp. You can learn more about our SDK [here](https://github.com/dittonetwork/ditto-workflow-sdk).


# Ditto Consensus

A comprehensive walkthrough of how Ditto leverages the Othentic AVS consensus engine to authorize and settle ERC-4337 UserOperations via the DittoValidatorModule.

## **1. Overview**

Ditto relies on Othentic’s consensus to securely validate operations before execution.

<figure><img src="https://258555021-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0oqis4JDhDSIVRhBEmPf%2Fuploads%2FB2sw92c5LpYyhq5LGu4t%2Fimage.png?alt=media&amp;token=c70de4b3-f588-4a9f-bc61-7cd14ebd6e09" alt=""><figcaption></figcaption></figure>

Workflow:

1. **Simulation** Simulators monitor active workflows and execute scheduled tasks. Each workflow points to a registry contract that references the corresponding TypeScript code. The code runs in a restricted environment:
   * Whitelisted packages only
   * RPC calls to supported networks
   * Strict execution time limits If the code returns calldata, the Performer proposes a task result (in Ditto: approval of a UserOperation) and produces a proofOfTask.
2. **Attestation** Attesters independently validate the result against local policy. They BLS-sign an approval or rejection, weighted by their restaked voting power.
3. **Aggregation** An Aggregator collects signatures, monitors quorum thresholds, and aggregates them into a single BLS signature.
4. **On-chain Verification** The AttestationCenter contract verifies the aggregated signature on-chain using OBLS (Optimized BLS verification).
5. **Authorization** Ditto consumes this consensus output inside the DittoValidatorModule, authorizing the UserOperation if consensus confirms validity.

Consensus thresholds:

* Approval → >66% of total voting power signs approval
* Rejection → ≥33% of total voting power signs rejection
* Unresolved → No quorum, task remains pending

## **2. Roles in Consensus**

* Performer
  * Finds workflows that need execution
  * Simulates workflow execution
  * Creates a tasks and submits them for attester validation
* Attesters
  * Validate the task and its proofs according to Ditto session policies
  * Approve or reject by signing with BLS
  * Voting power is proportional to the restaked balance
* Aggregator
  * Collects BLS signatures from attesters
  * Verifies quorum thresholds
  * Aggregates signatures and submits the final proof to the Attestation Center
* Attestation Center
  * Receives the aggregated proof
  * Submits the task execution result to the target chain
  * Executes workflow logic via a task submission hook

## **3. Keys and Security Model**

Operators use a dual-key design:

* Controller key (ECDSA, Safe)
  * On-chain actions: registration, submissions, rewards
  * Financially exposed
* Consensus key (BLS)
  * Off-chain attestations and P2P auth
  * Cannot move funds

## **4. Networking**

* libp2p + Gossipsub pub/sub network
* Message flow: Performer → gossip proofOfTask → Attesters → signed votes → Aggregator → on-chain submission

Network types:

* Permissionless: any restaker with stake
* Whitelisted: governance-approved operators only

## **5. On-chain Contracts**

Ethereum (L1):

* Governance & operator staking
* Cross-layer messaging for registrations, slashing, rewards

Task Chain (L2, e.g., Base):

* AttestationCenter
  * Verifies aggregated BLS sigs with OBLS
  * Applies quorum rules, enforces slashing/rewards
* OBLS (Optimized BLS)
  * Efficient verification of aggregates
  * Tracks operator sets and voting power
* InternalTaskHandler
  * Syncs voting power from L1
  * Maintains OBLS registry consistency

## **6. Voting Power**

* Proportional to restaked assets
* Synced from L1 → L2 dynamically
* Governance can define per-task quorum rules

## **7. Ditto Task Definition**

Ditto defines UserOpValidation tasks.

These tasks request validation of proposed UserOperations against Ditto session policies.

Configurable parameters:

* Minimum voting power per attester
* Max attesters per task (latency/gas cap)

## **8. Attested Message Format**

Operators sign a standardized EIP-712 digest:

* userOpHash — canonical ERC-4337 hash
* smartAccount — Ditto account submitting the op
* sessionKey — authorized session key
* sessionNonce — replay protection
* validAfter / validUntil — optional time bounds
* targetChainId — cross-chain replay protection

## **9. End-to-End Flow**

1. Trigger → UserOperation constructed
2. Performer → produces proofOfTask
3. Attesters → validate + sign votes
4. Aggregator → collects sigs, aggregates on quorum
5. On-chain → AttestationCenter + OBLS verify → AC hook → EntryPoint → Ditto Validator Module → executes transaction

## **10. Slashing & Challenges**

* Performer slashing → if consensus rejects
* Attester slashing → if votes contradict finalized consensus
* Challenge system → third parties can prove misbehaviour, claim part of slashed stake

## **11. Ditto Signing Model**

* Attesters sign UserOpConsent (EIP-712 structured)
* Aggregated BLS signature + attester IDs submitted
* DittoValidatorModule verifies signature
* EntryPoint executes authorized transaction

## **12. Failure Modes**

* No quorum → UserOp unauthorized
* Byzantine attesters → slashed if provably malicious
* Operator churn → voting power synced to reflect reality

## **13. Coming soon: Stateless Workflow for Vault Curators**

This model guarantees that vault automations are transparent, reproducible, and consensus-driven, while removing reliance on mutable off-chain infrastructure.

1. **Policy Updates** If the curator changes the policy, it must be done publicly through the registry. All Ditto operators automatically discover and enforce the updated code, ensuring consistent execution across the network.
2. **Session Creation** A session is created pointing to the curator’s specified policy. This policy defines the rules under which automations are authorized.
3. **Vault Integration** The vault installs the ERC-7579 DittoValidatorModule, enabling automated validation and execution of UserOperations against the published workflow.
4. **Workflow Publication** Curators publish compiled workflow code into the Ditto Automation Registry. This code must adhere to Ditto’s enforced runtime restrictions (whitelisted packages, RPC-only access, execution time limits).

This model guarantees that vault automations are transparent, reproducible, and consensus-driven, while removing reliance on mutable off-chain infrastructure.


# Ditto Earn

Deposit into Ditto vaults and track your positions at earn.dittonetwork.io.

[earn.dittonetwork.io](https://earn.dittonetwork.io) lists the vaults below. Check the network and contract address before depositing.

| Vault                                                                                     | Deposit | Network  | Strategy                                                |
| ----------------------------------------------------------------------------------------- | ------- | -------- | ------------------------------------------------------- |
| [Yield Split Vault](https://docs.dittonetwork.io/ditto-earn/yield-split-vault)            | USDC    | Ethereum | Aave, Spark, Fluid and Morpho                           |
| [MUSD Savings Vault V2](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault) | MUSD    | Mezo     | Spark Savings USDC on Ethereum; September 23 deployment |
| [MUSD Savings pilot](https://earn.dittonetwork.io/vaults/musd-savings)                    | MUSD    | Mezo     | Separate August deployment for existing positions       |

The two MUSD vaults have different contracts and share tokens. Positions are not automatically migrated. V2 is live with real funds; initial live end-to-end validation is ongoing.

## Deposit

1. Connect your wallet and switch to the vault's network.
2. Enter an amount and review the estimated shares and price.
3. Approve the deposit token if needed, then confirm the deposit. Wait for successful transaction receipts.

Gas is BTC on Mezo and ETH on Ethereum.

## Withdraw

* **Yield Split Vault:** use its Withdraw tab, subject to its five-minute post-deposit cooldown and available liquidity.
* **MUSD vaults:** request a withdrawal, wait for its batch to fund, then submit a claim. See [Withdrawals](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/withdrawals).

## Reading the dashboard

APY is an estimate, not a guaranteed return. For MUSD, TVL and position value use the last published NAV—not current available cash. The share-price timestamp shows its age. MUSD V2 publishes NAV at withdrawal-batch close or 48 hours after the last publication, subject to safety checks and network availability; this does not change the August pilot. Bridge and swap costs are paid by the vault, even though it charges no protocol deposit/withdrawal fee.

## For developers

* [MUSD / Mezo UI integration](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/integration): current contracts, ABI subset, approvals, asynchronous withdrawals and UI state handling. Do not use a generic synchronous ERC-4626 widget unchanged.
* [Yield Split integration](https://docs.dittonetwork.io/ditto-earn/yield-split-vault/integration): separate product documentation; its SDK/API examples do not apply to the MUSD vault.


# Yield Split Vault

Automated USDC yield across Aave, Spark, Fluid and Morpho, on Ethereum.

The **Yield Split Vault** (share token **ysUSDC**) is a white-label, automated yield aggregator for lending protocols, built on the ERC-4626 standard. It maximizes capital efficiency by rebalancing USDC across blue-chip DeFi strategies (Aave, Spark, Fluid and Morpho) based on realized historical performance.

Depositors can use it directly on the [Earn dashboard](https://earn.dittonetwork.io/vaults/yield-split). Developers and fintechs can offer it inside their own apps through a widget or the Data API, without managing contract interactions or rebalancing themselves — see Integration.

{% hint style="info" %}
This vault was previously documented as **Ditto USD Meta Lending**, and is also referred to as **Ditto Yield**. On chain, the vault is named `Yield Split USDC` with the symbol `ysUSDC`.
{% endhint %}

| Parameter           | Details                                                 |
| ------------------- | ------------------------------------------------------- |
| **Deposit asset**   | USDC                                                    |
| **Share token**     | ysUSDC                                                  |
| **Network**         | Ethereum Mainnet (Chain ID: 1)                          |
| **Standard**        | ERC-4626                                                |
| **Strategies**      | Aave V3, Spark, Fluid, Morpho (Gauntlet and Steakhouse) |
| **Withdrawals**     | Instant, 5 minutes after your last deposit              |
| **Performance fee** | 3.75% of yield above the high-water mark                |

See Architecture for how allocation decisions are made, Deployments for contract addresses, and Integration for the widget and API.


# Architecture

The system operates on a trust-minimized architecture separating **Decision Making** from **Execution**:

1. **Ditto Keeper (Off-chain)**: Watches yield opportunities across the connected protocols and proposes a new allocation.
2. **APR Oracle (On-chain)**: Snapshots realized APRs from underlying protocols to prevent manipulation.
3. **Rebalance execution (On-chain)**: The vault's own keeper-gated `executeRebalance` applies a proposed allocation. It only goes through if the on-chain estimator scores the new allocation above the current one by a configured margin, and a cooldown applies between rebalances.
4. **Vault (ERC-4626)**: Atomically executes deposits/withdrawals across strategies.

#### Security Measures

* **Non-Custodial**: User funds are held in the smart contract, never by Ditto or the integrator.
* **Atomic Execution**: Rebalances happen in a single transaction.
* **Slippage Protection**: The vault snapshots Total Value Locked (TVL) before and after every rebalance.
* **Reward Debt Model**: Protocol fees are minted exclusively from yield. The principal deposit is never touched.
* **Fail-closed guards**: A price guard and a protocol blocklist guard must hold fresh state. If that state goes stale, or a guard reports a problem, deposits and rebalances are blocked. Withdrawals are never gated by the guards.

<figure><img src="https://258555021-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0oqis4JDhDSIVRhBEmPf%2Fuploads%2FwAnEN3PYJuZOOTmglAj9%2FScreenshot%202025-12-05%20at%2011.43.36.png?alt=media&amp;token=1d0810ec-eb70-4aed-831f-9834e9536d15" alt=""><figcaption></figcaption></figure>


# Deployments

List of published contracts and protocol addresses

Currently, the protocol is live on **Ethereum Mainnet**. Deposit at [earn.dittonetwork.io/vaults/yield-split](https://earn.dittonetwork.io/vaults/yield-split).

| Parameter            | Details                                                                                  |
| -------------------- | ---------------------------------------------------------------------------------------- |
| **Vault Name**       | Yield Split USDC                                                                         |
| **Symbol**           | ysUSDC                                                                                   |
| **Network**          | Ethereum Mainnet (Chain ID: 1)                                                           |
| **Underlying Asset** | USDC (`0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`)                                      |
| **Strategies**       | Aave V3 USDC, Fluid USDC, Morpho Gauntlet USDC Prime, Morpho Steakhouse USDC, Spark USDC |
| **Management Fee**   | 0.00%                                                                                    |
| **Performance Fee**  | 3.75% of yield above the high-water mark                                                 |

CORE

| Name                      | Details                                    |
| ------------------------- | ------------------------------------------ |
| YieldSplitVault (Proxy)   | 0x62507A876309639096D08E7F77AC9CfB67Df8011 |
| YieldSplitVault (Impl)    | 0xf861C72c5bdCd393eBd27bF0E89F40C099371605 |
| YieldSplitLogic (Library) | 0x0CC5c605F72c845c70E6A2Ce6AE3676f4807b806 |

INFRASTRUCTURE

| Name                           | Details                                    |
| ------------------------------ | ------------------------------------------ |
| ReturnEstimator (Proxy)        | 0x7C347eA9b12aD44A7d66341F51349fDa3380B754 |
| ReturnEstimator (Impl)         | 0x925F03066C7e3BCb35f7A57388E53b37974d3141 |
| GuardManager (Proxy)           | 0xD8b3208abEF2Be174c54013626f5AAd028dA099D |
| GuardManager (Impl)            | 0x08cc78f0dA4E8a89A9b66211Dd4961B10d7a5b66 |
| ChainlinkPriceGuard            | 0x79CdbAd430Db26BA5b71F4dA6681A53a1a22C94E |
| ProtocolBlocklistGuard (Proxy) | 0x443D490928912251B26f68d8B1b865e7660E3421 |
| ProtocolBlocklistGuard (Impl)  | 0x1048f71699BB83A4761F1efA27a687Cd56437f08 |

ADAPTERS

| Name                       | Details                                    |
| -------------------------- | ------------------------------------------ |
| AaveAdapter (Aave V3)      | 0x1E40C4f4De465490Aa67E45D8ED658cFEb8F63b8 |
| FluidAdapter               | 0x1137Dac313F84A07A07427274A1b3F0D1b26Fd85 |
| MorphoAdapter (Gauntlet)   | 0xD817340FB0b885b4CD8DDc440097ef8094340990 |
| MorphoAdapter (Steakhouse) | 0xC5Ca8DF5b453C35f51D1c897507f2A5daec19546 |
| AaveAdapter (Spark)        | 0x2E07db3a74Dcf604AF4d3a80a5B54A993883Fc74 |

ESTIMATORS

| Name                             | Details                                    |
| -------------------------------- | ------------------------------------------ |
| AaveV3IRMEstimator               | 0x129bD8631b060c30d83576fF1b86F9FE1dF83394 |
| FluidIRMEstimator                | 0x29506C74cbAc305D80037EF7e6639e1A9520d89b |
| MetaMorphoEstimator (Gauntlet)   | 0x514AA224699F3A66300FaD54Bf312d0fD547EAb1 |
| MetaMorphoEstimator (Steakhouse) | 0xEa09e8F9C44EF46b457773C564ADCA531be8AF49 |
| SparkIRMEstimator (Spark)        | 0x1DC6910e7e7090fd1154147f96791d71aA2571C1 |


# Integration

Widget and API

### Widget SDK Integration

{% hint style="warning" %}
The widget SDK is not published yet — `@ditto-network/sdk` is not yet available on npm, and the snippet below describes the planned interface. If you want it for your app, contact us and we will get you into the private beta. The [REST API](#rest-api-reference) below is live today.
{% endhint %}

The easiest way to integrate the Yield Split Vault will be our React SDK. It provides a fully responsive, themed UI for deposits, withdrawals, and analytics.

#### Installation

```bash
npm install @ditto-network/sdk lucide-react
```

#### Basic Usage

```tsx
import { VaultCard, PositionCard, HistoricChart, HistoryCard } from '@ditto-network/sdk';

export default function YieldDashboard() {
  return (
    <div className="flex flex-col gap-4 max-w-md mx-auto">
      {/* 1. Core Interaction */}
      <VaultCard
        vaultAddress="0x62507A876309639096D08E7F77AC9CfB67Df8011"
        theme="dark"
      />

      {/* 2. User Stats & Graph */}
      <PositionCard theme="dark" />

      {/* 3. Analytics */}
      <HistoricChart
        period="30d"
        benchmark="market"
        theme="dark"
      />

      {/* 4. Activity */}
      <HistoryCard limit={5} theme="dark" />
    </div>
  );
}
```

#### Configuration Props

| Prop           | Type      | Default           | Description                             |
| -------------- | --------- | ----------------- | --------------------------------------- |
| `vaultAddress` | `string`  | **Required**      | The address of the Ditto Vault.         |
| `theme`        | `dark`    | `light`           | Interface style                         |
| `primaryColor` | `string`  | `'text-cyan-400'` | Tailwind text color class for accents.  |
| `showSwap`     | `boolean` | `true`            | Show the Deposit/Withdraw interface.    |
| `showChart`    | `boolean` | `true`            | Show the historical APY backtest chart. |
| `showPosition` | `boolean` | `true`            | Show user balance and PnL card.         |
| `showHistory`  | `boolean` | `true`            | Show transaction history list.          |

***

### REST API Reference

For custom dashboards, use the Data API.

**Base URL:** `https://api.dittonetwork.io`

**Auth:** Bearer Token (Contact Sales for API Key)

The payloads below are illustrative; figures are not live values.

#### 1 Get Vault Details

Returns TVL, current APY, and strategy allocation.

**Endpoint:** `GET /vaults/{address}`

```json
{
  "vault": {
    "address": "0x62507A876309639096D08E7F77AC9CfB67Df8011",
    "name": "Yield Split USDC",
    "tvl": {
        "amount": "12,450,230.50",
        "currency": {
            "symbol": "USDC",
            "chain_id": 1,
            "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
        }
    },
    "apy": {
        "current": 5.02,
        "weekly_avg": 4.89
    },
    "allocations": [
        { "protocol": "Fluid", "percent": 45.0, "apy": 5.42 },
        { "protocol": "Spark", "percent": 30.0, "apy": 4.85 },
        { "protocol": "Aave", "percent": 25.0, "apy": 4.12 }
    ]
  }
}
```

#### 2 Get Historical APY Series

Returns daily data points for building charts.

**Endpoint:** `GET /series`

* **Query Params**: `vault`, `period` (7d, 30d, 1y, all)

```json
{
  "period": "30d",
  "data": [
    {
      "date": "2026-05-20",
      "apy": 4.85,
      "tvl": 12123456.00,
      "allocations": [
        { "protocol": "Fluid", "percent": 45.0, "apy": 5.42 },
        { "protocol": "Spark", "percent": 30.0, "apy": 4.85 },
        { "protocol": "Aave", "percent": 25.0, "apy": 4.12 }
      ]
    }
  ]
}
```

#### 3 Get Global Transactions

Returns a paginated list of all vault events (User actions + Protocol actions).

**Endpoint:** `GET /transactions`

* **Query Params**:
  * `vault`: (string) Vault address
  * `depositor`: (string) Depositor address
  * `type`: (string) `DEPOSIT`, `WITHDRAW`, `REBALANCE`, `APR_UPDATE`
  * `limit`: (int) Default 20
  * `page`: (int) Default 1

```json
{
  "meta": {
      "total": 1450,
      "page": 1,
      "limit": 20
  },
  "data": [
    {
      "tx_hash": "0x3a2...9b1",
      "type": "REBALANCE",
      "timestamp": 1748805000,
      "value_usd": "1,250,000.00",
      "details": {
         "strategy_in": "FLUID",
         "strategy_out": "AAVE"
      }
    },
    {
      "tx_hash": "0x4c2...1e9",
      "type": "APR_UPDATE",
      "timestamp": 1748803800,
      "details": {
         "new_apy": 5.02
      }
    }
  ]
}
```

## Usage Examples

**Get all active vaults:**

```bash
curl "https://api.dittonetwork.io/v1/vaults?status=active" \
  -H "Authorization: Bearer $DITTO_API_KEY"
```

**Get specific vault details:**

```bash
curl "https://api.dittonetwork.io/v1/vaults/0x62507A876309639096D08E7F77AC9CfB67Df8011" \
  -H "Authorization: Bearer $DITTO_API_KEY"
```

**Get a user's transactions for a vault:**

```bash
curl "https://api.dittonetwork.io/v1/transactions?vault=0x62507A876309639096D08E7F77AC9CfB67Df8011&user=0xYourAddress" \
  -H "Authorization: Bearer $DITTO_API_KEY"
```


# Ditto MUSD Savings Vault

Deposit MUSD on Mezo; the vault invests USDC in Spark Savings on Ethereum.

Deposit MUSD on Mezo and receive **dMUSD**, your share of the vault. Ditto swaps and bridges the funds to Ethereum, then supplies USDC to Spark Savings. A buffer stays on Mezo for withdrawals.

[Open V2 on Ditto Earn](https://earn.dittonetwork.io/vaults/musd-savings-v2) · [Deployments](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/deployments) · [Mezo UI integration](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/integration)

**V2 was deployed September 23, 2026.** It holds real funds; initial live end-to-end validation is still in progress. Start small. The [August pilot](https://earn.dittonetwork.io/vaults/musd-savings) remains a separate vault—pilot shares do not become V2 shares.

| Item                        | Behaviour                                                                                                |
| --------------------------- | -------------------------------------------------------------------------------------------------------- |
| Network                     | Mezo mainnet, chain ID 31612                                                                             |
| Deposit asset / share token | MUSD / dMUSD, both 18 decimals                                                                           |
| Entry                       | Shares minted immediately at the last published price                                                    |
| Exit                        | Request → batch settlement → claim                                                                       |
| Yield                       | USDC invested in Spark Savings on Ethereum                                                               |
| Costs                       | No protocol deposit/withdrawal fee. Bridge and swap costs reduce vault value; wallet gas is BTC on Mezo. |

## Share price and balances

The published share price is the MUSD value of one dMUSD. For V2, operators update it when a withdrawal batch closes, or 48 hours after the last publication. Safety checks, liquidity, RPC or quorum failures can delay publication; 48 hours is a target, not a guaranteed deadline. It is **not a live balance**. Deposits use the last published price without a NAV-age gate, so it can still lag current value in either direction. This policy has been active since October 13, 2026; the August pilot is unchanged.

Only the Spark position earns yield. Idle balances and funds crossing the bridge do not. The displayed APY is an estimate, not a guaranteed net return. Bridge/swap costs, stablecoin exchange rates and losses can outweigh yield.

The dashboard separates buffer, Spark, other nonzero balances and recent bridge activity. Do not add transfer history to balances or assume the difference from published-NAV TVL is money in transit.

## Withdrawals

Request in dMUSD, wait for the batch to be funded, then claim MUSD. The current operator policy closes a non-empty batch at 100 MUSD queued or 24 hours after opening. Settlement can take longer if funds must return from Ethereum or services are delayed. See [Withdrawals](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/withdrawals).

## Risks and control

You can lose funds through vault, bridge or venue failures, stablecoin price changes and accounting or operational failures. Withdrawal timing is not guaranteed.

The current five operator seats are run by Ditto; four signatures authorize normal execution. Both guardian keys and upgrade authority are currently controlled by Ditto. This is not yet an independently operated or jointly custodied deployment with Mezo.


# Withdrawals

Request dMUSD redemption, wait for batch funding, then claim MUSD on Mezo.

The V2 flow is **request → settle → claim**. All user transactions are on Mezo and use BTC for gas. Use the [vault that holds your shares](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/deployments); pilot and V2 requests are separate.

## 1. Request

On the **Withdraw** tab, enter dMUSD and confirm **Request withdrawal**. The shares are locked into the current batch. The MUSD amount shown is an estimate; the final entitlement uses the share price fixed at batch close.

## 2. Wait for settlement

Current operator policy makes a non-empty batch due when either trigger is reached:

| Trigger | Value                                            |
| ------- | ------------------------------------------------ |
| Size    | 100 MUSD of queued shares at the published price |
| Age     | 24 hours since the batch opened                  |

An empty batch stays open. If it is already 24 hours old, the next request makes it due immediately. **Due is not the same as closed:** operators must execute the close, then fund it.

V2 also publishes NAV after 48 hours without a successful price publication, subject to safety checks and network availability. That standalone update does not close or fund a withdrawal batch and is not a settlement deadline. The batch triggers above are unchanged.

The vault pays from its Mezo buffer where possible. Otherwise, funds return from Spark through the bridge and a swap back to MUSD. A buffer payment is generally faster; RPC, operator, venue or bridge delays can extend either path. Do not treat the displayed estimate as a deadline.

## 3. Claim

When **Your withdrawals** shows an amount ready to claim, press **Claim**. MUSD is paid to your wallet. This is a separate transaction; funds do not arrive automatically just because the batch settled.

Partial emergency funding may permit a partial claim, with the remainder payable after more funding. Already funded claims remain callable while the vault is Paused or Deprecated. V2 also preserves requests and cancellation after deprecation; pause can delay normal settlement.

## Cancellation

Cancel only while the batch is **Open**. Your dMUSD returns to your wallet. If the batch is already due by size or age, it may close before a cancellation transaction is included. Once closed, cancellation is no longer possible.

## Statuses

| Status           | Meaning                                                         |
| ---------------- | --------------------------------------------------------------- |
| Open             | Requests accepted; cancellation possible                        |
| Processing       | Closed; waiting for funding                                     |
| Partially funded | Claim only the amount currently available; retain the remainder |
| Settled          | Funding complete; any unclaimed entitlement can be claimed      |

For wallet/frontend implementation, use [Mezo UI integration](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/integration). The on-chain claimable amount—not a timer or estimated bridge arrival—determines whether Claim is enabled.


# Deployments

September 23 V2 contracts for new integrations, with the August pilot listed separately.

## V2 — September 23, 2026

**Use this deployment for the Mezo UI integration:** `mainnet-2026-09-23`.

[Open V2 on Ditto Earn](https://earn.dittonetwork.io/vaults/musd-savings-v2) · [Integration guide](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/integration)

The contracts are live on mainnet. Initial live end-to-end validation is ongoing. This is a separate vault, not an upgrade or automatic migration of pilot shares.

### Mezo — chain ID 31612

Gas: BTC. Index deployment events from block **12045502**. Contract addresses below are the user-facing proxies where applicable.

| Contract / asset                | Address                                                                                                                    | Units                                 |
| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------- |
| **Vault and dMUSD share token** | [0x9171Cb787C3fEEbBC808D07CaB62B1d789CE14F8](https://explorer.mezo.org/address/0x9171Cb787C3fEEbBC808D07CaB62B1d789CE14F8) | 18 decimals                           |
| **MUSD — deposit asset**        | [0xdD468A1DDc392dcdbEf6db6e34E89AA338F9F186](https://explorer.mezo.org/address/0xdD468A1DDc392dcdbEf6db6e34E89AA338F9F186) | 18 decimals                           |
| WithdrawalQueue                 | [0xeBA277be5AEdd2Bb2F90f81f01ea58f1cc959A0a](https://explorer.mezo.org/address/0xeBA277be5AEdd2Bb2F90f81f01ea58f1cc959A0a) | Shares and MUSD: 18 decimals          |
| NAVConsumer                     | [0x16270960d928B687A2dedC0235036CcbdaE03F8c](https://explorer.mezo.org/address/0x16270960d928B687A2dedC0235036CcbdaE03F8c) | MUSD per share, scaled by 1e27        |
| MezoOpsExecutor                 | [0x398a3B42bb6634b4B4E7bB2f4CbF871C8d1151F6](https://explorer.mezo.org/address/0x398a3B42bb6634b4B4E7bB2f4CbF871C8d1151F6) | Operations; not a user deposit target |
| mUSDC — bridge asset            | [0x04671C72Aab5AC02A03c1098314b1BB6B560c197](https://explorer.mezo.org/address/0x04671C72Aab5AC02A03c1098314b1BB6B560c197) | 6 decimals                            |
| Mezo bridge adapter             | [0xcf2299Fc9A47cD119288e045a1fff29A5f198a30](https://explorer.mezo.org/address/0xcf2299Fc9A47cD119288e045a1fff29A5f198a30) | Operations only                       |
| Swap adapter                    | [0x04D4B796800b1704Ad043BD5889f882A80ceBb3B](https://explorer.mezo.org/address/0x04D4B796800b1704Ad043BD5889f882A80ceBb3B) | Operations only                       |

### Ethereum — chain ID 1

Index deployment events from block **26040402**. These addresses are for strategy/asset reads; users deposit and claim on Mezo.

| Contract / asset                 | Address                                                                                                               |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| BridgeReceiver                   | [0x73e97D42f341713e2ED10E55964C066d924a8106](https://etherscan.io/address/0x73e97D42f341713e2ED10E55964C066d924a8106) |
| Spark Savings adapter            | [0x4E9011545FDCE94238A5767057c32692A420ecE5](https://etherscan.io/address/0x4E9011545FDCE94238A5767057c32692A420ecE5) |
| Spark Savings USDC — yield venue | [0x28B3a8fb53B741A8Fd78c0fb9A6B2393d896a43d](https://etherscan.io/address/0x28B3a8fb53B741A8Fd78c0fb9A6B2393d896a43d) |
| USDC — 6 decimals                | [0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48](https://etherscan.io/address/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48) |
| Ethereum bridge adapter          | [0x04D4B796800b1704Ad043BD5889f882A80ceBb3B](https://etherscan.io/address/0x04D4B796800b1704Ad043BD5889f882A80ceBb3B) |

Always identify a contract by **chain ID plus address**. The same address can identify different contracts on the two chains.

### Current NAV publication policy

Since October 13, 2026, V2 publishes NAV at withdrawal-batch close or 48 hours after the last successful publication. Safety checks and network availability can delay it. This runtime update changes no address or user-facing ABI in the tables above and does not change the August pilot.

Read `currentNAV()` and `lastPostedAt()` from the existing NAVConsumer; see [UI refresh requirements](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/integration#nav-publication-and-ui-refresh). Runtime source: [PR #64](https://github.com/dittonetwork/mezo-stable-yield/pull/64), merge `61bdb690ff1afb93e528e1219c65d774c395ba89`.

### Machine-readable record and source

* [Full deployment JSON](https://github.com/dittonetwork/mezo-stable-yield/blob/291fe1903ee32f96f76818e87ba053710ab7df49/ops/deployments/mainnet-2026-09-23.addresses.json): both chains, all wiring and deployment blocks.
* [Deployment verification](https://github.com/dittonetwork/mezo-stable-yield/blob/291fe1903ee32f96f76818e87ba053710ab7df49/deployments/mainnet-2026-09-23.verification.json).
* Signed deployment source: `22a2783baf3a4321a05245f71f9015c18db18499`; evidence commit: `291fe1903ee32f96f76818e87ba053710ab7df49`.

Repository access may be required. The public integration guide includes the user-facing ABI subset and addresses, so the Mezo UI does not depend on a private repository at runtime.

## August pilot — existing holders only

[Open the pilot](https://earn.dittonetwork.io/vaults/musd-savings). These are **not V2 addresses**. The two vaults both use the symbol dMUSD but have different tokens, balances and requests. Do not combine them by symbol or move users automatically.

| Chain      | Contract            | Address                                      |
| ---------- | ------------------- | -------------------------------------------- |
| Mezo 31612 | Vault / pilot dMUSD | `0x762a17f2B3164ea5010C1C88085AeAC8872957D0` |
| Mezo 31612 | WithdrawalQueue     | `0x9D72922Fd520154a2bE98D36033839874B274290` |
| Mezo 31612 | NAVConsumer         | `0x40bb55996363e5Da6754A65fAB4F70fB520Ff99e` |
| Mezo 31612 | MezoOpsExecutor     | `0xb08F6bac55d0058B11D74E0cF6A76EF4C2A43754` |
| Ethereum 1 | BridgeReceiver      | `0x7817548BE174C22DecDe831Ea9d514927fD0D286` |
| Ethereum 1 | Spark adapter       | `0x944C7F5e08686117a5Bf66bE56b2B4bae869642C` |

MUSD and the Spark Savings venue are shared assets, not shared vault accounting. Keep deployment selection explicit.


# Mezo UI integration

Integrate the September 23, 2026 MUSD vault into a Mezo wallet or frontend.

Use deployment **`mainnet-2026-09-23`**. This is the V2 vault, not the August pilot. All user transactions take place on **Mezo mainnet, chain ID 31612**, with **BTC for gas**. Users do not bridge funds or transact on Ethereum themselves.

The vault is live with real funds. Initial live end-to-end validation is still in progress; a funded deposit → request → claim test remains a release check for the Mezo integration.

[Deployment addresses](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/deployments) · [Reference UI](https://earn.dittonetwork.io/vaults/musd-savings-v2) · [Frontend source](https://github.com/dittonetwork/delta-neutral-vault-frontend)

## 1. Network and contracts

```ts
import { parseAbi, parseUnits } from 'viem';

const chainId = 31612;
const MUSD = '0xdD468A1DDc392dcdbEf6db6e34E89AA338F9F186';
const VAULT = '0x9171Cb787C3fEEbBC808D07CaB62B1d789CE14F8';
const QUEUE = '0xeBA277be5AEdd2Bb2F90f81f01ea58f1cc959A0a';
const NAV = '0x16270960d928B687A2dedC0235036CcbdaE03F8c';

const tokenAbi = parseAbi([
  'function allowance(address owner, address spender) view returns (uint256)',
  'function approve(address spender, uint256 amount) returns (bool)',
  'function balanceOf(address account) view returns (uint256)',
]);
const vaultAbi = parseAbi([
  'function asset() view returns (address)',
  'function queue() view returns (address)',
  'function nav() view returns (address)',
  'function mode() view returns (uint8)',
  'function balanceOf(address account) view returns (uint256)',
  'function totalAssets() view returns (uint256)',
  'function maxDeposit(address receiver) view returns (uint256)',
  'function estimateDeposit(uint256 assets) view returns (uint256 shares, bool available)',
  'function convertToAssets(uint256 shares) view returns (uint256)',
  'function deposit(uint256 assets, address receiver) returns (uint256 shares)',
  'function requestWithdrawal(uint256 shares) returns (uint256 batchId)',
  'function cancelRedeem(uint64 batchId, uint256 shares)',
  'function claimWithdrawal(uint64 batchId) returns (uint256 assets)',
  'event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares)',
  'event RedeemRequest(address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 shares)',
]);
const queueAbi = parseAbi([
  'struct BatchInfo { uint64 batchId; uint8 status; uint8 reason; uint64 openedAt; uint64 closedAt; uint64 eta; uint256 totalShares; uint256 closeNavRay; uint256 obligation; uint256 funded; uint256 claimed; }',
  'function currentBatchId() view returns (uint64)',
  'function batchInfo(uint64 batchId) view returns (BatchInfo)',
  'function sharesOf(address controller, uint64 batchId) view returns (uint256)',
  'function claimableAssets(address controller, uint64 batchId) view returns (uint256)',
  'event Claimed(uint64 indexed batchId, address indexed controller, address receiver, uint256 assets)',
]);
const navAbi = parseAbi([
  'function currentNAV() view returns (uint256)',
  'function lastPostedAt() view returns (uint64)',
]);
```

MUSD and dMUSD both use **18 decimals**. `currentNAV()` is MUSD per dMUSD scaled by **1e27**. Ethereum USDC and Mezo mUSDC use 6 decimals; they are not the deposit token.

Use the **vault proxy** above for user calls and as the approval spender, not its implementation. Send the approval transaction to MUSD. Check `eth_chainId`, `asset()`, `queue()` and `nav()` against this bundle before enabling transactions. The vault is also the dMUSD ERC-20 token.

**Do not use a generic synchronous ERC-4626 widget unchanged.** All four `preview*` methods and synchronous `withdraw`/`redeem` revert. `maxWithdraw`/`maxRedeem` return zero because instant exits are unsupported—not because withdrawal requests are disabled. Use the methods below. No Ditto API key or operator service is required for these flows.

## 2. Deposit MUSD

The examples assume a Mezo `publicClient`, a `walletClient` connected to the user's wallet, and the selected address `account`. Never use a server-held key to sign user transactions.

1. Read `mode()` (0 = Active), MUSD balance, BTC balance, `maxDeposit(account)` and `estimateDeposit(assets)`. The estimate's `available` flag only checks mode: it does not check balance, allowance or cap. Block submission on failed reads, zero shares or an amount above the deposit limit.
2. Read `MUSD.allowance(account, VAULT)`. If insufficient, approve **VAULT**, not the queue or bridge. An exact-amount approval is sufficient. Wait for a successful approval receipt before depositing.
3. Simulate `deposit(assets, account)`, then request the wallet transaction. Display success only after a successful receipt; the vault's `Deposit` event gives the actual shares minted.

```ts
const assets = parseUnits('10', 18); // example, not a minimum
// After the balance, mode, cap and allowance checks above:
const { request } = await publicClient.simulateContract({
  account, address: VAULT, abi: vaultAbi,
  functionName: 'deposit', args: [assets, account],
});
const hash = await walletClient.writeContract(request);
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== 'success') throw new Error('Deposit reverted');
```

Deposits mint shares immediately at the **last published NAV**. They do not wait for placement or bridging. The estimate can change before inclusion; the deposit method has no `minShares` argument. Show the price and `lastPostedAt()` timestamp, not a promise of a fixed output.

## 3. Request, track and claim a withdrawal

| Step     | User call / read                                                   | Behaviour                                                                                                                                                                                   |
| -------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Request  | `VAULT.requestWithdrawal(shares)`                                  | Amount is **dMUSD**, not MUSD. Locks the user's shares into a batch. No dMUSD approval is needed for this self-service method.                                                              |
| Identify | `RedeemRequest` in the request receipt                             | `requestId` is the batch ID. Filter logs by the **vault address** and the expected controller/owner. Do not use a pre-read `currentBatchId()` as proof: a batch may close before inclusion. |
| Track    | `QUEUE.batchInfo(batchId)` and `claimableAssets(account, batchId)` | Poll after receipts and while processing. Keep the request visible after shares leave the wallet.                                                                                           |
| Cancel   | `VAULT.cancelRedeem(batchId, shares)`                              | Only while status is **Open**. Check `sharesOf(account, batchId)` and simulate; cancellation can race batch close.                                                                          |
| Claim    | `VAULT.claimWithdrawal(batchId)`                                   | Enable when **claimableAssets > 0**, including partial funding. Pays MUSD to the calling user. Claim is a separate wallet transaction.                                                      |

Use the same simulate → wallet → successful-receipt pattern for each write. Refresh balances, batch status and claimable amount afterwards. An emergency partial claim can leave more payable later; do not delete the request merely because one claim succeeded. `sharesOf` is not a reliable remaining-entitlement view after claims: use `claimableAssets` and the vault's `pendingRedeemRequest` / `claimableRedeemRequest` views when needed.

To restore requests after reconnecting, index this vault's `RedeemRequest` events for the controller from **Mezo block 12045502**. Store the key as `(chainId, vault, controller, batchId)`. Handle reorgs and RPC errors; an unreadable range is not an empty history. Current batch ID is only for displaying where the next request is expected to go.

| `BatchInfo.status`                  | UI treatment                                                   |
| ----------------------------------- | -------------------------------------------------------------- |
| 0 — None                            | No such batch                                                  |
| 1 — Open                            | Queued; cancellation available                                 |
| 2–4 — Closed / Unwinding / InFlight | Processing; do not require every intermediate status to appear |
| 5 — PartiallyFunded                 | Claim what `claimableAssets` permits; retain unpaid remainder  |
| 6 — Fulfilled                       | Settled; claim only if the user's `claimableAssets` is nonzero |

Current off-chain policy is **100 MUSD queued or 24 hours after the batch opened**, with no empty-batch close. These are operator settings, not immutable contract deadlines. Closing and funding still require execution. `eta == 0` means unknown, not immediate. Buffer-funded settlement is faster than returning funds from Ethereum; do not show an unconditional completion time.

Modes: **0 Active**, **1 Paused**, **2 Deprecated**. Disable deposits outside Active. V2 still accepts withdrawal requests and open-batch cancellation in modes 1 and 2, and funded claims remain callable. Pause can delay normal settlement; Deprecated is a permanent wind-down, not confiscation of claims. These V2 rules must not be applied blindly to the pilot.

## 4. Values and risk copy

### NAV publication and UI refresh

Since **October 13, 2026**, V2 publishes NAV when a non-empty withdrawal batch closes, or **48 hours after the last successful publication**, whichever triggers the next update. A successful batch-close update, standalone post or guardian override resets the clock. This is an off-chain operator policy, not an on-chain freshness guarantee; the August pilot is unchanged.

The aggregator builds the full NAV calculation when a price update is needed, not on every idle loop. Publication still requires the normal finality, bridge-accounting, price/liquidity and operator-quorum checks. Failed checks or unavailable RPCs delay publication and trigger retries/monitoring; the last published price remains in use.

**No contract address, ABI or transaction-flow changes are needed for this cadence update.** Keep reading `currentNAV()` and `lastPostedAt()` from the existing NAVConsumer. Refresh those reads, `totalAssets()` and `convertToAssets(balanceOf(account))` through the UI's normal polling and after relevant receipts. Do not wait only for a batch-close event: standalone NAV updates also change the share price, TVL and position value. Do not calculate or post NAV in the frontend, or substitute an animated estimate for the published price.

Suggested FAQ copy: "The share price updates when a withdrawal batch closes, or 48 hours after the last publication. Safety checks or network issues may delay an update. Deposits use the last published price."

The 48-hour interval is not a withdrawal-settlement deadline or the independent liveness heartbeat. Withdrawal batch triggers remain 100 MUSD or 24 hours after opening; funding and claim follow separately.

### Display values

* **Position value:** `convertToAssets(balanceOf(account))`, explicitly labelled at the last published NAV. Show pending withdrawals and claimable MUSD separately.
* **TVL:** `totalAssets()` is NAV-marked, not cash available to withdraw. Pending obligations and queue balances must not be blindly added again.
* **APY:** show Spark Savings' current rate as the vault's estimated APY, as the reference UI does. Label it an estimate, not a guaranteed return: the vault's actual yield varies with rebalancing. Part of the MUSD stays on Mezo as a withdrawal buffer, new deposits move to Spark in batches, and bridge and swap costs show up in the share price.
* **Fees:** no protocol deposit/withdrawal fee; bridge and swap costs are borne by the vault. Wallet gas is BTC on Mezo.
* **Risk:** stale published prices, stablecoin exchange rates, contract/bridge/venue failures and operator delays can reduce value or delay exits. Deposits are public; there is no NAV-age gate.
* **Bridge display:** show independently verified transfer status, not `TVL minus visible balances`. Ditto Earn's recent-activity endpoint is a bounded UI feed, not a settlement oracle or an all-time pending balance API.

## Before releasing the Mezo UI

* Confirm the chain, four contract addresses and 18/27 decimal handling against this deployment.
* Test approval rejection, failed RPC reads, reverted transactions and wallet/network changes.
* Run deposit → request → batch funding → claim with a small agreed amount; separately check cancel while Open and a request racing close.
* Test partial claim, paused/deprecated handling and reconnection in fixtures or on a fork—do not mutate production governance to test the UI.
* Verify that a standalone NAV update refreshes the displayed share price, TVL and position value without a withdrawal-batch event. Use a fixture or fork; do not send a production transaction just to test the UI.
* Keep the August pilot as a separate product/address if supporting it. Its shares do not become V2 shares.

Reference selectors and tuple layout were checked against the deployed September 23 contracts and source on 2026-09-23. Full source: [DMUSDVault](https://github.com/dittonetwork/mezo-stable-yield/blob/291fe1903ee32f96f76818e87ba053710ab7df49/src/DMUSDVault.sol), [WithdrawalQueue](https://github.com/dittonetwork/mezo-stable-yield/blob/291fe1903ee32f96f76818e87ba053710ab7df49/src/WithdrawalQueue.sol). Repository access may be required.


# FAQ

Shares, fees, timing and risks for the MUSD vault.

## Which vault should a new integration use?

The **September 23 V2 deployment**. See [Deployments](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/deployments). The August pilot remains available to existing holders and has a separate dMUSD token.

## What do I receive?

dMUSD shares in your wallet. Their MUSD value follows the published share price. Only funds invested in Spark earn yield; cash and funds in transit do not.

## Why can TVL differ from the visible balances?

TVL uses the last published NAV, while balance reads and bridge activity refresh separately. Bridge/swap costs, accrued yield and MUSD/USDC exchange rates can change value between NAV posts. Transfer history is not an additional balance to add to TVL.

## When does the share price update?

For V2, when a withdrawal batch closes, or 48 hours after the last publication. Updates may be delayed if safety checks fail or the network is unavailable. Deposits use the last published price, which can lag current value in either direction. The independent liveness heartbeat does not publish NAV. This 48-hour policy does not apply to the August pilot.

## How do I get my funds back?

Request a withdrawal, wait for batch funding, then claim. Cancel only while the batch is Open. Timing depends on operators, liquidity and bridge settlement; it is not guaranteed. See [Withdrawals](https://docs.dittonetwork.io/ditto-earn/ditto-musd-savings-vault/withdrawals).

## What does it cost?

No protocol deposit or withdrawal fee. Bridge and swap costs are paid by the vault and reduce share value. You pay transaction gas in BTC on Mezo.

## Can I lose money?

Yes. Smart-contract, bridge, venue and operational failures, stablecoin price changes and costs can reduce the share price or delay withdrawals. The displayed APY is not a guaranteed return.


# Vault Reporting

Custom Oracle for On-Chain Vault Valuation and Share Price Calculation

<https://docs.dittonetwork.io/overview/protocol-overview>

### **Overview**

Ditto offers your vault infrastructure an upgrade through the **Ditto Custom Oracle Service** — a decentralized, restaked oracle that publishes the portfolio NAV on a fixed schedule (e.g., hourly/4h/daily) with a defined SLA and max‑staleness guard.

This value becomes the **source of truth** for calculating the current vault share price, defined as:

$$
NAV\_{\text{usd}} = \sum (\text{assets marked to FMV}) - \text{liabilities}
$$

These values use 18 decimals with rounding mode “round‑down” and the base currency (USD) explicitly stated.\
This ensures a single, unambiguous formula — eliminating pricing disputes and providing a reliable reference for ERC-4626/7540 hooks that consume this value — allowing all depositors to see the near-real-time, verifiable performance; typical lag = block finality + update interval.&#x20;

***

### Pricing Policy

> **Source order:** on‑chain oracle/TWAP → vendor FMV → VWAP fallback.\
> **TWAP window:** 30 minutes (default).\
> **SLA:** 5 minutes.\
> **Max staleness:** 45 minutes.\
> **FX oracle & cache TTL:** configured by governance

Prices are aggregated in order of priority: first from on‑chain oracles or TWAPs, then from vendor full‑market‑value feeds, with a volume‑weighted average price (VWAP) as a fallback.

***

### **Motivation**

Today, vault performance and total asset value are derived from multiple off-chain dashboards manually. These are valuable tools but come with limitations:

* Updates are delayed and infrequent.
* Off-chain dashboards require human reconciliation of wallet lists and signer changes; our feed removes that manual step by attesting source lists on-chain.

By integrating Ditto’s **Custom Oracle**, your vault gains a **continuous, decentralized, and transparent pricing mechanism** — making the vault share value **cryptographically verifiable** at all times.

***

### **How It Works**

#### **1. Data Aggregation**

Ditto restaked operators fetch data from all relevant asset sources:

| Source                                                                                                                                    | Description                                                                                  |
| ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| <p><strong>Indexers/RPC scans</strong><br><a href="https://debank.com/profile/0xc35bc7e918bb4c0159296d9749dc59de605b4b93">example</a></p> | Fetched via Debank / RPC scans.                                                              |
| **Perp DEX positions**                                                                                                                    | Collateral ± unrealized PnL at the oracle price; apply a haircut if the price feed is stale. |
| **CEX balances (read‑only keys)**                                                                                                         | Use exchange APIs with read‑only keys; mark balances to FMV via the pricing policy.          |

> 🔒 Read-only API keys are shared among Ditto operators and never exposed publicly.\
> Keys are managed through KMS/HSM with at-rest encryption, restricted by IP allow-listing and least-privilege scopes.\
> Only fetcher pods have ephemeral access; operators never view raw credentials.\
> Key rotation cadence(e.g. 30 days) and a compromise response playbook are enforced to ensure ongoing security integrity.\
> Operators never see raw secrets; only short-lived fetcher tokens are used

***

#### **2. Operator Consensus**

Each Ditto restaked operator independently computes the **portfolio’s total USD value** based on the aggregated data.

* **Operator set size (n)** and **threshold (t)** define how many signatures are required to publish NAV.
* **Aggregation**: median of submitted NAV values with a median absolute deviation (MAD) outlier filter to remove outliers.
* **Signature scheme**: BLS aggregated signatures, with slashing or eviction for misbehaving operators.

Values are then submitted to the Othentic Consensus Aggregator, which:

* Validates multiple operator submissions and their signatures.
* Publishes this value on-chain.

***

#### **3. On-Chain Publication**

The **on-chain value** represents the **Net Asset Value (NAV)** of the vault, updated periodically (e.g., hourly or daily).

This value directly determines the **current vault share price** used for:

* **New deposits:** calculates how many shares the user receives per token deposited.
* **Withdrawals:** determines how much underlying value each share redeems.
* **Transparency:** gives depositors a verifiable real-time metric of vault performance.

To prevent stale-price exploitation during periods of high inflows or outflows, the protocol applies several safeguards:

* **Deposit/withdrawal queue windows**: aligned to NAV update intervals.
* **Deviation guard**: compares the published **NAV** against a **TWAP NAV**.
* **Preview functions** (`previewDeposit`, `previewWithdraw`): revert when **staleness exceeds the SLA**, ensuring users interact only with fresh prices.
* An optional **anti‑arbitrage spread** may be applied near the SLA edge.

These controls ensure that pricing integrity and fairness are maintained, even under volatile market conditions.

***

### **Benefits**

* Provides a **near‑real‑time** (latest verified) on‑chain NAV and price per share feed with a defined SLA and staleness guard.
* Supports both DeFi positions and CEX balances via read‑only keys.
* Enables ERC‑4626/7540 vault hooks to access the **latest verified** NAV for depositor fairness.
* Gas infrastructure via ERC‑4337/7579 is used only for transaction submitters, reducing overhead for vault operators.

***

### **Deployment Flow**

1. **Setup**
   * Curator provides read-only API keys and wallet addresses.
   * Ditto registers these sources in the oracle config.
2. **Operator Fetch & Compute**
   * Restaked operators independently fetch and calculate total USD value.
3. **Consensus & Publication**
   * Aggregated operator value is posted on-chain via Ditto Oracle Automation.
   * The vault smart contract uses this value to fetch share price.
4. **Verification**
   * Any user can verify vault NAV and share price directly on-chain.
   * Frontend dashboards display “verified by Ditto” tag with latest update timestamp.

To start integration please contact <info@dittonetwork.io>

***

### **Service Summary**

* Provides a **near‑real‑time** (latest verified) on‑chain NAV and price per share feed with a defined SLA and staleness guard.
* Supports both DeFi positions and CEX balances via read‑only keys.
* Enables ERC‑4626/7540 vault hooks to access the **latest verified** NAV for depositor fairness.
* Gas infrastructure via ERC‑4337/7579 is used only for transaction submitters, reducing overhead for vault operators.

***

### **Outcome**

By integrating Ditto’s Custom Oracle, your vault transitions from **opaque manual valuation** to **fully transparent, on-chain verified NAV and share pricing**.

This improves:

* **Depositor trust**
* **Operational transparency**
* **Auditability**
* **Market confidence**
* **Reduced pricing delay**

and positions your strategy as a leader in **institutional-grade DeFi asset management**.

#### We put NAV on-chain without migrating your stack; competitors either keep NAV off-chain (Cryptio/Lukka) or require moving assets into their vault (Enzyme).

| Platform                    | On-Chain Pricing Feed                        | DeFi + CEX support              | Notes                                                                                  |
| --------------------------- | -------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------- |
| **Ditto Custom NAV Oracle** | ✅ Yes — Othentic BLS-aggregated attestations | Yes (DeFi + CEX read‑only keys) | On‑chain quorum publishes NAV and pps; can ingest FMV from vendors like Lukka/Cryptio. |
| **Cryptio**                 | ❌ None                                       | Partial (off‑chain accounting)  | Off‑chain accounting; no on‑chain oracle.                                              |
| **Lukka**                   | ❌ None                                       | Partial (enterprise FMV)        | Produces FMV but no on‑chain output; can be ingested by Ditto.                         |
| **Enzyme**                  | ✅ Internal (vault-level)                     | No external CEX                 | Native vault accounting internal to Enzyme; cannot aggregate external CEX balances.    |

***

### **Update SLA and Failure Handling**

To maintain reliable on-chain pricing, the NAV Oracle enforces a strict **Service Level Agreement (SLA)** for update frequency.\
If updates are missed or delayed, the system automatically applies fallback and signaling mechanisms.

**Mechanisms:**

* **Skip-block policy:** minor missed updates within tolerance are skipped without slashing to prevent redundant transactions.
* **Operator set churn:** persistent underperformance triggers automatic replacement of inactive operators from the active set.
* **Staleness guard:** when the update delay exceeds the SLA threshold, reads fall back to the **last valid NAV** value, and a `Stale()` event is emitted on-chain.

These controls ensure continuity of data availability while preserving transparency around operational reliability.

***

### **Proof Bundle Publication**

Each NAV update includes a **proof bundle**, containing:

* Source data snapshots (DeFi + CEX positions)
* Pricing ticks and oracles used
* Individual operator signatures

The **hash of the proof bundle** is published on-chain with every update, while the full bundle is stored off-chain for audit and verification purposes.

**Events:**

* `ProofBundlePublished(proofHash, proofURI)` — emitted per update.
* The `proofURI` provides access to the full verification bundle hosted on IPFS, Arweave, or a similar decentralized store.

This ensures reproducibility, auditability, and verifiable linkage between on-chain NAVs and off-chain data sources.

***

### **Incident Communication**

In the event of data feed issues, missed updates, or operator coordination failures, Ditto maintains a dedicated **incident communication channel** and **status page**.

**Key components:**

* Real-time status updates on NAV Oracle health and SLA adherence.
* Public incident reports summarizing root cause, resolution timeline, and corrective measures.
* Operator coordination and transparency log for historical events.

This guarantees operational transparency and trust for all vault integrators and depositors.


# Looping Strategy

Automated Multi-Risk ERC-4626 Vaults with Ditto Execution Engine

<https://docs.dittonetwork.io/overview/protocol-overview>

## **Overview**

Ditto Automation Labs is designing the first iteration of its automated vault system, standardized on **ERC-7540** (asynchronous deposits and withdrawals), extending ERC-4626. This design ensures that deposits and withdrawals can be processed asynchronously, enabling smooth management of liquidity in complex looped strategies.

The vault will be controlled by a **VaultOperator**, set to the multisig safe of the **Ditto Vaults Curator**. This multisig issues a **session via the Ditto Validator module**, granting the right to trigger automations (activations, deactivations, rebalances) on the vault in a controlled, permissioned manner.

The product’s positioning remains the same: a **hands-free yield automation platform** with execution guarantees powered by Ditto’s decentralized operator network.

### **Core Development Items**

[PoC Spec](https://www.notion.so/PoC-Spec-280d3e1d9514802da9caff5a05282cbc?pvs=21)

1. **Position Valuation**
   * A **smart contract** to deliver the current value of the vault’s position on a lending borrowing protocol.
   * Alternatively, an automation that periodically refetches and updates values.
   * Especially relevant for **cross-chain liquidity allocations**, ensuring share accounting remains correct across deposits and withdrawals.
2. **Strategy Selector Script**
   * A **JavaScript service** that fetches APYs from supported protocols.
   * Compares the profitability of different pool configurations.
   * Decides whether to rebalance, deactivate, or activate assets.
   * **Loop logic**: calculates the target loop number dynamically, subject to a minimum improvement threshold (e.g., skip looping if boost <0.2%).
3. **Router Smart Contract**
   * Handles **position winding and unwinding**.
   * Uses lending pools, uni pools, slippage parameters, and target loop numbers.
   * More efficient than flashloans (0.05% cost of flashloan).
   * Can also **unwind** without flashloans, making exit safer and cheaper.
4. **Withdrawal Processor**
   * Monitors the size of the withdrawal queue and unwinds the required amount marking them available to claim according to current position value and share-to-asset rate.

### **Oracle & Valuation**

To ensure accurate vault accounting:

* Ditto proposes using an **on-chain lens oracle** to track **total position value** at any moment.
* This enables:
  * Fair deposit share issuance.
  * Precise share burns on withdrawals.
  * Transparent, tamper-proof vault valuation for all participants.

### **Guards & Security**

Ditto introduces a dual-guard system to protect vaults and ensure execution integrity:

* **Off-chain guard**
  * Consensus of top-tier operators validating automated actions.
  * Provides an extra layer of human and institutional oversight.
* **On-chain guard**
  * Smart session permissions restrict what automations can execute.
  * Whitelisting of protocols ensures assets are only deployed into approved strategies.

Together, these guarantee **security, accountability, and resilience**.

### **User Journeys**

#### 1. **Asset Managers / Curators**

* Use Ditto Execution Engine and ERC-4626 vaults as **building blocks** to design yield strategies.
* Can **set up new vaults** or upgrade existing ones by configuring:
  * Number of loops / target LTV.
  * Strategy parameters (assets and protocols whitelisted).
* Management is simplified through **modular automation shortcuts** for deposits, withdrawals, rebalances, and emergency exits.

#### 2. **End Users**

* Deposit into vaults.
* Monitor balance, APY, liquidation thresholds, and vault activity through the dashboard.
* Withdraw via the queue mechanism, with full transparency on status and timing.

### **Future Availability**

Currently, Ditto offers **custom private vaults** built in collaboration with selected partners during the **alpha phase**.

After alpha:

* The **Ditto Validator Module** and **Ditto Automation Vault framework** will be opened to **curators and asset managers**.
* This will allow the wider community to **deploy their own strategies** on top of Ditto’s infrastructure.
* Curators will leverage the same automation stack (activator, deactivator, rebalance, compounding, guards) with **plug-and-play tools**.

## Math

#### Theory

$$
\begin{aligned}&\textbf{Parameters:} \\\[4pt]\&P\_0 \quad \text{(initial principal)} \ \&r\_s \quad \text{(supply APY)} \ \&r\_b \quad \text{(borrow APY)} \ &\ell \quad \text{(loan-to-value ratio)} \ \&n \quad \text{(number of loops)} \\\[12pt]
&\textbf{Loop Dynamics:} \\\[4pt]\&S\_k = P\_0 \cdot \ell^{,k-1}, \quad (k=1,2,\dots) \ \&B\_k = P\_0 \cdot \ell^{,k} \ &\Pi^{\text{sup}}\_k = r\_s \cdot S\_k \ \&C^{\text{bor}}*k = r\_b \cdot B\_k \ &\Pi\_k = \Pi^{\text{sup}}*k - C^{\text{bor}}*k = S\_k ,(r\_s - \ell r\_b) \\\[12pt]
&\textbf{Cumulative Profit:} \\\[4pt]&\Pi*{1:n} = P\_0 ,(r\_s - \ell r\_b),\frac{1-\ell^n}{1-\ell} \\\[12pt]
&\textbf{Final APY:} \\\[4pt]&\mathrm{APY}*n = \frac{\Pi*{1:n}}{P\_0}= (r\_s - \ell r\_b),\frac{1-\ell^n}{1-\ell} \\\[12pt]
&\textbf{“Finish (no borrow)” Variant:} \\\[4pt]&\Pi^{\text{finish}}*{1:n}= \frac{P\_0}{1-\ell}\Big\[r\_s,(1-\ell^{,n+1}) - r\_b\ell,(1-\ell^n)\Big] \\\[6pt]&\mathrm{APY}^{\text{finish}}*n= \frac{\Pi^{\text{finish}}*{1:n}}{P\_0}= \frac{r\_s(1-\ell^{,n+1}) - r\_b\ell(1-\ell^n)}{1-\ell} \\\[12pt]
&\textbf{Theoretical Maximum:} \\\[4pt]&\lim*{n\to\infty} \mathrm{APY}*n= \lim*{n\to\infty} \mathrm{APY}^{\text{finish}}\_n= \frac{r\_s - \ell r\_b}{1-\ell}\end{aligned}
$$

### Looping vs Flashloan:

* Take deposit + flashloan = max looped supply
* Borrow max loop borrow amount when boost < threshhold
* Repay flashloan and lose 0.05% on Aave v3 so direct looping is recommended.

### Total supply

$$
\textbf{Total Supply (as $n \to \infty$):} \\\[6pt]
S\_{\text{total},\infty}
\= \lim\_{n \to \infty} P\_0 ,\frac{1-\ell^{,n}}{1-\ell}
\= \frac{P\_0}{1-\ell}
$$

### Total borrow

$$
\textbf{Total Borrow (as $n \to \infty$):} \\\[6pt]
B\_{\text{total},\infty}
\= \lim\_{n \to \infty} P\_0 ,\frac{\ell,(1-\ell^{,n})}{1-\ell}
\= \frac{P\_0 ,\ell}{1-\ell}
$$

## **Core Features**

**1. Automated Liquidity Activation**

* Deposits from users enter a liquidity queue.
* Once the queue surpasses a defined threshold ($10,000), the Ditto Execution Engine automatically:
  * Activates the queued liquidity.
  * Allocates it into the respective strategy loops.
  * Updates the vault state with new locked amounts.

**2. Withdrawal Queue**

* Users can initiate withdrawals through the vault portal.
* Withdrawals are placed in a queue system.
* Once the withdrawal threshold is reached, the Ditto Execution Engine executes asset deactivation, releasing the necessary liquidity.
* Users see:
  * Their individual withdrawal request status.
  * The total withdrawal queue.
  * Estimated execution timeline.

**3. Ditto Execution Engine Automations**

The Ditto Execution Engine powers all operational aspects of the vaults:

* Asset Activation: moving deposits into strategies once thresholds are hit.
* Autocompounding: reinvesting strategy rewards to maximize APY.
* Emergency Unlooping: exit strategy operation in case of critical events.
* Asset Deactivation: processing withdrawal queues by freeing liquidity.

**4. Transparent Manager Dashboard**

The portal provides full visibility into vault activity, risk exposure, and user balances:

* Current APY per vault.
* Amount of funds locked in strategies.
* Liquidation thresholds and their current status.
* Latest rebalances and strategy operations.
* Auto-compounds and activations history.
* Latest withdrawals processed.
* Real-time withdrawal status and queue insights.

## **User journey**

1. Deposit:
   * User selects a vault.
   * Deposit is added to liquidity queue.
   * User claims his shares.
2. Activation:
   * When the queue threshold is reached, assets are looped into the chosen strategy.
3. Growth:
   * Rewards are autocompounded by the Ditto Execution Engine.
   * Users track APY, activations, and portfolio performance through the portal.
4. Withdrawal:
   * User requests withdrawal via the portal.
   * Request enters the withdrawal queue.
   * Once the threshold is reached, assets are deactivated and released.
   * User monitors live withdrawal progress until assets are received.

## **Value Proposition**

* Automated yield optimization without user intervention.
* Flexible risk exposure through configurable vault strategies (risk parameter - `target` **`LTV`**).
* Transparency-first design: all operations, queues, and thresholds are visible to users.
* Secure withdrawal mechanism with clear expectations.
* Failsafe management via emergency unlooping powered by the Ditto Execution Engine.


# Auto Rebalancing

Automate yield optimization for multiple predefined strategies .

#### **Objective**

The **Auto Rebalancing Strategy** automates yield optimization across multiple predefined strategies — each representing a specific capital deployment method such as lending, LP farming, leveraged looping, or vault aggregation.

It continuously:

* **Activates pending deposits** into the most profitable strategy.
* **Rebalances or deactivates** positions when better yields are found or performance declines.
* **Processes withdrawals** safely by prioritizing liquidity sources to minimize friction.
* **Maintains tokenized vault interoperability** via [**ERC-4626**](https://docs.openzeppelin.com/contracts/5.x/erc4626) and [**ERC-7540**](https://eips.ethereum.org/EIPS/eip-7540) standards

***

### **1. Automation Overview**

#### **Trigger**

* **Frequency:** Every 1 hour (Cron)
* **Data fetched:**
  * Current and historical APYs per strategy
  * TVL and liquidity
  * Historical volatility metrics
  * Transaction costs (gas, slippage)

***

### **2. Opportunity Discovery**

Each **strategy** is a predefined configuration (asset pair, protocol, or vault).\
The rebalancing process evaluates all strategies to find the **best net yield** after accounting for risks and costs.

For each strategy:

1. Fetch performance metrics:
   * `supplyAPY`, `borrowAPY` (if relevant)
   * `TVL`, `liquidity`, `volatility`, `fees`
2. Compute **Net APY**:\
   $$APY\_{\text{net}} = APY\_{\text{gross}} - \left( C\_{\text{gas}} + C\_{\text{slippage}} + C\_{\text{fee}} \right)$$<br>
3. Store opportunities with all metadata for guard evaluation.

***

### **3. Independent Guard Checks**

Each candidate opportunity passes through independent guard checks before being eligible for activation or rebalancing.

Each guard can be toggled or weighted differently depending on strategy type.

* **Minimum Pending Amount**\
  Avoid activating small deposits.\
  *Example:* `pendingAssets ≥ 5000`
* **APY Improvement**\
  Ensure yield gain exceeds the threshold.\
  *Example:* `ΔAPY ≥ 0.2%`
* **APY Stability**\
  Avoid pools or vaults with volatile APYs.\
  *Example:* `volatility ≤ 0.5%`
* **Profit vs Gas**\
  Rebalance only if expected profit exceeds gas costs.\
  *Example:* `(ΔAPY × balance × freqEst) > gasCost`
* **Slippage Profitability**\
  Require at least 10 days of additional yield to offset slippage.\
  *Example:* `10-day profit > slippageCost`
* **TVL Capacity**\
  Limit exposure to small or illiquid pools.\
  *Example:* `strategyTVL × maxShare = vaultLimit`
* **TVL Stability**\
  Ensure liquidity is stable and not fluctuating excessively.\
  *Example:* `stdev(TVL)/mean(TVL) < 0.1`

***

### **4. Decision Engine**

The automation evaluates all eligible opportunities and selects the one with the **highest net APY** that passes all guards.

```python
best_opportunity = None

for opp in opportunities:
    if not check_apy_boost(opp.apy, currentAPY): continue
    if not check_apy_stability(opp.historicalAPY): continue
    if not check_profit_vs_gas(opp.apy, currentAPY, balance, freqEst, gasCost): continue
    if not check_slippage(opp.apy, currentAPY, balance, opp.slippageCost): continue
    if not check_tvl_capacity(opp.totalSupply, opp.poolTVL): continue
    if not check_tvl_stability(opp.historicalTVL): continue

    if not best_opportunity or opp.apy > best_opportunity.apy:
        best_opportunity = opp
```

***

### **5. Execution Logic**

| Condition                              | Action                                                  |
| -------------------------------------- | ------------------------------------------------------- |
| **Better strategy found**              | `IStrategy.rebalance()` into target strategy            |
| **No better yield & current APY < 0**  | `IStrategy.deactivate()` or shift to a safe asset       |
| **Pending deposits ≥ MIN\_ACTIVATION** | `IStrategy.activate()` (enter current or best strategy) |
| **Otherwise**                          | No action (wait for next cycle)                         |

***

### **6. Strategy Interface**

Every strategy integrates with the **Automation Controller** via a unified interface.\
This allows the rebalancer to manage any strategy type through standardized calls.

```solidity
interface IStrategy {
    function activate(bytes calldata params) external;
    function deactivate(bytes calldata params) external;
    function rebalance(bytes calldata oldParams, bytes calldata newParams) external;
    function getCurrentYield() external view returns (uint256);
    function getExpectedYield(bytes calldata params) external view returns (uint256);
    function getTVL() external view returns (uint256);
}
```

> Implementations of `IStrategy` may wrap looping, LP vaults, money markets, or any structured yield product.

***

### **7. Withdrawal Automation**

Withdrawals follow a prioritized flow to minimize capital movement:

1. **Pending Deposits First**\
   Serve withdrawal requests from unactivated deposits (instant runtime match).
2. **Idle Liquidity Second**\
   If insufficient, use liquidity already in the **redeemVault**.
3. **Deactivation (Last Resort)**\
   If the above sources can’t satisfy withdrawals, call\
   `IStrategy.deactivate()` to unwind positions and release liquidity.

This creates a **natural netting effect** between new deposits and redemptions.

***

### **8. Risk Framework**

* Yield improvement threshold (≥0.2%)
* APY stability filters
* Gas and slippage profitability guards
* TVL capacity and liquidity stability
* Minimum activation size
* Auto deactivation if APY < 0

All checks operate independently and can be updated without redeploying strategy contracts.

***

### **9. Yield Comparison Model**

To compare yields across heterogeneous strategies, normalize all metrics to a **net annualized APY**:

$$
APY\_{\text{net}} = APY\_{\text{strategy}} - C\_{\text{gas}} - C\_{\text{slippage}} - C\_{\text{risk}}
$$

A rebalance is triggered when:

$$
\Delta APY = APY\_{\text{net,new}} - APY\_{\text{net,current}}
$$

***

### **10. Rebalance Flow**

1. Detect better opportunity (ΔAPY > threshold).
2. Validate all guard checks.
3. Execute:

   ```solidity
   IStrategy.rebalance(oldParams, newParams);
   ```
4. Rebalance transaction redistributes capital from the underperforming strategy to the target one.
5. Updated positions are stored in the Automation Controller state.

***

#### **Key Takeaway**

The **Auto Rebalancing Strategy** acts as a **universal yield optimizer** for any **ERC-4626 or ERC-7540-compatible vault**, using **Ditto’s secure automation** to maximize returns while maintaining safety and composability.

It provides a unified framework for automated capital deployment, rebalancing, and withdrawals — built for reliability, modularity, and cross-protocol interoperability.


# Node Operator Onboarding

The following outlines the process for onboarding as an operator to start executing at Ditto Network.

### 1. Wallet Setup

Create a new Ethereum Externally Owned Account (EOA) or multisig wallet to use as your operator identity.

{% hint style="info" %}
Operators must generate a new wallet for each new delegator they receive stake from. Addresses cannot be changed after deployment. For best practices, we recommend using a multisig for this address.
{% endhint %}

### 2. Register with a Shared Security Provider of your choice

**Network/AVS address: `0x4a49d2E53B33a4D50024B99B4fA159041367E55D`**

Ditto Network supports:

{% tabs %}
{% tab title="Symbiotic" %}
👉 [Ditto on Symbiotic](https://app.symbiotic.fi/network/0x4a49d2E53B33a4D50024B99B4fA159041367E55D)

Symbiotic is a shared security protocol designed to create a marketplace for economic security. It enables networks that need security to access it from those who have assets to stake, creating an efficient ecosystem where stake can be shared and utilized across multiple networks.

To participate as an operator for Ditto, **if you’re not registered yet**:

Register as a Symbiotic Operator using this [guide](https://docs.symbiotic.fi/handbooks/operators-handbook/).
{% endtab %}

{% tab title="EigenLayer" %}
👉 [Ditto on EigenLayer](https://app.eigenlayer.xyz/avs/0x4a49d2E53B33a4D50024B99B4fA159041367E55D/)

EigenLayer enables **restaking**, allowing ETH and LST holders to re-stake their assets to secure new decentralized services (AVSs). Ditto leverages this to provide shared Ethereum security for its automation engine, without bootstrapping a separate validator set.

To participate as an operator for Ditto, **if you’re not registered yet**:

Register as an EigenLayer Operator using the [EigenLayer registration assistant from Othentic](https://docs.othentic.xyz/main/user-guide/operator-management/register-to-eigenlayer),  then [deposit your stake](https://docs.othentic.xyz/main/user-guide/operator-management/deposit-stake) to participate in consensus.
{% endtab %}
{% endtabs %}

### 3. Whitelisting

The Ditto Runner Node (DRN) is a backend service that indexes registered and executed workflows, stores them in a local database, retrieves workflow metadata from IPFS, and simulates active workflows.

Before running the node, each operator must be whitelisted. Please join the [Telegram group](https://t.me/+_zH57wUkqsIzYmYy) and provide your simulator and operator addresses in the following [google form](https://forms.gle/iQcGKtY7wq66Dnxg6).

* Simulator address: Generate a new EOA private and public key **(save them!)**. Fill this field with the generated **address**.
* Operator address: This is the address that holds the delegated stake on Symbiotic/EigenLayer.

This step is required to enable operations and reporting. Failure to complete it will prevent the node from functioning properly in the live environment.

### 4. Registering operator to othentic stack

**Install** [**Othentic CLI**](https://docs.othentic.xyz/main/reference/othentic-cli)**:**&#x20;

Verify that you have Node.js version `22.6.0` installed by running:

```sh
nvm use 22.6
node -v # Should output: v22.6.0
pnpm add -g @othentic/cli:v1.1.5
otcli -V # Should output: 1.1.5
```

```sh
otcli operator register --l1-chain mainnet --browser-sign 
```

* AVS Governance address: `0x4a49d2E53B33a4D50024B99B4fA159041367E55D`
* Enter your consensus private key: {It should match the private key of the [simulator address](#id-3.-whitelisting)}
* Rewards Receiver address (default: msg.sender): {As you wish}

Then on opened window connect to your Safe via Wallet Connect or to EOA wallet via any suggested way.

Then choice your staking provider in the CLI.

Then follow the instructions.

> **For Safe users:** if you encounter errors while signing a transaction, use the Safe UI transaction builder with the custom data provided. Send a transaction to the AVS Governance address using the data suggested by the Othentic UI.

### 5. Running the DRN

#### Prerequisites

**Hardware**

To ensure stable performance, we recommend running the software on an instance with at least the following specifications:

Instance type: Equivalent to AWS [t3a.medium](https://costcalc.cloudoptimo.com/aws-pricing-calculator/ec2/t3a.medium) (2 vCPUs, 4 GB RAM) Storage: 20 GB or more (SSD recommended)

**Software**

Before you begin, ensure that you have the following installed on your system:

* [Docker](https://docs.docker.com/get-docker/)
* [Docker Compose](https://docs.docker.com/compose/install/)
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
* [Make](https://www.gnu.org/software/make/) (optional, but recommended for using the provided commands)

#### 1. Clone DRN repository

```sh
git clone https://github.com/dittonetwork/ditto-runner-node.git
cd ditto-runner-node
```

#### 2. Configure Environment Variables

Create a file named `.env` and add the following critical variables. These are **required** for the node to operate.

```sh
EXECUTOR_PRIVATE_KEY=...
# Mainnet
RPC_URL_1=...
# Polygon
RPC_URL_137=...
# Base
RPC_URL_8453=...
# Arbitrum
RPC_URL_42161=...
```

`EXECUTOR_PRIVATE_KEY` — Consensus private key from [#id-4.-registering-operator-to-othentic-stack](#id-4.-registering-operator-to-othentic-stack "mention")

#### 3. Run the Setup Command

```sh
make up
```

After this, you are ready to go.

#### 4. Monitor node

```sh
make logs
```


# Loyalty Points

For users, restakers, vault managers, operators and external partners.

> Ditto Network is launching a Loyalty Points Program to reward early adopters, incentivize vault curators, and align stakeholder participation with the growth of the Ditto ecosystem. These points will eventually be converted into Ditto tokens upon token generation. The program incentivizes stake delegation into Ditto’s infrastructure, particularly through restaking protocols like Symbiotic and EigenLayer.

[**Points Portal** ](https://portal.dittonetwork.io/)**is live. You can check your current points status through the Ditto UI or directly via the Symbiotic UI.**

### Loyalty Points Logic for Vault Participants

#### Formula:

Loyalty Points are calculated hourly based on the following formula:

$$
\text{Loyalty Points} = \text{USD Collateral Amount} \times 0.0025 \times \text{Elapsed Hours} \times \text{Vault Multiplier}
$$

#### Key Components:

1. **Stake Delegation to Vaults:**
   * Users receive Loyalty Points for every dollar of collateral staked in Ditto-compatible vaults (e.g., Symbiotic-supported vaults).
   * Points accrue hourly, rewarding long-term staking and commitment.
2. **Vault Multipliers:**
   * **Symbiotic Vaults:** A base multiplier of 1.0x is applied if the entire vault’s stake is delegated to the Ditto Network. For example, if a vault has delegated $50M but has a total LRT value of $100M, the multiplier will be 0.5x.
   * Special promotions may include additional seasonal multipliers to attract more liquidity.
3. **Early Depositor Bonuses:**
   * Loyalty Points are updated hourly and displayed in real-time on the Ditto Rewards Dashboard.

#### Example Calculation:

A user stakes **$10,000** in a vault that is fully delegated into the Ditto Network for **72 hours**.

$$
\text{Loyalty Points} = $10{,}000 \times 0.0025 \times 72 \times 1.0 = 1800 \text{ Loyalty Points}
$$

### Loyalty Points Logic for Vault Curators

Vault curators act as intermediaries, managing liquidity allocation and optimizing staking strategies. Curators will be rewarded with Loyalty Points for their contributions, further aligning their interests with the success of the Ditto Network.

#### Benefits of Loyalty Points for Curators:

* **Enhanced Profitability:** Makes curating vaults more attractive by supplementing fee-based income.
* **Governance Alignment:** Loyalty Points will grant curators influence in future governance decisions.

### Loyalty Points Rules and Conditions

1. **Gaming Prevention:**
   * Users attempting to game the system by withdrawing and redepositing the same funds for double-counting points will have their multipliers reduced or points voided.
   * Loyalty Points are tied to sustained participation and cannot be accrued through wash staking.
2. **Eligibility:**
   * Users must hold a position for a minimum of **2 days** in a vault to qualify for Loyalty Points.
   * Points are only calculated for collateral that remains staked during the relevant period.

### Final Notes

* The Ditto Loyalty Points Program is designed to reward long-term participation, incentivize early adoption, and align all stakeholders with the network’s success.
* Points mechanics will be governed by Ditto’s smart contracts to ensure transparency and fairness.

### Access via API (for partners)

You can extract Loyalty Points data through our API using the provided specifications. This allows developers and analysts to access and integrate points information into their systems seamlessly. For detailed API documentation and endpoints, please refer to our [Portal API Documentation](https://api.dittonetwork.io/api/docs/?urls.primaryname=portal\&urls.primaryName=Portal).


# Workflow Quickstart

Use Metamask to create scheduled operation


# Terms and Conditions

Last modified: August 15, 2025

Welcome to [dittonetwork.io](http://dittonetwork.io) ("we," "us," or "our"), the informational resource for Ditto Network, as defined below.

These Terms and Conditions and any other documents incorporated herein by reference (collectively, these "Terms") to you or the company or other legal entity you represent ("you" or "your") explains the terms and conditions by which you may access [dittonetwork.io](http://dittonetwork.io) ("the Site") and [app.dittonetwork.io](http://app.dittonetwork.io) ("the Interface"). Please do not use the Site or Interface if you disagree with any of these Terms.

#### **1. USE OF THE SITE AND THE INTERFACE**

The [dittonetwork.io](http://dittonetwork.io) website is for informational purposes only.

[dittonetwork.io](http://dittonetwork.io) is not part of any transaction on the blockchain networks underlying the Ditto Network; we do not have possession, custody, or control over any crypto assets appearing on the Interface; and we do not have possession, custody, or control over any user's funds. Further, we do not store, send, or receive any crypto assets. You understand that when you interact with any Ditto Network smart contracts, you always retain control over your crypto assets. We do not have access to your private keys.

* 1.1. As a condition to accessing or using the Site or Interface, you represent and warrant to [dittonetwork.io](http://dittonetwork.io) the following:
  * 1.1.1. If you are an individual person, then you are of legal age in the jurisdiction in which you reside, and you have the legal capacity to enter into these Terms and be bound by them;
  * 1.1.2. If you are an entity, then you must have the legal authority to accept these Terms on that entity's behalf, in which case "you" (except as used in this paragraph) will mean that entity;
  * 1.1.3. You are not a U.S. Person;
  * 1.1.4. You are not a resident, national, or agent of any country to which the United States, the United Kingdom, or the European Union embargoes goods or imposes similar sanctions (collectively, "Restricted Territories");
  * 1.1.5. You are not subject to economic or trade sanctions administered or enforced by any governmental authority; or otherwise, you are not a member of any sanctions list or equivalent maintained by the United States government, the United Kingdom government, the European Union, or the United Nations, including without limitation the U.S. Office of Foreign Asset Control Specifically Designated Nationals and Blocked Person List (collectively, "Sanctions Lists Persons");
  * 1.1.6. You do intend to transact with any Restricted Person or Sanctions List Person;
  * 1.1.7. You do not, and will not, use VPN software or any other privacy or anonymization tools or techniques, or other means, to circumvent, or attempt to circumvent, any restrictions that apply; and
  * 1.1.8. Your access is not (a) prohibited by and does not otherwise violate or assist you in violating any domestic or foreign law, rule, statute, regulation, by-law, order, protocol, code, decree, letter, or another directive, requirement, guidance, or guideline, published or in force that applies to or is otherwise intended to govern or regulate any person, property, transaction, activity, event or other matter, including any rule, letter, order, judgment, directive or other requirements, guidance, or guideline issued by any domestic or foreign federal, provincial or state, municipal, local or other governmental, regulatory, judicial or administrative authority having jurisdiction over [dittonetwork.io](http://dittonetwork.io) or you as otherwise duly enacted, enforceable by law, the common law or equity (collectively, "Applicable Laws"); or (b) contribute to or facilitate any illegal activity.
* 1.2. As a condition to accessing or using the Site or the Interface, you acknowledge, understand, and agree to the following:
  * 1.2.1. From time to time, the Site or the Interface may be inaccessible or inoperable for any reason, including, but not limited to: (a) equipment malfunctions; (b) periodic maintenance procedures or repairs that [dittonetwork.io](http://dittonetwork.io) or any of its suppliers or contractors may undertake from time to time; (c) causes beyond [dittonetwork.io](http://dittonetwork.io)'s control or that [dittonetwork.io](http://dittonetwork.io) could not reasonably foresee; (d) disruptions and temporary or permanent unavailability of underlying blockchain infrastructure; or (e) unavailability of third-party service providers or external partners for any reason;
  * 1.2.2. We reserve the right to disable or modify access to the Site at any time in the event of any breach of these Terms, including, without limitation, if we reasonably believe any of your representations and warranties may be untrue or inaccurate, and we will not be liable to you for any losses or damages you may suffer as a result of or in connection with the Site or the Interface being inaccessible to you at any time or for any reason;
  * 1.2.3. The Interface may evolve, which means third parties may apply changes, replace, or discontinue (temporarily or permanently) the access at any time in their sole discretion;
  * 1.2.4. The pricing information provided on the Site or the Interface does not represent an offer, a solicitation of an offer, or any advice regarding, or recommendation to enter into, a transaction with [dittonetwork.io](http://dittonetwork.io);
  * 1.2.5. [dittonetwork.io](http://dittonetwork.io) does not act as a broker or advisor for you;
  * 1.2.6. You are solely responsible for your use of the Site or the Interface, including all of your transfers of digital assets;
  * 1.2.7. To the fullest not prohibited by Applicable Law, we owe no fiduciary duties or liabilities to you or any other party, and that to the extent any such duties or liabilities may exist at law or in equity, you hereby irrevocably disclaim, waive, and eliminate those duties and liabilities;
  * 1.2.8. You are solely responsible for reporting and paying any taxes applicable to your use of the Interface; and
  * 1.2.9. We have no control over, or liability for, the delivery, quality, safety, legality, or any other aspect of any digital assets that you may transfer to or from a third party, and we are not responsible for ensuring that an entity with whom you transact completes the transaction or is authorized to do so. If you experience a problem with any transactions in digital assets using the Site or the Interface, you bear the entire risk.

#### **2. FEES**

You are required to pay all fees for transactions involving certain blockchain networks. These fees may include gas costs and all other fees reflected on the Interface at your use, including trading-related fees. [dittonetwork.io](http://dittonetwork.io) does not receive fees for any blockchain transactions or using the Site or the Interface.

#### **3. NO PROFESSIONAL ADVICE OR FIDUCIARY DUTIES**

Nothing herein constitutes legal, financial, business, or tax advice, and you are strongly advised to consult an advisor(s) before engaging in any activity in connection herewith. All information provided by the Site is for informational purposes only and should not be construed as professional advice. You should not take, or refrain from taking, any action based on any information contained on the Site or any other information that we make available at any time, including, without limitation, blog posts, articles, links to third-party content, discord content, news feeds, tutorials, tweets, and videos. The Terms are not intended to, and do not, create or impose any fiduciary duties on us.

#### **4. PROPRIETARY RIGHT**

* 4.1. [dittonetwork.io](http://dittonetwork.io) own all rights, names, logos, and other marks used on the Site and the Interface, including, without limitation, any copyrights in and to any content, code, data, or other materials that you may access or use on or through the Site or the Interface; however, the code for the Ditto Network and the Interface ([app.dittonetwork.io](http://app.dittonetwork.io)) deployed on IPFS is open-sourced. Except as expressly set forth herein, your use of or access to the Site or the Interface does not grant you any ownership or other rights therein.
* 4.2. [dittonetwork.io](http://dittonetwork.io) may use and share your comments, bug reports, ideas, or other feedback that you may provide, including suggestions about how we might improve. You agree that [dittonetwork.io](http://dittonetwork.io) is free to use or not use any feedback we receive from you as we see fit, including copying and sharing such feedback with third parties, without any obligation to you.

#### **5. MODIFICATION, SUSPENSION, AND TERMINATION**

* 5.1. [dittonetwork.io](http://dittonetwork.io) reserve the right, at our sole discretion, from time to time and with or without prior notice to you, to modify, suspend or disable (temporarily or permanently) the Site or our subdomain to the Interface, in whole or in part, for any reason whatsoever, including, without limitation. Upon termination of your access, your right to use the Site or the Interface from our subdomain will immediately cease. However, it would still be accessible via a third party since we do not host or own its code. [dittonetwork.io](http://dittonetwork.io) will not be liable for any losses suffered by you resulting from any modification to the Site or the Interface or from any modification, suspension, or termination, for any reason, of your access to all or any portion of the Site or the Interface.
* 5.2. [dittonetwork.io](http://dittonetwork.io) may revise these Terms from time to time. We will notify you by updating the date at the top of the Terms and maintaining a current version. The most current version of the Terms will always be at <https://dittonetwork.io/#/terms-and-conditions>. All modifications will be effective when they are posted. By continuing to access or use the Site or the Interface after those revisions become effective, you agree to be bound by the revised Terms.

#### **6. RISKS**

* 6.1. The use of technology related to blockchain, smart contracts, and cryptocurrencies, among others, entails a risk that by accessing transactions, you are assuming. [dittonetwork.io](http://dittonetwork.io) does not own or control any underlying software through which blockchain networks are formed. The software underlying blockchain networks are open-source so anyone can use, copy, modify, and distribute it. By using the Interface, you acknowledge and agree:
  * 6.1.1. That [dittonetwork.io](http://dittonetwork.io) is not responsible for the operation of the open-source software and networks underlying the Interface;
  * 6.1.2. That there exists no guarantee of the functionality, security, or availability of that software and networks; and
  * 6.1.3. That the underlying networks are subject to sudden changes in operating rules, such as those commonly referred to as "forks," which may materially affect the Interface. You are responsible for securing your private key(s). We do not have access to your private key(s); losing control of your private key(s) will permanently and irreversibly deny you access to any blockchain-based network. Neither [dittonetwork.io](http://dittonetwork.io) nor any other person or entity will be able to retrieve or protect your digital assets. If your private key(s) are lost, you will not be able to transfer your digital assets to any blockchain address or wallet. If this occurs, you will not be able to realize any value or utility from the digital assets you may hold.
* 6.2. [dittonetwork.io](http://dittonetwork.io) is not responsible for the content of any third party, including, but not limited to, information, materials, products, or services that [dittonetwork.io](http://dittonetwork.io) does not own or control. In addition, third parties may offer promotions related to your access and use of the Interface. [dittonetwork.io](http://dittonetwork.io) does not endorse or assume any responsibility for such resources or promotions. Suppose you access any such resources or participate in any such promotions. In that case, you do so at your own risk and understand that these Terms do not apply to your dealings or relationships with any third parties. You expressly relieve [dittonetwork.io](http://dittonetwork.io) of all liability arising from using such resources or participating in such promotions.
* 6.3. You understand that the Ethereum, Polygon and Arbitrum blockchains remain under development, which creates technological and security risks when using the Interface, in addition to uncertainty relating to digital assets and transactions therein. You acknowledge that the cost of transacting onEthereum, Polygon and Arbitrum blockchains are variable and may increase at any time, causing an impact on any activities taking place on these blockchains, which may result in price fluctuations or increased costs when using the Interface.
* 6.4. Transactions entered into in connection with the Interface are irreversible and final, and there are no refunds. You acknowledge and agree that you will access and use the Interface at your own risk.
* 6.5. We must comply with Applicable Law, which may require us to, upon request by government agencies, take certain actions or provide information that may not be in your best interests.
* 6.6. You hereby assume and agree that [dittonetwork.io](http://dittonetwork.io) will have no responsibility or liability for the risks in Section 9. You hereby irrevocably waive, release and discharge all claims, whether known or unknown to you, against [dittonetwork.io](http://dittonetwork.io), its affiliates, and their respective shareholders, members, directors, officers, employees, agents, representatives, suppliers, and contractors related to any of the risks set forth in this Section 6.

#### **7. PROHIBITED USES**

* 7.1 You agree not to engage in the prohibited uses set forth below. The specific activities set forth below are representative but not exhaustive. By using the Site or the Interface, you confirm that you will not do any of the following:
  * 7.1.1. Promote or facilitate illegal activities, including but not limited to money laundering, terrorist financing, tax evasion, buying or selling illegal drugs, contraband, counterfeit goods, or illegal weapons;
  * 7.1.2. Engage in transactions involving items that infringe or violate any copyright, trademark, right of publicity, privacy, or any other proprietary right of [dittonetwork.io](http://dittonetwork.io);
  * 7.1.3. Engage in improper or abusive trading practices, including but not limited to (a) any fraudulent act or scheme to defraud, deceive, trick, or mislead; (b) trading ahead of another user of the Site or the Interface or front-running; (c) fraudulent trading; (d) accommodation trading; (e) fictitious transactions; (f) pre-arranged or non-competitive transactions; or (g) cornering;
  * 7.1.4. Uploading or transmitting viruses, worms, Trojan horses, time bombs, cancelbots, spiders, malware, or any other type of malicious code that will or may be used in any way that will affect the functionality or operation of the Site or the Interface;
  * 7.1.5. Use the Site or Interface in any way that is, in our sole discretion, libelous, defamatory, profane, obscene, pornographic, sexually explicit, indecent, lewd, vulgar, suggestive, harassing, stalking, hateful, threatening, offensive, discriminatory, bigoted, abusive, inflammatory, fraudulent, deceptive, or otherwise objectionable or likely or intended to incite, threaten, facilitate, promote, or encourage hate, racial intolerance, or violent acts against others;
  * 7.1.6. Harass, abuse, or harm another person or entity, including [dittonetwork.io](http://dittonetwork.io)'s collaborator and service providers;
  * 7.1.7. Impersonate another user of the Site or the Interface or otherwise misrepresent yourself; or
  * 7.1.8. Engage or attempt to engage or encourage, induce or assist any third party, or yourself attempt, to engage in any of the activities prohibited under this Section 4 or any other provision of these Terms.

#### **8. DISCLOSURES; DISCLAIMERS**

[dittonetwork.io](http://dittonetwork.io) is an informational site for the Ditto Netowrk. [dittonetwork.io](http://dittonetwork.io) does not operate an exchange platform or offer trade execution or clearing services and has no oversight, involvement, or control concerning your transactions using the Interface. All transactions between users of the Interface are executed peer-to-peer directly between the users' blockchain addresses through a third-party developed open-source smart contract.

You understand that [dittonetwork.io](http://dittonetwork.io) is not registered or licensed by any regulatory agency or authority. No such agency or authority has reviewed or approved the use of the Site or the Interface.

You agree that the Site and the Interface are provided on an "AS IS" and "AS AVAILABLE" basis. [dittonetwork.io](http://dittonetwork.io) makes no guarantees of any kind or connection with the Site or the Interface.

#### **9. LIMITATION OF LIABILITY**

In no event shall [dittonetwork.io](http://dittonetwork.io), its affiliates, its suppliers and contractors, and its affiliates', suppliers' and contractors' respective stockholders, members, directors, officers, managers, employees, attorneys, agents, representatives, suppliers, and contractors shall be liable for any direct, indirect, incidental, special, punitive, consequential or similar damages or liabilities whatsoever (including, without limitation, damages for loss of fiat, assets, data, information, revenue, opportunities, use, goodwill, profits or other business or financial benefit) arising out of or in connection with the Site or the Interface, or other item provided by or on behalf of [dittonetwork.io](http://dittonetwork.io), whether under contract, tort (including negligence), civil liability, statute, strict liability, breach of warranties, or under any other theory of liability, and whether or not we have been advised of, knew of or should have known of the possibility of such damages and notwithstanding any failure of the essential purpose of these Terms or any limited remedy hereunder nor is [dittonetwork.io](http://dittonetwork.io) in any way responsible for the execution or settlement of transactions between users of the Interface.

In no event shall [dittonetwork.io](http://dittonetwork.io)'s aggregate liability arising out of or in connection with the Site or Interface exceed one thousand US Dollars (1,000.00 USD).

#### **10. INDEMNIFICATION**

You will defend, indemnify, and hold harmless [dittonetwork.io](http://dittonetwork.io), its affiliates, members, member, managers, employees, attorneys, representatives, suppliers, and contractors from any claim, demand, lawsuit, action, proceeding, investigation, liability, damage, loss, cost or expense, including without limitation reasonable attorneys' fees, arising out of or relating to (a) your use of or conduct in connection with the Site or the Interface (b) your violation of these Terms; or (c) your misuse of the Site or the Interface, or any smart contract and/or script related thereto; (d) your violation of any laws, rules, regulations, codes, statutes, ordinances, or orders of any governmental or quasi-governmental authorities; (e) your violation of the rights of any third party, including any intellectual property right, publicity, confidentiality, property, or privacy right; (f) your use of a third-party product, service, and/or website; or (g) any misrepresentation made by you. We reserve the right to assume, at your expense, the exclusive defense, and control of any matter subject to indemnification by you. You agree to cooperate with our defense of any claim. You will not, in any event, settle any claim without.

#### **11. DISPUTE RESOLUTION & ARBITRATION**

[dittonetwork.io](http://dittonetwork.io) will use its best efforts to resolve potential disputes through informal, good faith negotiations. If a potential dispute arises, you must contact us by sending a written notice of your claim ("Notice") to [dittonetwork.io](http://dittonetwork.io) on any of our official channels. The notice must (a) describe the nature and basis of the claim and (b) set forth the specific relief sought. Our notice to you will be similar in form to that described above. If you and [dittonetwork.io](http://dittonetwork.io) cannot reach an agreement to resolve the claim within sixty (60) days of your email, then you and [dittonetwork.io](http://dittonetwork.io) agree to resolve the potential dispute according to the process set forth below.

Any claim arising out of or related to these Terms or the Site or the Interface must be filed within one year after such claim arose; otherwise, the claim is permanently barred, which means that you and [dittonetwork.io](http://dittonetwork.io) will not have the right to assert the claim.

#### **12. GOVERNING LAW**

The interpretation and enforcement of these Terms, and any dispute related to these Terms, the Site, or the Interface, will be governed by and construed and enforced under the laws of the Delaware, as applicable.

#### **13. GENERAL INFORMATION**

* 13.1. Any right or remedy of [dittonetwork.io](http://dittonetwork.io) set forth in these Terms is in addition to, and not in lieu of, any other right or remedy whether described in these Terms, under Applicable Law, at law, or in equity. The failure or delay of [dittonetwork.io](http://dittonetwork.io) in exercising any right, power, or privilege under these Terms shall not operate as a waiver thereof.
* 13.2. The following sections of these Terms will survive any termination of your access to the Site or the Interface, regardless of the reasons for its expiration or termination, in addition to any other provision which by law or by its nature should survive: Sections 3 through 12.
* 13.3. The invalidity or unenforceability of any of these Terms shall not affect the validity or enforceability of any other of these Terms, all of which shall remain in full force and effect.
* 13.4. [dittonetwork.io](http://dittonetwork.io) will have no responsibility or liability for any failure or delay in performance of the Site or the Interface, or any loss or damage that you may incur, due to any circumstance or event beyond our control, including without limitation any flood, extraordinary weather conditions, earthquake, or other act of God, fire, war, insurrection, riot, labor dispute, accident, any law, order regulation, direction, action or request of the government, communications, power failure, or equipment or software malfunction.
* 13.5. You may not assign or transfer any right to use the Site, the Interface, or any of your rights or obligations under these Terms, without our express prior written consent, including by operation of law or in connection with any change of control. We may assign or transfer any or all of our rights or obligations under these Terms, in whole or part, without notice or obtaining your consent or approval.
* 13.6. These Terms contain the entire agreement between you and [dittonetwork.io](http://dittonetwork.io) and supersede all prior and contemporaneous understandings between the parties regarding the Interface and the Site or the Interface.
* 13.7. In the event of any conflict between these Terms and any other agreement you may have with us, these Terms will control unless the other agreement specifically identifies these Terms and declares that the other agreement supersedes these Terms.
* 13.8. You agree that, except as otherwise expressly provided in these Terms, there shall be no third-party beneficiaries to the Terms other than the Indemnified Parties.

#### **CONTACT INFORMATION**

If you have any questions about these Terms, the Site, or the Interface, please get in touch with [dittonetwork.io](http://dittonetwork.io) on any of our official channels or via email - <info@dittonetwork.io>


# Media Kit

{% file src="/files/U58Dw7hbJXI65bVZeVgU" %}

<figure><img src="https://258555021-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0oqis4JDhDSIVRhBEmPf%2Fuploads%2FMYVYNjsBCefmkLGyAFUt%2FLogo%20white.png?alt=media&amp;token=e0bbffec-c17f-45c3-9de2-ba9a446a5157" alt=""><figcaption></figcaption></figure>

<figure><img src="https://258555021-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0oqis4JDhDSIVRhBEmPf%2Fuploads%2Fkq68fmV8yRXXubSQkLUO%2FLogo%20black.png?alt=media&amp;token=dd2072ab-4d2f-4cfb-ad0a-3b7cc15065e1" alt=""><figcaption></figcaption></figure>


# Helpful Links

Twitter (X) - <https://x.com/Ditto_Network>

Website - <https://dittonetwork.io/>

Builder App - <https://app.dittonetwork.io/>

Github - <https://github.com/dittonetwork>

Points Portal - <https://portal.dittonetwork.io/>


