A Unified Intent Model

Arcadia begins with a radical simplification: every piece of application logic can be reframed as the conditional movement of a resource. In fact, Arcadia treats the entire intent layer as a marketplace for resources. A resource may be a fungible or non-fungible asset, a single-use voucher, or even a custom lock over any mutable contract state. Whichever flavor it takes, each resource is represented by a canonical and globally unique MToken address; a registry records where the real token or state lives and how it should be unwrapped on its native domain.

A user expresses a request by signing an Intent an EIP712-compliant struct with two halves. The input half names the srcMToken and srcAmount the author is willing to commit, plus a nonce for replay protection. The output half, an Outcome struct, describes the assets that must be delivered on settlement and fill semantics (exact, minimum, percentage, or range). In plain English an intent reads: “Move the resource I’ve committed, but only finalize if you return exactly what this recipe demands.”

enum OutcomeAssetStructure {
    AnySingle,
    Any,
    All
}

enum FillStructure {
    Exactly,
    Minimum,
    PctFilled,
    ConcreteRange
}

struct Outcome {
    address[] mTokens;
    uint256[] mAmounts;
    OutcomeAssetStructure outcomeAssetStructure;
    FillStructure fillStructure;
}

struct Intent {
    address author;
    uint256 ttl;
    uint256 nonce;
    address srcMToken;
    uint256 srcAmount;
    Outcome outcome;
}

Predicate-Based Settlement Conditions

Settlement is gated by predicate guards. Whereas a traditional limit order relies on a single condition (“price ≥ 2000”), Arcadia’s guard can be an arbitrary boolean expression whose atoms are verifiable facts on exchange of assets. The predicate expressions are evaluated at settlement time; if they return true, the transaction proceeds, otherwise it reverts, preserving the intuitive safety guarantees of a limit order while vastly expanding expressiveness.

enum OutType {
    Intent,
    Receipt
}

struct OutputIdx {
    OutType outType;
    uint64 outIdx;
}

struct MoveRecord {
    uint64 srcIdx;
    OutputIdx outputIdx;
    uint256 qty;
}

struct FillRecord {
    uint64 inIdx;
    uint64 outIdx;
    OutType outType;
}

struct Solution {
    bytes32[] intentIds;
    Intent[] intentOutputs;
    Receipt[] receiptOutputs;
    MoveRecord[] spendGraph;
    FillRecord[] fillGraph;
}

By casting every operation as conditional trading of resources, Arcadia keeps its protocol surface compact enough to audit formally, enforces linear consumption of MTokens to prevent double-spends, and collapses swaps, loans, liquidations, and cross-chain claims into the same signed trade template. Developers can compose intents like lego blocks; solvers can discover, match and atomically settle multiple intents; users retain the familiar mental model of limit orders, and all actors can interoperate automatically without bespoke adapters.