bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 4쪽 중 2쪽
of our choices for different deployments inSec-
tion 5: Applications.
5.1 Nodes and network layer
The architectural topology of Anoma operates on a
substrate of networked Turing machines, which we
refer to asnodes. Nodes may take on different oper-
ationalroles, such as gossiping intents, searching for
solutions, and voting in consensus. Although different
roles will have different hardware requirements, nodes
are a single class and runtime configuration settings
determine which roles a node performs.
All nodes compute deterministically, with the ability
to generate local randomness (which may be used,
for example, as secret values in cryptography) and
have read and write access to local storage. The
set of nodes is unbounded and dynamic with nodes
entering and exiting at any times. Nodes are partially
connected on an open network, where different roles
require different connections. The network layer is
assumed to be unreliable (messages may be arbitrarily
dropped, duplicated, or reordered) and untrustworthy
(unencrypted data is not secret). Specific roles may
have more stringent network assumptions such as
partial synchrony.
5.2 Intents
Anintentis a signed message that describes a partial
state transitions. Semantically, intents contain infor-
mation about state preferences, such as that Alice
wishes to swap X for Y, or any X with property T for
any Y with property U, or Z for some asset A, but
only if A was previously owned by Bob, and only if
Bob provides an additional signature. More generally
intents are arbitrary code that is evaluated at runtime
by the settlement layer.
Intents are partial and hence specific counterparties
are not required, albeit they can also be complete
(complete state transitions are a subset of partial
state transitions). For example, an intent may ex-
press that Alice wishes to send asset A to Bob, a state
change which requires no one except Alice to agree
in order to be enacted. Such intents may still require
solvers, if certain information is unknown by Alice.
For example, Alice could express that she wishes to
set a bounty value in proportion to the current tem-
perature in Berlin, a value which she does not know
but knows an oracle key for, and which a solver with
oracle data access could provide. Intents which need
neither counterparties nor solvers can be immediately
converted into transactions. The particular syntax
of representation of assets, properties, etc. is fixed
at the application level. At the architectural level,
intents are opaque bytestrings.
5.3 Intent gossip layer
Theintent gossip layeris a virtual sparse overlay
network for dissemination of intents, counterparty
discovery, and solving (when a solver combines multi-
ple intents to craft a valid transaction). The intent
gossip layer consists of sparsely networkedintent gos-
sip nodes, whereintent gossipis a role any node can
play. When a client authors an intent which requires
solving, it broadcast the signed intent to anintent
gossip node, which further relays the intent over the
6
Figure 1: The lifecycle of an intent in the Anoma architecture
intent gossip layer. This broadcast can be directed,
where the node picks specific other nodes based on
solving specialisation or other criteria, or undirected,
where the node broadcasts the intent as widely as pos-
sible. Intents can contain a settlement-conditional fee,
to be paid only if the intent is satisfied, settled and
confirmed by consensus. Furthermore this fee can be
split between all nodes involved in the gossip and the
ultimate solver. Intents can pay a fee for confirmation
and ordering of the (likely encrypted) intent in a data
availability domain where solvers compete to find the
best match for each batch of intents.
5.4 Solver
Asolveris a node which chooses to observe all or a
subset of intents and computes solutions over the set
of intents. It achieves this by running one or many
solver algorithms. These algorithms are local and
different solvers compete with each other to satisfy
the presented constrain system. In practice, solvers
will likely specialise in certain applications, such as
fungible token trading or computing rollup states.
Solvers are permissionless and anyone can act as the
role of solver. Solvers can decide which intents to
accept and should generally only consider those that
are worth the storage and bandwidth costs, perhaps
due to a fee or an expected spread from a trade.
The solver algorithm searches the space of possible
solutions based on the current state of the settlement
layerandtheknownintentpoolwiththeaimoffinding
subsets of combinable intents to generate transactions
which are accepted by the settlement layer.
5.5 Transaction
Atransactionis complete state transition which
acts as a function from the current state to a new
state. Transactions follow the declarative program-
ming model and describe the desired end state rather
than the imperative steps to compute it. As a result,
submitters of transactions, such as solvers or ordinary
users, do not have to consider the execution steps
when reasoning about the behaviour of their transac-
tion. In existing systems, such as Ethereum or other
programmable settlement architectures, submitters
have to be aware and trust all intermediary execution
steps, including as proxy contracts, since they can
modify the imperative computation and change the
final state result. With Anoma’s declarative approach
7
submitters only have to accurately specify the desired
end state without worrying about the compute done
in the middle.
Submitters encrypt transactions against the Ferveo
Distributed Key Generation (DKG) public key [7].
Nodes receive and gossip only encrypted transactions.
After consensus has ordered the encrypted byte strings
a 23 majority of consensus nodes decrypts and reveals
the original transactions. Ferveo is non-interactive,
which means that there are no extra economic security
guarantees required in order to enforce the revelation
of the original transactions.
5.6 Mempool
Themempoolis a virtual dense partitioned overlay
network for transactions. The mempool is partitioned
on the basis of security and concurrency domains
(fractal instances), where nodes participating in the
mempool gossip only transactions for fractal instances
which they are interested in. By contrast to the intent
gossip network, the mempool is dense in the sense that
validators of a particular fractal instance must receive
all of the transactions destined for that instance. The
mempool is opaque since it only receives, stores and
gossips encrypted byte strings rather than transparent
transactions.
5.7 Data availability domain
Adata availability domainis a logical clock and data
availability layer. These data availability domains are
programmable by all applications. It allows applica-
tions to specify batches of intents that are decrypted
all at once at the same time after a particular time
interval has passed. Intents can be submitted in en-
crypted form (using Ferveo) to the nodes in a partic-
ular batch. After the batch is complete the validators
decrypt all intents in a batch and add the decrypted
content to the state. These intents are not directly
executed by the state machine, but rather are avail-
able to solvers who compete to offer the best solution
by a measurable criterion defined by the application.
5.8 Security domain
Asecurity domainis a set of cryptographically iden-
tified nodes executing a particular state transition
function in consensus, for which finality and correct-
ness hold under a particular assumption of a certain
fraction of nodes behaving according to protocol, gen-
erally: n >= 3f + 1. Different Sybil-resistance mech-
anisms can be used to select the set of nodes, such as
proof of stake (PoS), proof of work (PoW), proof of
identity (PoI) or proof of authority (PoA).
5.9 Concurrency domain
Aconcurrency domainis a total ordering over a set of
transactions within the domain which may be partially
ordered or unordered with respect to other concur-
rency domains. Concurrency domains always operate
within particular security domains, since the total
order is enforced by the consensus of the security
domain.
5.10 Consensus
Consensusis an algorithm for agreement between
many parties (some possibly Byzantine) that forms a
security domain and quantizes time. The consensus
algorithm is responsible for grouping transactions into
blocks which are agreed upon by consensus partici-
pants.
5.11 Execution
Anexecution environmentis an algorithm for taking
the current state and a set of transactions and apply-
ing those transactions to the state resulting in a new
state. Anoma provides aunified execution environ-
mentwhich can handle various state transitions.
• Transparentdata is public to execution nodes and
observers.
• Semi-discreetdata is not known to execution
nodes and observers, but known to a single user,
who can prove properties of it using ZKPs.
• Discreetdata is known by no one independently
and is computed and stored in encrypted form
8
using various forms of homomorphic encryption
(HE).
Anoma provides a general framework for reasoning
about the locality of data independently of the kind
of verification performed, but performance character-
istics of the underlying cryptographic schemes will
determine the practical feasibility and execution costs
of various applications. Technologies such as zero-
knowledge or optimistic rollups can be used with all
supported state transitions.
5.12 Application
Anapplicationis a semantic domain governing the
form and logic of a particular partition of state which
many users may interact with.Figure 2illustrates
the interfaces for end-users in Anoma. An application
consists of:
• State, which may be partitioned across multi-
ple fractal instances and shards within those in-
stances;
• application validity predicates, which govern
changes to the application’s state;
• user validity predicate components, which can be
included by the user in order to authorise certain
interactions with the application;
• intent formats, which allow intents to be created
by clients, reasoned about by solvers, and pro-
cessed by application validity predicates;
• solver algorithms, which allow solvers to craft
transactions satisfying intents from a specific ap-
plication or possibly from many other applica-
tions;, - - andinterfaces, which provide users
visual, spatial, and temporal abstractions for in-
teracting with the application.
5.13 Fractal instance
Afractal instanceis an instance of the Anoma con-
sensus and execution protocols operated by a set of
networked validators. In general, fractal instances are
security domains, in that they are operated by a par-
ticular set of validators, of which the user must trust a
quorum; concurrency domains, in that they maintain
a full order of only the transactions which they exe-
cute; and data availability domains, in that external
observers can query the fractal instance to retrieve
parts of its state. Fractal instances are sovereign, in
that they do not depend on any other part of the
fractal instance graph for continued correct execu-
tion, although their validator sets may overlap, a
property which can be exploited in certain cases to
provide multi-chain atomic settlement. Fractal in-
stances, in order to be compatible with all features of
the network, must implement the Anoma consensus
and settlement protocols according to the specifica-
tion, but they can vary in their chosen sybil-resistance
mechanisms, execution pricing, and local governance
of protocol versioning, economic distribution regime,
and irregular state transitions handling.
6 Programming model
Considering the architecture of Anoma from the per-
spective of users with preferences over states of the
system, one might ask the question: why are there
applications at all? Cannot users merely articulate
their preferences and the system enact them, without
further component intermediation? In principle, they
can, but the search space of solvers and difficulty of
coordinating the relations between the state of the
ledger and state of the world would be computation-
ally intractable without coordination on particular
forms of representation and particular logics of prefer-
ence expression and settlement. Applications describe
these particular forms, on which it is necessary to co-
ordinate in order to express, match, and settle intents,
and in order to provide simple and accurate interfaces
for users.
6.1 Application components
An application on the Anoma architecture consists of
intent formats, an application state validity predicate,
user validity predicate components, solver algorithms,
and one or many user interfaces.
• Intent formatsdescribe the form and semantics
of particular intents utilised by the application,
which must be created by the user interfaces,
understood by intent gossip nodes, matched by
9
Figure 2: End-user interfaces of applications on Anoma
solvers, and validated by the application’s validity
predicates.
• Theapplication state validity predicateencodes
the relation governing valid state transitions of
the application’s state.
• User validity predicate componentsencode the
relations which users can approve in order to
allow for safe interactions with this application.
• Solver algorithmsinstruct a solver how to match
this application’s intents and form valid transac-
tions.
• Finally,user interfacespresent users with a
graphical or textual view of and controller for the
application in question.
6.2 Application portability
By default, applications are portable across fractal in-
stances, and application state validity predicates may
also reason about security and concurrency domains
in order to allow for safe interaction between users of
an application across these domains.
Although nothing ties a particular interface to a par-
ticular application, Anoma’s intent gossip network is
capable of acting as a data availability layer for inter-
face code, in a way which allows secure synchronised
interface and application versions.
6.3 Application security model
In Anoma, users distrust applications. Applications
are never granted un-restricted access to modify a
user’s state. All state entries carry an explicit owner,
and the validity predicate associated with that owner
must authorise all changes to that state. Instead of
authorising à latransferFrom, users add components
to their validity predicates which allow for specific
interactions with a specific application, which can
then be performed non-interactively from the perspec-
tive of the user, if they have granted the application
license to do so. These components can be altered or
revoked at any time, and allow for “defence-in-depth”,
e.g. prevent transfers of more than X within time
boundt).
6.4 Application state model
Anoma assumes clients arestateful- they are treated
as components of the distributed system. Messages
will only be sent once, and can be marked as delivered,
in which case they will not be kept around. Message
history can be reconstructed by reprocessing historical
transaction archives.
7 Applications
The architecture of Anoma is suitable for any ap-
plication desiring to provide counterparty discovery,
solving, and settlement for particular forms of pref-
erences over a particular semantic domain. Here we
enumerate several primitives that Anoma exposes to
application developers. We then list several exam-
ples of contemporary decentralised applications and
how they would benefit from Anoma’s architecture.
Followed by the description of novel decentralised
applications which have hitherto been impractical or
impossible to develop due to the constraints of existing
architectures.
10
7.1 Novel primitives for applications
Anoma exposes several new primitives to application
developers:
• Incentivised data availability, for data which is
expected to be used in the creation of future
transactions, provided by the intent gossip layer
(seeSection 6: Architectural instantiation).
• Programmable solvers, provided by intent gossip
nodes running solver algorithms, to which can be
outsourced the computational task of finding an
atomic state transition (transaction) involving
many parties which simultaneously satisfies all
of their preferences.
• Programmable threshold decryption, provided
by Ferveo [7], which can be used to implement
on-demandbatchingandenforceconfigurablefair-
ness properties on the processing of application-
specific state transitions submitted within a quan-
tised period of logical time.
• ZKP systems and fully homomorphic encryption
(FHE), which can be used to separate verification
of properties of data from knowledge of the data
itself. Application developers can leverage those
to build applications that handle various modes
of state in the same application.
These primitives taken together provide the flexibility
required to build complex user-friendly applications
whichprovidethedesiredgame-theoretic, datalocality
andlatencyproperties, suchasdecentralisedquadratic
voting and quadratic funding, voting through incen-
tivised data availability, settlement through solvers,
and receipt-freeness through ZKPs and FHE.
7.2 Application examples
7.2.1 Contemporary decentralised applica-
tions
Here we list example of collections of contemporary
applications that follow the intent, counterparty dis-
covery, and solving design pattern, but that are at
the moment application specific and rely on at least
one single-operator component.
7.2.1.1 Decentralised exchangesContempo-
rary decentralised exchanges for both fungible and
non-fungible tokens, such as 0x, CoWSwap, Uniswap,
Wyvern, and Seaport, require both counterparty dis-
covery, solving, and settlement, besides other require-
ments such as batched/fair execution. At the mo-
ment, such projects either use the blockchain itself for
counterparty discovery (Uniswap) or operate single-
operator orderbooks controlled by specific parties
(0x, Wyvern, Seaport, CoWSwap), which tend to be
trusted for fair ordering and optimal execution. Using
Anoma, these parties could be replaced by the peer-to-
peer intent gossip and distributed solving layer, which
generalises through arbitrary trades. Orders to buy
or sell particular assets would instead be broadcasted
across the intent gossip network as intents, matched
by a solver, who could collect any number of intents in
order to balance a trade, and submitted for settlement
to the fractal instance holding the assets in question.
Threshold decryption can be used for fairness across
batches.
7.2.1.2 RollupsExisting rollup architectures,
both optimistic ones such as Arbitrum, Optimism;
and zero-knowledge ones, such as ZkSync or StarkNet,
operate with a single-operator sequencer and solver
responsible for ordering transactions, calculating state
updates, and submitting updated states to the root
chain, in these cases, Ethereum. This sequencer is
trusted with fair ordering and optimal solving, and
can selectively omit transactions, so some projects
have expressed a desire to decentralise the sequencer.
As a decentralised sequencer is simply a consensus
instance, such rollups could instantiate an Anoma
fractal instance, using Typhon consensus, to oper-
ate their sequencer, and submit zero-knowledge or
optimistic proofs of execution to Ethereum as they
currently do.
7.2.1.3 Public goods fundingQuadratic fund-
ing (QF), as implemented by Gitcoin, requires
both counterparty discovery, solving (as the funding
provider’s payouts depend on individual donations),
and settlement. Using Anoma, QF can be imple-
mented in a manner which provides excellent UX
11
(e.g., donating to projects carries no fees). The fund-
ing provider, project creators, and all individual do-
nators each author intents reflecting their willingness
to commit funds, execute on a project, and donate,
respectively. A solver algorithm matches these intents
and creates a single transaction to settle at the end
of the QF round, while the funding 프로젝트로 돌아가기