bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 4쪽 중 1쪽
Irys:
A
Programmable
Datachain
for
Verifiable
Storage
and
Onchain
Computation
Josh
Benaron,
Dan
MacDonald,
and
Jesse
Cruz
Wright
Disclosure
:
The
information
described
in
this
paper
is
preliminary
and
subject
to
change
at
any
time.
Furthermore,
this
paper
may
contain
“forward-looking
statements.”
Nothing
in
this
White
Paper
is
an
offer
to
sell,
or
the
solicitation
of
an
offer
to
buy,
any
tokens.
Abstract
This
paper
presents
Irys,
a
Layer-1
Datachain
that
makes
data
programmable
by
unifying
high-performance
storage,
data
availability,
and
an
EVM-compatible
execution
environment
so
smart
contracts
can
read
and
act
on
onchain
bytes
at
hot-access
latency.
A
hybrid
Proof-of-Work
and
Stake
consensus
ties
block
production
to
Hard
Disk
Drive-bound,
Verifiable
Delay
Function-paced
efficient
sampling;
miners
perform
deterministic
200
MiB
sequential
reads
each
second
and
are
slashable,
creating
continual
proofs
of
storage
with
low
messaging
overhead
and
fast
inclusion.
Matrix
packing
encodes
a
miner’s
address
into
each
256
KiB
chunk,
enforcing
unique
replicas
and
closing
remote-mining
attack
surfaces.
A
multi-ledger
architecture
supports
arbitrary
retention
windows;
data
enters
short-term
ledgers
and
is
promoted
to
permanent
once
ingress
proofs
reach
threshold,
decoupling
fee
markets
and
stabilizing
costs.
IrysVM
extends
the
EVM
with
precompiles
that
stream
chunk
ranges
into
contracts,
enabling
in-protocol
licensing,
royalties,
and
verifiable
AI
workflows
where
datasets
are
first-class
program
inputs.
On
commodity
1
Gbps
hardware,
throughput
scales
with
the
number
of
miners
and
write
latency
is
drive-limited;
pricing
targets
at-cost
HDD
economics.
Together
these
primitives
provide
a
single
chain
that
proves
availability,
ordering,
and
durable
storage
while
turning
data
from
a
static
payload
into
an
executable
asset.
1
1
Introduction
A
datachain
is
an
implementation
of
a
fault-tolerant
replicated
data
and
execution
machine.
Current
storage
blockchains
treat
data
as
static
payloads
and
make
weak
assumptions
about
data
availability,
verifiability,
and
usability
within
computation.
Each
node
typically
verifies
data
in
isolation,
without
any
unified
mechanism
to
prove
that
the
data
exists,
is
actively
stored,
or
can
be
acted
upon
deterministically
by
smart
contracts.
The
absence
of
a
verifiable
data
layer
means
that
while
storage
can
be
decentralized,
execution
remains
disconnected,
preventing
true
onchain
applications
from
operating
on
large-scale
datasets.
Irys
introduces
a
verifiable
data
architecture
designed
to
encode
proof
of
storage,
access,
and
availability
directly
into
the
consensus
process.
Each
block
not
only
orders
transactions
but
also
cryptographically
proves
that
every
partition
of
data
has
been
sampled
and
remains
accessible.
This
transforms
the
ledger
into
a
programmable
data
substrate,
where
both
state
transitions
and
data
proofs
are
verified
within
the
same
trustless
environment.
It
is
anticipated
that
every
node
in
the
Irys
network
can
rely
on
the
verifiable
persistence
and
accessibility
of
data
recorded
onchain
without
external
assumptions
or
intermediaries.
2
Outline
The
remainder
of
this
paper
is
organized
as
follows.
Section
3
presents
the
high-level
architecture
and
vertical
integration
model.
Section
4
defines
blocks,
transaction
lanes,
and
the
multi-ledger
partition
lifecycle.
Section
5
introduces
PoW/S
consensus,
highlighting
efficient
sampling
and
the
VDF
read
limiter
as
core
subsections.
Section
6
describes
the
data
transaction
lifecycle.
Section
7
specifies
IrysVM
and
Programmable
Data.
Section
8
details
tokenomics.
Section
9
formalizes
the
fee
model
for
term
and
permanent
storage.
Section
10
defines
epoch-boundary
processing.
Section
11
outlines
future
work
on
programmable-data
L2s
and
faster
blocks/finality.
3
High-level
architecture
Irys
is
a
fully
integrated
layer-1
protocol
that
unifies
data
storage
and
execution
within
a
single
architecture.
By
combining
these
traditionally
separate
layers,
Irys
enables
users
to
store
data
directly
onchain
at
a
fraction
of
conventional
costs
while
executing
application
logic
natively
on
that
same
data.
The
design
philosophy
behind
Irys
centers
on
vertical
integration:
eliminating
the
fragmented
tooling
and
multiple
dependencies
that
developers
currently
face
across
disparate
infrastructures.
Instead
of
relying
on
a
patchwork
of
external
services
for
storage,
compute,
and
verification,
Irys
provides
a
cohesive
environment
where
every
layer
of
the
stack
operates
within
one
trustless,
verifiable
system.
2
The
below
diagram
outlines
the
processes
within
Irys
that
enable
it
to
have
its
unique
properties:
Figure
1:
Mining
Process
Irys
combines
high-performance
data
with
robust
verification,
enabling
a
native
execution
environment
for
onchain
data.
Traditional
storage
protocols
struggle
to
balance
these
two
aspects,
making
it
difficult
to
manage
execution
and
storage
in
the
same
chain,
meaning
building
onchain
apps
on
datachains
has
been
impossible
to
date.
Irys
overcomes
this
tradeoff
by
uniting
Proof
of
Work
(PoW)
with
staking
and
slashing
mechanisms.
This
enables
Irys
to
efficiently
handle
all
forms
of
data
alongside
having
robust
security
for
fully
onchain
applications.
We
call
this
integration
of
secure
storage
and
native
execution
in
a
single
protocol
“Programmable
Data.”
Figure
2:
Programmable
Data
3
IrysVM
enables
the
capability
for
smart
contracts
to
directly
access,
compute
on,
and
derive
value
from
large
volumes
of
onchain
data
stored
within
the
protocol.
This
transforms
data
from
a
passive,
static
commodity
into
an
active,
composable
asset
class
that
can
be
queried,
processed,
and
monetized
within
the
execution
layer
itself.
Through
its
extended
EVM++
architecture
and
native
data
access
primitives,
IrysVM
allows
developers
to
build
applications
where
datasets
are
not
merely
referenced
but
programmatically
integrated
into
logic,
enabling
new
classes
of
onchain
AI,
analytics,
and
automation
that
operate
directly
on
verifiable
data.
4
Blocks
and
transactions
There
are
two
types
of
transactions:
Data
transaction
:
a
transaction
that
stores
data
on
the
network.
Execution
transaction
:
a
transaction
that
interacts
with
a
smart
contract
through
IrysVM.
This
includes
programmable
data
transactions.
Each
block
contains
two
sets
of
transactions
in
separate
block
lanes.
The
block
structure
can
be
seen
below:
Field
Name
Description
block_hash
The
block
identifier
height
The
block
height
diff
Difficulty
threshold
used
to
produce
the
current
block
cumulative_diff
The
sum
of
the
average
number
of
hashes
computed
by
the
network
to
produce
the
past
blocks,
including
this
one
last_diff_timestamp
Timestamp
(in
milliseconds)
since
UNIX_EPOCH
of
the
last
difficulty
adjustment
solution_hash
The
solution
hash
for
the
block
previous_solution_hash
The
solution
hash
of
the
previous
block
in
the
chain
last_epoch_hash
The
solution
hash
of
the
last
epoch
block
chunk_hash
SHA-256
hash
of
the
PoA
chunk
(unencoded)
bytes
previous_block_hash
Previous
block
identifier
previous_cumulative_diff
The
previous
block's
cumulative
difficulty
poa
The
recall
chunk-proof
4
Field
Name
Description
reward_address
The
address
that
the
block
reward
should
be
sent
to
miner_address
The
address
of
the
block
producer
-
used
to
validate
the
block
hash/signature
&
the
PoA
chunk
signature
The
block
signature
timestamp
Timestamp
(in
milliseconds)
since
UNIX_EPOCH
of
when
the
block
was
discovered/produced
ledgers
A
list
of
transaction
ledgers,
one
for
each
active
data
ledger
evm_block_hash
The
Ethereum
Virtual
Machine
block
hash
vdf_limiter_info
Information
about
the
Verifiable
Delay
Function
limiter
Irys
uses
block
lanes
to
ensure
that
users
can
always
submit
a
data
transaction,
even
when
the
execution
lane
is
congested.
This
allows
data
transactions
to
have
stable
pricing.
4.1
Partition
Lifecycle
(Capacity
&
Data,
Multi
Ledger)
Irys
introduces
a
multi-ledger
system
where
data
can
seamlessly
transition
between
different
terms.
This
effectively
enables
users
to
store
data
for
any
period
of
time
(e.g.,
1
day,
1
week,
1
year,
or
forever).
There
are
also
inbuilt
mechanisms
for
“promoting”
data
to
longer-term
ledgers––e.g,.
when
a
user
requests
to
store
data
on
the
permanent
ledger,
it
enters
the
5-day
ledger
and
transitions
to
the
permanent
ledger
once
it’s
been
verified
by
the
network.
Figure
3:
Multi-Ledger
System
A
ledger
is
a
collection
of
data
with
a
shared
property
(typically
duration),
i.e.,
all
data
in
ledger
0
is
stored
for
5
days.
5
4.2
Partition
Lifecycle
Ledgers
on
Irys
are
split
up
into
16TB
partitions.
This
allows
miners
to
affordably
use
HDDs
and
not
be
outcompeted
by
SSDs.
Figure
4:
Ledger
Promotion
Irys
measures
the
amount
of
data
uploaded
and
then
uses
it
to
project
the
number
of
partitions
needed
on
standby.
These
standby
partitions
do
not
contain
any
data
(yet)
and
are
referred
to
as
Capacity
Partitions.
Figure
5:
Capacity
Partitions
6
Step
1:
Partition
Pledging
Miners
post
a
pledge
transaction
to
the
network
indicating
their
willingness
to
bring
a
new
partition
online.
The
protocol
then
randomly
assigns
unclaimed
capacity
partitions
to
the
pledged
miners;
any
miners
who
don’t
receive
capacity
partition
assignments
have
their
pledges
refunded.
Step
2:
Partition
Packing
Once
assigned
a
Capacity
Partition,
the
miner
packs
it
using
Irys’
matrix
packing
scheme.
This
process
fully
encodes
the
miner’s
fingerprint
into
the
partition.
Step
3:
Partition
Mining
Once
a
capacity
partition
is
packed,
the
protocol
assigns
a
random
200MB
sequential
read
to
the
miner
every
second.
The
miner
takes
these
200MB
reads,
splits
them
into
800
256KiB
chunks,
and
proceeds
to
hash
each
chunk,
looking
for
a
mining
solution.
If
the
miner
is
lucky
enough
to
find
a
mining
solution,
it
wins
the
right
to
produce
a
new
block
and
announce
it
to
the
network,
thus
earning
rewards.
Step
4:
Ledger
Assignment
When
it
comes
time
to
add
more
storage
capacity
to
one
of
Irys’
data
ledgers,
the
protocol
will
randomly
select
a
Capacity
Partition
that
is
actively
being
mined.
The
randomness
is
weighted
towards
partitions
used
to
mine
blocks,
rewarding
miners
who
have
been
participating
longer
and
have
been
effective
in
mining.
Being
assigned
to
a
data
ledger
and
mining
it
has
higher
rewards
than
mining
empty
capacity
partitions,
so
miners
are
incentivized
to
demonstrate
their
capability
by
mining
capacity
efficiently.
Step
5:
Partition
Departure
There
are
two
ways
partitions
leave
the
network:
orderly
departures
and
disorderly
departures.
4.2.1
Orderly
Departure
1.
The
miner
posts
a
transaction
to
un-pledge
their
partition
and
recover
the
commitment
they
staked
initially.
2.
A
timeout
period
begins
when
the
protocol
assigns
another
Capacity
Partition
to
synchronize
the
data
being
taken
offline.
3.
Once
the
timeout
has
passed,
the
departing
miner
can
recover
their
staked
commitment
and
remove
their
partition.
4.
If
the
miner
goes
offline
before
the
timeout
has
passed,
they
risk
losing
their
pledged
bond.
7
4.2.2
Disorderly
Departure
1.
A
miner
engages
in
adversarial
behavior
toward
the
network
(double
signing
blocks,
for
example).
2.
The
protocol
takes
their
staked
commitment.
3.
The
protocol
assigns
a
new
Capacity
Partition
to
fill
gaps
left
by
the
adversarial
miner.
This
is
an
undesirable
departure
as
the
network
will
have
to
assign
new
capacity
partitions
quickly.
Because
of
this,
Irys
requires
miners
to
make
a
significant
upfront
investment
by
staking
tokens
to
their
mining
address
in
order
to
participate
in
the
protocol
and
earn
rewards.
4.3
Matrix
packing
Packing
describes
the
process
of
miners
encoding
data
with
their
staking
address.
This
proves
they’re
storing
a
unique
replica
of
the
data,
as
opposed
to
mining
off
a
single
remote
copy
(a
common
attack
vector
on
datachains).
Irys
introduces
Matrix
Packing,
which
uses
a
VDF
to
encode
the
miner's
address
into
each
256KiB
chunk
they
store.
This
provides
sufficient
computational
cost
for
each
bit
of
data,
making
any
adversarial
mining
pattern
unprofitable.
The
process
is
outlined
in
detail
below:
4.3.1
Phase
1
-
Sequential
Hashing
1.
mining_address
,
partition_hash
,
and
chunk_offset
are
SHA-256
hashed
into
seed_hash
.
2.
seed_hash
is
SHA-256’d
to
form
the
initial
segment
.
3.
The
segment
bytes
are
appended
at
the
start
of
the
empty
chunk.
4.
The
segment
is
also
used
as
input
for
the
next
SHA-256.
5.
Resulting
segment
is
appended
following
the
previous
segment’s
bytes.
6.
Steps
4
and
5
are
repeated
using
the
previous
segment
until
the
empty
chunk
is
filled
with
segments.
8
Figure
6:
Sequential
Hashing
Sequential
hashing
ensures
single-core
chunk
packing
since
each
segment
depends
on
the
one
before
it,
establishing
a
minimum
packing
time.
This
method
allows
mining
of
data-less
"capacity"
chunks
that
are
verifiable
by
other
miners
deterministically
(by
recreating
the
packing
locally
and
comparing
it
to
the
provided
packed
chunk).
With
32-byte
segments
and
a
256KiB
chunk,
one
pass
of
sequential
hashing
requires
8,192
hashes.
The
challenge
is
that
a
Ryzen
5900X
can
compute
~15
million
SHA-256
hashes
per
second,
making
this
amount
of
packing
delay
take
a
tiny
fraction
of
a
second.
To
deter
adversarial
miners
from
packing
"on
demand"
we'll
have
to
increase
the
packing
length,
something
on
the
order
of
~1500ms.
4.3.2
Phase
1
-
Sequential
Hashing
+
Parametrized
Packing
Time
To
lengthen
chunk
packing
time,
sequential
hashing
could
loop
from
the
chunk’s
last
to
first
segment,
overwriting
it.
This
process
could
repeat
for
multiple
passes
until
reaching
a
desired
packing
duration.
9
Figure
7:
Parametrized
Packing
Time
Repeated
sequential
hashing
of
the
chunk
creates
layers
of
segments,
with
the
final
layer
stored
in
the
chunk.
This
process
succeeds
in
realizing
a
specific
packing
time
but
it
also
exposes
a
potential
vulnerability
to
adversarial
miners.
4.3.3
Fast
Packing
Vulnerability
Miner
then
stores
only
the
first
segment
of
the
resulting
packing
layer
and
discards
the
rest.
When
they
need
to
pack
a
chunk,
they
can
use
these
segments
to
reproduce
the
final
packing
layer
without
computing
all
previous
packing
layers
(in
parallel).
10
If
a
miner
wanted
to
stake
multiple
mining
addresses
for
replicas
of
the
same
partition
they
could
use
this
strategy
to
avoid
storing
a
unique
partition
for
each
staked
address.
Instead
they
could
store
an
unpacked
partition
and
quickly
pack
chunks
"on
demand"
for
each
mining
address
they
staked
to
that
partition.
This
is
an
example
of
using
compute
instead
of
storage
to
satisfy
the
consensus
rules
of
the
protocol
and
is
considered
a
degenerate
mining
strategy
(not
accomplishing
the
protocol’s
goal
of
provably
replicating
partition
data).
4.3.4
Adversarial
Mining
Why
would
a
miner
want
to
use
"on
demand"
packing?
Miners
are
economically
incentivized
to
use
the
most
profitable
mining
strategy.
For
miners
with
access
to
cheap
energy
and
pools
of
compute
(GPU
or
CPU)
it
may
be
more
profitable
to
employ
a
computational
strategy
to
mining
than
to
pay
the
storage
costs
of
a
storage-based
strategy.
They’d
employ
this
degenerate
strategy
(in
that
it
does
not
reinforce
or
support
the
protocol’s
utility)
—
a
miner
will
maintain
a
single
unpacked
replica
of
a
partition.
Figure
8:
“On
Demand
Packing”
Example
(Adversarial)
11
If
this
process
is
fast
enough
to
win
block
rewards,
the
miner
may
choose
it
instead
of
packing
all
the
chunks
of
a
partition
replica
like
the
protocol
expects.
4.3.5
Phase
2
-
2D
Matrix
Packing
To
stop
"on-demand"
packing,
the
protocol
requires
miners
to
store
all
chunk
segments
of
the
previous
layer
when
computing
a
new
one.
This
makes
computing
the
final
layer
possible
only
by
recomputing
all
prior
layers
through
two-dimensional
sequential
packing:
breadth
and
depth.
Each
layer
depends
on
the
previous
one,
starting
with
Phase
1
-
Sequential
Packing.
1.
a)
The
last
segment
of
the
previous
layer
becomes
an
input
to
the
first
sequential
hash
of
the
new
layer.
1.
b)
The
segment
on
the
previous
layer
at
the
same
location
of
the
segment
we
are
computing
becomes
input
entropy
to
the
current
segment.
2.
The
segment
produced
by
hashing
the
previous
segment
and
the
entropy
segment
is
appended
to
the
new
layer.
3.
a)
As
in
step
1a,
the
segment
computed
in
step
2
is
used
as
input
to
the
next
sequential
SHA-256
hash.
3.
b)
As
in
step
1b,
the
segment
from
the
previous
packing
layer
at
the
same
location
as
the
segment
currently
being
computed
is
used
as
entropy.
4.
The
resulting
segment
is
then
appended
to
the
chunk
after
the
previous
segment.
5.
Repeat
until
the
required
number
of
packing
layers
have
been
achieved
to
satisfy
the
packing
duration
requirement.
Figure
9:
Sequential
Packing
Process
12
The
result
of
packing
in
two
dimensions
this
way
is
that
every
segment
of
a
new
packing
layer
requires
the
segments
of
the
packing
layer
immediately
beneath
it.
There
is
no
way
to
compute
the
final
packing
layer
without
first
computing
every
packing
layer
beneath
it.
This
ensures
that
adversarial
miners
wishing
to
pack
"on
demand"
will
have
to
pack
for
the
full
packing
duration
every
time
they
pack
a
chunk.
Figure
10:
2D
Matrix
Packing
5
PoW/S
consensus
Irys
introduces
a
hybrid
Proof-of-Work-Stake
consensus
algorithm.
This
was
done
to
achieve
the
following
set
of
requirements:
●
Sustainable
economics
for
permanent
data
●
Minimize
infflationary
pressure
long-term
●
Create
accoun프로젝트로 돌아가기