►
From YouTube: Whiteboard Series with NEAR | Ep: 26 Holochain
Description
In this episode Illia from NEAR and Eric from Holochain discuss how Holochain uses scalable DHTs as the foundation of their platform.
------- About Whiteboard Series ---------
The Whiteboard Series with NEAR is a set of video interviews with Founders who are building scalable solutions for blockchain. We deep dive into their story, what they're developing and how it is helping the blockchain ecosystem.
Follow the latest from NEAR Protocol on,
Discord: https://near.ai/discord
Medium: https://near.ai/medium
Twitter: https://near.ai/twitter
GitHub: https://near.ai/github
A
B
B
So
the
thing
that's
interesting
about
hollow
chain
is
that
it
doesn't,
especially
if
you've
been
living
in
the
blockchain
world,
and
that's
what's
dear
to
you
and
that's
what
you
know
you
have
to
shift
your
mindset
because
whole
a
chain
is
not
a
consensus
mechanism.
It
is
not
a
way
of
having
some
data
reality
that
everybody
agrees
on.
B
What
whole
chain
is
more
like
is
what
we
actually
know
the
world
to
be
like
everything
comes
from
an
agent
centric
perspective,
so
what
whole
chain
provides
is
a
way
of
different
agents
who
are
playing
a
game
ie,
an
application
or
a
little
micro
service
to
agree
on
a
set
of
rules
to
begin
with
and
then
make
plays
inside
those
rules
and
have
them
be
validated
by
the
community.
So
the
agents
declare
moves
in
a
rule,
and
that
would
be
the
chain
where
you
have
the
chain
part
where
you
have
a
hash
chain.
B
That
starts
at
the
bottom,
with
what
we
like
to
call
the
DNA
or
the
rules
of
the
game.
The
second
element
in
the
chain-
and
this
is
every
agent
has
one
of
these
chains-
is
a
record
of
the
agents
identity.
What
their
address
is
so
there's
an
ID
and
then
from
there
on
out
in
the
chain.
It
would
be
the
rules
of
the
game
as
defined
in
the
DNA,
and
so
you
will
have
lots
and
lots
of
different
agents
that
are
doing
the
same
thing:
DNA
ID
and
then
whatever
it
might
be.
A
A
C
B
Popped
into
that
mindset
there's
not
one
chain.
This
is
an
agent
centric
point
of
view
where,
instead
of
data
centric,
where
you're
saying
there
is
a
chain
which
is
the
reality
of
everyone,
there
isn't
that,
and
this
is
true
of
the
world.
Okay,
we've
known
this
anion
Stein
made
this
quite
clear
to
us.
B
Everything
is
from
the
perspective
of
an
observer,
so
you
can
think
of
agents
as
observers
in
the
rules,
making
declarations
or
making
making
seeing
events
and
declaring
events
in
the
world
and
then
what
happens
in
the
shared
space
is
somebody
seeing
that
they
made
a
cryptographically
signed
set
of
its
actions
in
that
world
and
they
can
verify
them.
So
if
it's
something
like
a
tweet,
the
only
thing
you're
checking
for
is,
is
it
the
person
who
said
they
were
right?
Is
that
their
identity
according
to
their
identity?
B
A
B
This
is
beautiful,
because
this
is
right
where
I
want
to
get
to
in
a
data
centric
world
yeah.
This
is
what
people
start
to
think
in
their
head.
They
create
an
ontology
of.
There
is
a
thing
out
there
called
money
and
I'm
going
to
move
that
physical
object
from
one
place
to
the
other
right.
That
is
the
idea
that
we
do,
or
at.
B
B
The
double
spend
problem,
if
you
don't
start
with
that
ontology,
which
is
what
we
don't
do
in
hollow
chain.
If
you
start
with
this
agent,
centric
ontology,
what
you
do
is
you
create
this?
You
solve
the
problem
of
money,
a
different
way.
You
use
mutual
credit
in
which
what
you
say
is
this
is
my
ledger
in
my
and
and
the
transfer
of
money
is
not
a
coin
that
you
have
to
see
where
it
went
and
whether
it
was
double
spent
or
not.
Instead,
what
you're
doing
is
you're
just
entering
in
the
ledger?
B
B
B
It
a
function
called
balance
and
then
you
would
be
able
to
call
that
function,
balance
on
a
particular
agent
or
on
yourself
and
report.
It
depends
how
you
implement
it
in
the
particular
application.
You
do
so
in
hollow
chain,
there's
no
to
note
messaging
and
then
there's
UI
that
you,
basically
you
can
think
of
it
as
there's
an
internal
communication
mechanisms
where
nodes
can
talk
to
each
other
on
that
particular
network
and
there's
also
the
UI
facing
side
where
the
the
human
user
talks
to
the
agent,
which
is
the
device
and
and
calls
functions.
B
B
You
see
that
it's
a
chain
because
it
goes
all
the
way
back
to
the
DNA
and
you
calculate
out
their
balance,
and
you
just
see
it
because
you
can
do
that
by
either
getting
it
directly
from
them,
or
you
can
do
other
things
that
I
haven't
gotten
into
in
the
way
this
DHT
and
hollow
chain
has
linking
on
top
of
it,
but
now
I
jumped
really
fast
and
technical
and
I'm
not
sure.
If
that's
where
we're
gonna
go,
I
can
get
there.
If
you
would
like
yeah.
C
B
Big
thing
about
halogen
is
that
we're
a
way
in
which
you
can
create
arbitrary
applications
by
specifying
the
rules
of
the
game
in
this
DNA?
Everybody
knows
what
the
rule
is
of
that
particular
game
on
one
network,
each
DNA,
the
hash
of
the
DNA
itself
is
the
network,
hash
and
so
hollow
chain
is
built
on
thousands
and
thousands
of
networks,
because
you
should
think
of
each
one
of.
B
A
So
for
people
who
are
like
in
let's
say
coming
from
a
theme
world
like
I
can
actually
say
that
DNA
is
actually
a
smart
contract.
It's
not
very,
and
then
each
kind
of
agent
is
an
account
and
there's
a
smart
contract
which
kind
of
tracks
or
like
I,
mean
it's
not
really
an
account.
But
it's
like
you
can.
B
B
Can
buy
you
could
look
at
it
that
way
yeah,
but
in
the
theorem
of
course,
what
you're
trying
to
do
is
simulate
one
computer
yeah,
so
yeah
I
mean
here
it's
like
we're
not
trying
to
do
that.
What
we're
trying
to
do
is
actually
separate
that
out
and
understand
that
these
computers
actually
are
decentralized
and
are
distributed
and
that
there
are
different
contract
different
sub.
B
Different
levels
of
security
and
different
levels
of
validation
that
are
needed
in
different
context,
instead
of
the
ultimate
blockchain
trustless
context,
which
carries
with
it
a
very
high
price.
So
you
can
do
you
can
tune
the
price
of
what
you
do
to
the
context
of
the
application
that
you're
writing.
That's
that's
another
differentiating
and
interesting
thing.
A
B
But
the
thing
that's
slightly
different
about
our
DHT
and
the
reason
why
we
didn't
stick
with
that
is
that
we
allow,
when
you
create
one
of
those
nodes
and
or
one
of
the
entries
in
the
chain,
that's
what
we
call
them
a
chain
entries
and
you
publish
it
to
the
DHT.
Basically,
what
you've
done
is
you've.
B
You
have
an
entry
which
has
some
kind
of
hash
and
so
you're
publishing
the
content
and
the
hash,
and
the
entry
also
has
a
header
associated
with
it
right
because
that's
where
the
header
is,
and
it
and
and
the
entry
is
the
content,
because
this
is
because
what
the
DHT
is.
Is
the
content
addressable
store?
What
you
do
off
of
the
DHT?
Is
you
do
gets
on
the
hash.
C
B
A
B
A
sparse
place,
so
what
we've
allowed
is
this
notion
of
creating
a
graph
inside
of
a
DHT
where
you
say:
there's
a
base
which
is
a
which
is
some
hash
and
and
then
a
tag
and
a
target
which
is
another
hash.
So
you
can
do
you
can
use
the
tag
to
semantically
say
what
the
graph
relationship
is
between
the
base
and
then,
when
you're
doing
a
get
request
on
the
DHT.
B
You
can
get
at
the
content
of
entry,
but
you
can
also
get
a
list
of
the
links
by
tag,
so
you
can
find
out
what
things
are
related
to
other
things.
Example
back
to
the
Twitter
clone
example.
You
may
want
to
have
follows
so
you
may
have
a
you
may
create
a
well-known
entry
that
is
related
to
your
or
you
might.
Let's
see
what
would
be
a.
B
So
there's
a
more
complicated
way
of
doing
this,
that's
a
better
way
of
doing
it
because
you
don't
want
to
load,
tons
and
tons
of
actually
here.
Let's
do
this
example,
so
let's
do
the
same
thing
with
the
Twitter,
so
remember
how
the
second
entry
on
the
chain,
so
here's
the
DNA.
The
second
entry
is
your
ID
right.
A
B
It
depends
on
what
the
content
is
right,
because
the
content
could
make
it
1
to
end
you.
Can
you
could
do
any
kind
of
graph
you
want?
If
you
wanted
to
do
stuff,
you
could
put
crazy
things
in
the
tags.
We
don't
really
recommend
that,
but
probably
not
the
best
design
principle,
but
that
way
we
can
have
discovery
of
concepts
in
your
application
in
the
distributed
hash
table.
So
that's
one
of
the
pieces.
That's
added
to
our
notion
of
a
distributed
hash
table.
You.
A
C
A
A
B
On
a
nearness
algorithm
to
between
their
agent
hash
and
the
hash
of
the
entry
that
you're
trying
to
store
so
but
yes,
that's
related
to
the
to
the
linking
where
you
can
do
a
get
operation
on
the
base
or
on
any
entry
hash,
but
you
can
also
do
a
get
on
the
links
on
that
hash
to
find
the
other
stuff.
That's
there.
C
B
A
B
How
could
you
do
that?
Well,
I
mean
you
can't,
except
you
could
do
that,
so
we
can
talk
about
how
there's
lots
of
different
ways
to
manage
indexing.
If
it's
a
small
community,
you
could
just
create
a
directory
and
put
everything
on
that.
Well,
you
could
create
like
a
hash
whose
key
is
directory,
I
mean
whose
value
is
directory,
and
then
that
will
be
a
well-known
thing
and
everybody
could
look
at
it.
That's
if
you're
creating
an
app
for
a
small
community
like
Slackware.
You
want
me
to
have
you
know
hundred
thousand
ten
thousand
people.
B
That
would
be
fine.
That
would
be
sustainable.
That's
getting
on
the
edge
of
that.
If
you
wanted
to
do
much
larger
scale
indexing
where
you're
indexing
content
like
if
you're,
if
it's
a
Wikipedia
style
app,
then
we
have
a
pattern
where
we
have
a
separate,
a
whole
separate
DNA
on
a
separate
Network
where
nodes
volunteered
to
be
indexers.
C
A
B
B
Depending
on
the
context,
yes,
but
if
it's
a
Twitter
context,
does
it
really
matter
it's
been
signed
by
the
provenance
of
the
person?
Who
did
it?
That's
all
you
care
about.
You
might
need
to
do
that
so,
for
example,
in
the
currency
transaction
one
you
would
do
that
every
single
transaction
you
replay
back
to
the
beginning
to
make
sure
or
you
replay
back
to
a
checkpoint-
or
you
replay
back
to
some
known
entry,
where
the
somebody
also
co-signed
an
entry
with
a
node
or
a
notary.
B
A
B
I
mean
so:
we've
got
one
of
our
core
developers.
He's
been
dying
to
have
the
few
spare
hours
to
go
reimplemented
Bitcoin
on
top
of
college.
Shame
because
he
thinks
it
would
be
a
fun
project,
yeah
and
sometimes
people
do
think
of
hollow
chain,
as
just
only
state
channels.
That's
one
way
of
thinking
about
it
and
one
of
the
things
we've
thought
that
would
be
fun
is
oh
cool.
B
Let's
use
hollow
chain
as
a
place
to
implement
your
state
channels
for
etherium,
smart
contract
and
and
then
we're
interested
to
see
how
many
things
would
start
getting
removed,
because
in
the
end,
in
our
experience
all
you
almost
all
use
cases
not
all
use
cases,
but
almost
all
use
cases.
When
you
do
the
mine
flip
from
the
data-centric
to
the
agent
centric
point
of
view,
you
come
up
with
a
slightly
different
way
of
solving
the
same
problem
that
doesn't
require
can
consensus
the
way
blockchain
solutions
do
well.
A
I
guess
the
question
mainly
is
like
getting
to
the
same
state
between,
like
you
do
at
some
point.
If
specially,
if
you're
dealing
with
like
money
right,
you
do
want
to
make
sure
that
kind
of
this
is
something
that
everybody
would
also
agree
on,
because
if
you
want,
if
you
own
a
mana
one,
if
you
want
to
keep
moving
this,
like,
let's
say
somebody
sent
you
money
before
you
can
move
this
money
into
somebody
else.
A
You
kind
of
want
to
make
sure
that
you
know
people
would
agree
that
you
have
this
money
in
the
first
place
right,
so
this
is
kind
of
even
if
it's
agent
centric,
like
you
at
the
end
care
about
yourself
and
that
your
payments
will
get
accepted.
So
and
that's
why
I
like
the
question
is
yeah
depending
on
how
you
implement
it,
it
may
take
a
while
it
kind
of
all
the
sources
of
where
you
got
this
money
from
yeah.
Well,.
A
The
point
here
is
that
when
you
go
in
China
and
you
want
to
buy
a
cup
of
coffee
there,
you
want
to
make
sure
you
can
do
it
as
well.
Right,
that's
that's
where
it's
like
yeah.
It
may
be
like
at
any
single
point
when
you're
buying
something
like
you,
don't
really
need
world
to
know,
but
the
problem
is
when
you
are
in
that
part
of
the
world.
You
also
want
to
know.
That's
the
point.
B
B
B
That's
that
seems
real
to
me
right
now,
rather
than
this
other
way
of
like
let's
have
one
hard-coded
reality
that
exists
and
and
I
think
the
claim
that
we're
making-
and
this
is
it's
really
about
when
you
have
an
architecture,
that's
based
on
what
reality
really
looks
like
they're,
much
more
likely
to
get
decent
solutions
at
different
scales
over
time,
and
we
know
that
reality
looks
like
lots
of
agents
and
lots
of
viewpoints
playing.
This
is
wide.
It
is
so
freakin
awesome,
because
you
can
branch
and
merge.
B
Yeah,
and
do
you
think
that
that's
actually
the
right
way
it's
supposed
to
go?
Yeah
I'm,
just
can't
wait
until
we
watch
that
change,
because
github
is
exactly
like
what
al
had.
You
might
be
too
young
to
remember
this:
a
o
L
before
there
was
the
web.
They
were
these
rooms
where
there
was
content
and
it
was
all
siloed
inside
of
AOL,
and
there
was
another
silo
inside
of
Jeannie
along
comes
HTTP
as
a
protocol
that
allows
us
to
spread
that
out.
B
It's
the
same
kind
of
thing,
with
github
when
github
turns
into
a
protocol
ie
a
set
of
DNA
in
a
game
that
we
can
play
together,
then
we
have
a
different
space
of
what
it
means
to
do:
project
management.
And
yes,
there
is
this,
going
back
and
forth
between
the
the
centralizing,
the
large-scale
the
one
place
to
go,
look
at
a
reality
and
then
back
into
the
agent
centric,
and
that's
the
that's.
Why
we're
not
only
agents
entering
in
fact
we're
we.
B
B
So
so,
like
the
or
another
thing
they
do,
is
they
publish
something
forward
and
they
say:
okay
I
made
this
transaction.
Then
I
cut
this
off
my
chain
and
do
another
one
right.
Well,
you
both
of
these
got
published
to
the
DHT
right,
so
somebody
out
there
is
going
to
see,
wait,
the
same
person
and
they
check
the
chain
and
they're
like
there
are
two
things
that
showed
up
inside
that
chain.
That
should
be
at
the
same
place,
and
this
is
clearly
a
fraudulent
player,
because
I
can
see
that
that's
the
case.
So.
A
But
but
I
mean
we're
you're
indexing
everything
but
hash
right.
So
here
you
know
to
one
person:
I
send
this
hash
to
another
person
else.
You
don't
you
like
its
most
published,
it's
both
on
the
HT
but
like
as
the
purse
as
like
another
agent
that
observes
this
right,
I'm
telling
him
hey.
Here's
your
the
data
you
looking
for
is
that
this.
B
A
B
So
I'm
about
to
write
down
in
my
book
and
you're
about
to
write
down
a
plus,
yeah
right
and
so
I
go
and
I
say.
Give
me
your
chain
I
know:
I
I
say
so:
there's
going
to
be
a
pre-negotiate,
there
may
be
a
pre
negotiation
phase.
Where
you
tell
me
what
the
header
of
your
chain
is
and
I
do
a
get
and
I
look
on
the
DHT
I'm
gonna
find
something
different
on
the
DHT.
Then
you
just
told
me,
but.
A
B
A
B
C
B
A
B
B
B
Let's
see
if
we
start
again
and
let's
draw
this
up
and
make
it
clear
for
the
use
case
that
you're
asking
for
and
let's
also
actually
do
it
a
little
bit
more
carefully
so
that
it
shows
correctly.
So,
let's
see
here
so
if
let's
say
that
I
start
out,
I've
got
my
DNA
and
I've
got
my
ID
all
right
and
so
I
have
a
balance
of
zero
and
I
want
to
do
a
transaction
with
you
and
so
you've
got
your
DNA
and
you've
got
your
ID
and
so
I'm
going
to
we're.
B
Gonna
have
a
negotiation
phase
where
I
say
we're
about
to
make
a
transaction,
and
you
say
you're
going
to
make
a
transaction,
and
so
we
both
sign
the
transaction
ahead
of
time.
So
we
have
that
what
the
content
of
this
thing
is
going
to
look
like
beforehand,
and
then
it's
going
to
have
a
header
in
which
you
sign
something
and
header
in
which
I
that
the
signature
of
this
entry,
where
you're,
what
you
know
ten
dollars
for
the
coffee
and
I'm
plus
ten
dollars
for
the
expensive
coffee
all.
B
Right
and
so
then,
this
is
the
content
which
shows
this
is
the
value
of
the
transaction
and,
of
course,
every
one
of
these
entries
has
headers
off
of
it,
which
have
in
it
the
fact
that
it
has
my
signature
and
it
has
the
hash
of
the
header.
In
fact,
actually,
that's
what's
linked
right,
you
know
in
any
chain,
and
we
always
know
that.
That's-
and
this
is
a
combination
of
both
of
those
things
right.
B
Ok,
so
we
are
preparing
this
this
entry
together,
where
we
knew
that
that
was
what
was
happening
and
so
I
signed
this
here.
Let's
do
it
like
that
and
because
that's
the
content,
okay.
So
in
this
situation
now
this
got
published
to
the
DHT.
So
we
know
that-
and
we
know
that
the
starting
of
the
rules
of
the
DNA
said
that
the
credit
limit
is
100.
Each
of
us
have
100
credit
limit,
so.
B
You
can
see
my
chain
to
the
bottom
and
you
can
see
that
I'm,
not
overspending.
I
can
see
your
chain
to
the
bottom
to
know
that
you're
not
engaged
in
other
things,
that
I
don't
care
about
or
that
I'm
that
I
don't
like,
and
this
is
fine
now
we're
moving
to
the
next
scenario.
Right
where
we
publish
know.
C
A
B
Fit
actually,
this
is
fun.
You
know,
I'm
gonna
do
I'm
gonna
actually
have
you
solve
the
problem
because
from
this
book
this
is
a
really
interesting
exercise.
So
thinking
from
the
agent
perspective,
what
do
you
need
to
publish
to
the
DHT
to
actually
make
this
work,
and
what
questions
is
that
this
is
exactly
what's
great
about
whole
chain?
Is
it
makes
you
actually
think
about
the
real
problem,
that's
necessary
for
the
exact
situation
you're
in
okay?
So
basically,
this
is
a
roll
back
situation
where
the
credit
limit
was
10.
B
B
Addressable
and
you
can
publish
headers
as
content
if
you
want
to,
and
when
you
get
a
hash,
you
can
see
what
header
was
associated
with
that
hash,
but
just
you
need
to
get
a
hash
right,
yeah,
but
but
so
you've
got
hashes.
We've
got
linked.
We've
got
a
link
to
the
HT.
What
do
we
do
with
the
link
DHT
to
solve
this
problem?.
A
B
So
then,
there's
other
ways
to
if
you
don't
like
that,
if
you
think
that
there's
problems
with
network
partitioning,
you
can
also
have
notaries,
well-known
notaries.
If
you
want
in
your
particular
well-known,
modernise,
is
also
network
partitioning,
that's
partly
yeah,
that's
right
that
so
that
yeah
that's
interesting,
but
you
know
sometimes
one
of
the
ways
and
we
handle
network
partitioning
is
by
having
Sentinel
nodes
and
the
central
nodes.
B
B
A
B
B
What
holds
it,
but
we
have
a
different
DHT
that
we're
developing,
because
that
the
but
math
is
really
hard
for
calculating
neighborhoods
when
you're
using
a
tree
and
things
don't
look
like
they're
in
the
same
neighborhood
from
different
vantage
points
in
the
in
the
tree
in
academia
DHT,
and
we
really
wanted
to
be
able
to
have
a
Euclidian
geometry
for
figuring
out
what
the
night
neighborhood
is,
rather
than
a
non-euclidean
one,
which
is
really
really
weird.
So.
B
We're
we're
developing
something
we're
calling
our
DHT
it's
in
development,
and
it's
pretty
it's
interesting.
We
did
some
prototyping
of
it.
It's
not
completely
developed,
but
the
basic
idea
works
like
this.
If
you
take
all
the
hashes
of
the
nodes-
and
you
put
them
on
a
circle-
and
this
is
I-
might
be
getting
this
wrong
because
I'm
not
the
main
engineer
on
this,
but
this
is
it's
pretty
close
to
what
it
is
and
you'll
get
the
idea
about
how
to
do
this.
B
So
if
you
think
about
any
particular
agent-
and
let's
put
that
line
there
as
an
agent
agents
hash,
then
you
can
draw
an
arc
on
this
circle
as
actually
it
should
be.
They
should
be
equal
in
length.
They're
pretend
that's
the
same.
This
is
the
arc
of
all
of
the
hashes
of
the
entries
that
this
agent
says
it's
responsible
for
right,
and
then
you
have
a
second
arc,
which
is
the
arc
of
all
of
the
agents
who
it
indexes
right.
B
C
C
B
B
B
B
B
C
B
Then
publish
what
we
call
a
warrant
and
then
get
you
block
list
from
that
particular
network.
So
yeah
you
can
do
grinding.
You
can
do
there.
There
are
some
particular
places
where
it's
some
civil
defects
are.
Are
we're
susceptible
to
that
in
most
places,
but
for
the
most
part,
what
we
see
is
that
that
would
be
actually
really
hard,
because
it
just
takes
one
good
actor
to
show
a
bad
actor
yeah.
B
This
is
another
interesting
thing
about
this
DHT,
where,
instead
of
the
agent
being
so
you
think
of
the
agent
as
one
portion
and
then
what
it's
the
hash
of
the
content.
These
things
is
what's
being
referred
to
in
arc.
You
can
do
the
same
thing
where,
with
the
nodes
for
discovery
of
nodes,
where
the
agent
has
this
ring,
but
what's
in
the
hash,
is
the
transport
address?
There's.
B
A
B
So
well,
the
validation
happens
is
whenever
you're
doing
a
publish
and
you
found
out
who
was
in
your
neighborhood,
who
needs
to
store
it.
You
published
to
them
directly
because
by
it
that's
the
the
meta
rules
of
the
game,
then
they
go
and
they
run
the
DNA
on
and
run
whatever.
The
rules
are
locally
on
their
node
to
see.
If
the
data
that
you're
publishing
follows
and
that
may
involve
doing,
gets,
there's
a
there's
another
there
that
may
involve
doing
gets
on
the
network
to
find
out
whether
things
are
true.
B
But
there's
another
interesting
thing
we
do
is
we
have
a
validation
package
that
gets
sent
or
can
be
queried
for
during
that
during
that
validation
phase,
so
that
you
can,
because
what
is
necessary
to
do
validation
is
also
contact
specific.
So
you
can
query
back
the
original
node.
You
can
get
the
full
chain
of
the
original
node.
You
could
query
and
and
see
whether
it
fits
into
the
rules
of
the
game.
So
how.
B
Could
get
very
expensive
and
for
if
and
in
in
the
context
where
it
would
get
expensive,
then
you
would
do
other
things
to
make
it
cheap.
That
would
be
an
applicant
like
I
was
saying
there
would
be
checkpoint
nodes
where
you
summarize
the
state,
and
you
know
that
you
only
have
to
go
back
that
far
because
it's
been
validated
by
other
nodes
and
you
can
validate
that
checkpoint.
Things
like
that.
I
mean.
B
Could
no
absolutely
you
could
use,
you
could
use
consensus
and
we're
not
against
that
at
all,
I
mean
there
are
some.
There
are
some
really
reasonable
use
cases
for
for
a
block
change.
I
mean
there
are
other.
There
are
other
efforts
out
there
that
have
the
same
kind
of
agent
centric
approach
and
one
of
the
things
that
they
end
up
doing
is
using
things
like
a
blockchain
for
finding
notes,
just
no
discovery,
and
because
you
publish
that
to
that
blockchain
and
you
go
find
that
that's
one
one
case
that
is
somewhat
reasonable.
I.
B
B
So
it's
turning
it
on
its
head.
It's
saying
we
start
from
state
channels
and
then,
if
you
need
that,
maybe
that's
a
special
case
where
you
use
it,
where
it's
actually
okay
to
spend
that
much
power
or
that
much
whatever
the
proof
of
X
is
and
whatever
consequences
come
from
that
proof
of
X
context-specific.
A
B
So
now
it's
a
new
technology.
Exactly
so
in
our
prototype,
the
original
prototype
that
I
wrote.
What
we
did
is
we
had
two
two
interpreters
in
there,
because
that's
what
I
found
easily
in
the
Ingo
libraries,
we
had
a
lisp
interpreter
and
we
had
a
JavaScript
interpreter
and
you
could
write
your
DNA
in
any
one
of
those
languages
and
then
it
would
run
because
the
whole
point
is
it
just
needs
to
be
hashable.
So
everybody
knows
they're
running
starting
from
the
same
hash.
B
Then
what
we
decided
is
that
we
wanted
to
use.
We
did
the
flip
to
rust
for
all
the
reasons
that
one
flips
to
rust
because
of
its
speed
and
its
quality,
and
we
hit
the
same
thing
that
everybody
hits
with
rust
his
learning
curve,
which
was
a
problem,
but
the
big
deal
was
that
we
could
use
wasum.
We
could
use
Waze
me
from
parody
to
have
a
generic.
B
Deterministic
virtual
virtual
machine
engine,
and
then
we
could
take
advantage
of
all
the
new
languages
that
would
end
up
compiling
to
Wasson,
which
we
knew
would
be
coming
down
the
pike.
So
we
have
a
was
an
interpreter
that
we
compile
everything
to.
Currently
people
write
their
DNA's
in
rust,
there's
an
H
DK
for
all
the
basic
functions
that
are
that
you
call
it
called
hdk
call
the
chain
development
kit,
exactly
yeah
I
just
spit
this
out.
So
that's
our
hdk
and
and
we're
looking
forward
to
HD
case
in
other
languages.
B
We're
excited
about
that
and
actually
we're
hoping
that
somebody
in
the
community
will
build
the
web
simulator
case.
That's
the
way
we
wanted
to
go,
and
that
was
the
initial
way
that
goes.
Yeah
yeah,
that's
cool,
so
we
have
a
bunch
of
other
stuff
too.
You
know
we
have
a
testing
environment
that
allows
you
to
describe
scenarios
and
create,
like
in
virtual
agents
and
then
do
do
the
scenario
run.
B
The
scenario
see
what
happens
so
you
bet
you
basically
run
through
this
process
and
you
create
tests
for
that
watch
if
they
fail
or
don't
fail,
and
so
there's
there's
a
whole
bunch
of
tooling
that
we're
building
alongside
everything,
to
make
it
easy
for
folks
to
develop
in
this
and
it's
been
pretty
fun
to
watch
I
mean
we
started
out
with
our
developer.
Our
dev
camps
that
were
online
death
camps
and
people
really
hit
the
wall
of
rust,
but
then
each
time
the
tooling
has
come
up
and
it's
like.
B
A
B
C
B
B
Replication
and
issuing
of
identity
associated
with
I
mean
that
that
lets
you
actually
create
replication
keys
that
you
can
then
use
if
you
need
to
revoke
a
key
because
key
gets
lost
and
so
on,
and
then,
where
there's
a
personas
app
that
does
identity
stuff,
that
you
can
then
use
across
different
DNA's
that
you
could,
you
can
say,
hey
I,
need
this
little
bit
of
persona
data.
That's
on
that
chain
or
I
need
a
zero
knowledge
proof
of
that
data.
That's
on
that
on
that
particular
chain
and
get
a
little
value
out
of
it.
A
B
B
Well,
the
other
thing
that
it
describes
is
what
is
the
interface
to
for
the
user
interface
to
call
into
this
particular
DNA
right?
And
so,
if
you
do
a
function,
that
would
that
if
you
call
a
function,
what
like
post
in
your
Twitter
app
that
function
may
do
a
call
to
another
DNA
to
get
some
value
around
your
the
name,
that's
associated
with
that
account,
because
the
name
actually
comes
from
the
personas
app.
The
posting
has
doesn't
even
know
who?
What
name
is
it?
Is
there
that
comes
from
another
app?
A
A
B
What
I'm
saying
is
that
if
there
is
so
if
the
DNA
includes
functions
that
are
called
that
actually
do
the
addition
of
an
entry
onto
the
chain
right
yeah,
so
so
the
consequence
yeah
so
post.
So
that's
a
function,
that's
available
message,
etc.
So
there
would
have
in
this
particular
app.
There
would
have
been
probably
at
initialization
time.
There
would
have
been
a
time
when
you
went
to
personas
and
you
got
the
name
or
some
value
or
an
avatar.
B
A
So
let's
say
you
want
to
post
a
message
and
you
want
to
make
sure
that
whoever
posted
message
has
a
persona
in
the
personas
app
okay,
so
like
how
does
this
validity
function
looks
like
for
the
post
to
actually
validate
that
another
app
contains
this
information.
So
can
you
inside
the
DNA,
can
you
fetch
other
items
from?
Do
you
validate
and
like
how
much
can
you
do
there
in
a
way
so.
B
That's
a
great
question:
it's
a
complicated
thing.
What
what
what's
going
on
with
that
is
that
invalidation?
We
have
two
different
stages,
because
it's
in
there
there's
two
different
types
of
validation,
essentially
there's
the
preconditions
of
validation
and
then
there's
the
deterministic
aspect
of
validations.
So,
for
example,
one
of
the
things
that
you
might
want
to
validate
is
that
a
particular
link
exists
right,
but
that
is
a
non-deterministic
fact,
so
you
can't
run
the
final
validation
rules
until
you
have
gathered
all
the
information
that
you
need.
B
That
may
be
non-deterministic,
because
the
validation
rules
themself
have
to
be
deterministic,
and
so
there
is,
there
are
two
different
phases
of
validation,
and
so
in
one
you
can
do
fetches
and
you
can
do
things
like
check
to
see
if
links
exist
and
if
they
exist.
If
the
preconditions
exist,
then
you
can
actually
do
the
final
validation
which
we'll
call
it
which
will
commit
something
into
a
chain.
So
yes,
the
answer,
your
question
is
yes,
I'm,
just
giving
you
a
little
bit
more
context
because
of
what's
true
about
the
world.
B
B
A
B
You
can't
just
destroy
links,
they
don't
go
away
forever.
You
can
always
look
at
the
history
and
see
if
they
were
there,
so
the
the
links
are
marked
as
deleted,
because
it
is
an
append-only
log,
so
you
can
always
go
back
and
reevaluate
the
context
at
the
time
that
it
was
done.
So
this
would
this
would
be
a
case
like
somebody
stopped
doing
something
and
they're
not
even
online.
B
B
Okay,
so
now
you're
asking
implementation
questions.
We
have
a
thing
that
we
call.
We
have
two
things:
we
have
a
cast
our
content-addressable
story
that
we
use
for
storing
most
everything
and
on
top
of
the
store
on
top
of
the
cast,
we
have
something
called
an
EI
VI,
which
is
an
entity
attribute
value
index
store,
which
kind
of
looks
like
a
DHT
with
links.
It's
the
same
kind
of
thing
mirrored
inside
our
storage
and
I
mean
I'm
there.
Ea
V's
are
pretty
typical
data
storage
systems
for
sparse
data.
B
They've
been
used
for
medical
data
for
a
long
time,
and
the
index
is
the
thing
that
allows
you
to
find
what
was
the
latest
one
by
history
so
that
you
can
do
like.
If
you
have
a
hash,
you
put
something
in
it.
Yeah
I
mean
it
looks
exactly
like
that
thing
that
I
did
with
the
the
post
in
the
target,
but
not
again
now,
I'm
really
jumping
into
a
part
that
may
be
more
than
what
you
were
asked.
A
B
You
can
on
each
individual
node.
We
use
a
similar
pattern
inside
a
content,
addressable
store
for
storing
all
the
data
that
we
need
to
store.
So
we
can
store
a
link
using
the
same
pattern
in
our
in
our
store,
but
there's
also
an
index.
On
top
of
that.
That
allows
us
to
know
what
was
the
latest
one,
and
so
you
can
basically
I
mean
inside.
C
B
B
All
of
this,
so
at
this
part,
I
may
be
getting
slightly
wrong,
but
that
we
do
stuff
exactly
like.
We
have
a
hat.
We
restore
something
whose
hat
whose
content
is
the
word
deleted
and
then
on
deleted.
It
points
to
all
the
links
that
were
deleted
and
but
it's
base
it
has
I,
think
that's
the
way
they
do
that.
No,
no.
A
Because
the
problem
is
any
of
this
is
that
you
can
have
a
double
like
double
hat
on
on
the
on
the
links
and
like
any
upend
on
the
index
I,
it's
the
problem
always
is
like
having
two
of
append-only
because
of
either
conflict
or
malicious
attack.
So
that's
why
I'm
going
there
like
I'm
like
we're
distilling
it
from,
but.
B
But
what
you're
seeing
is
the
the
thing
we
just
did
here.
You
can
do
inside
your
content,
addressable
store
as
well,
because
you,
if
you,
if
you
basically
in
your
content,
addressable
store
on
your
local
machine.
You
can
do
the
exact
same
thing
that
we
did
here.
You
can
store
a
link
to
what
the
current
head
is.
The
thing
that's
current
and
from
your
experience,
but.
B
A
B
B
There
are
actually
there's
this
thing
called
the
Finny
attack
and
when
you
do
neighborhood
stuff,
there's
a
bunch
of
other
use
cases.
But
what's
interesting
is
from
this
approach
of
in
the
agent
centric
approach?
There
always
seems
to
be
a
solution,
that's
appropriate
for
the
context,
so
I
keep
saying
that
appropriate
for
the
context,
because
that's
what
matters
so
much
if
we
want
to
have
any
scalable
decentralized
solution
has
to
be
scalable.
According
to
the
context,
I
mean.
B
Just
like
I'm
just
deciding
that
for
the
purpose
of
our
viewers
right,
that's
that's
a
key
key
thing
for
us
to
know
and
that's
like
a
message
that
I
want
to
keep
getting
across
and
and
it's
important
because
people
will
say
well,
but
what
about
blah
yeah?
That's
a
great
question,
fantastic
questions
now
think
about
it
from
an
agency
point
of
view.
What
about
it?
How
do
we
solve
that?
Because
that's
actually
the
way
it
were
the
world
works,
yeah.
A
B
You
create
the
world
and
you
and
you
believe
that
things
get
transferred
from
one
place
to
the
next
and
you
want
that
to
exist
in
the
digital
world.
Yep
you
need
that.
Go
ahead.
That's
fine!
If
you've
got
a
double
spend
problem
and
it's
trust
list,
there's
no
membranes
and
you've
got
double
spie.
It's
been
go.
Do
that
great
yeah,
but.
B
Know
if
you
want
apart
everything,
everything
else
in
the
world
and
but
and
the
other
thing
is
the
actual
mechanics
of
doing
a
mutual
credit.
Instead
of
coins,
it's
doable
at
scale
with
the
same
patterns,
it's
just
a
different
kind
of
validation
that
ends
up
happening
and
it's
happening
between
the
subsets
of
people.
So
here's
the
difference.
There's
a
lot
of
validation
to
handle
these
header
things,
there's
a
lot
of
different
cases
in
edge
cases
you
have
to
pay
attention
to.
B
But
what
does
end
up
happening
is
you're
still
only
doing
it
between
a
small
subset
of
the
nodes
on
the
network
in
the
blockchain
world.
Everybody
has
to
agree
for
that
block
to
get
chained.
So
you
end
up
having
that
big
long
clock
cycle.
That's
in
the
basic
pattern
is
that
clock
cycle
would
be
appending
up
a
blocks
and
creating
one
reality.
This
doesn't
do
this.
It
does
the
validation
in
the
subset
of
the
spaces
that
are
needed,
I
mean.
A
B
Simple
get:
let's
actually
use
a
really
benign
case,
which
is
a
network
partition,
so
somebody
like
I,
mean
in
the
Twitter
case.
You
might
have
this
where
somebody
says
this
is
my
my
Twitter
handle,
and
they
say
this
is
my
Twitter
handle
it
was
partitioned.
It
comes
back
together.
You
have
two
people
have
the
same.
Handles
you
want
to
have
a
rule
that
says
you
can't
have
the
same:
handle
okay,.
A
A
B
You
want
you
want
me
to
get
into
that
for
a
little
bit
sure
yeah,
okay,
so
when
you
detect
things
that
are
against
the
rules,
there's
a
whole
layer
of
what
we
call
warrants
that
can
be
issued.
So
if
you
detect
something,
that's
it
that's
against
the
rules,
and
you
believe
that
it's
maliciously
against
the
rules.
According
to
the
rules,
then
you
can
issue
a
warrant
which
is
you
publish
on
your
chain,
a
warrant
that
so-and-so
is
a
bad
actor
and,
according
to
the
rules
of
the
particular
game,
there
may
be
different
consequences.
C
B
What
the
other
agents
can
do?
Is
you
just
block
list
that
node
from
the
network
and
that
can
get
pushed
pretty
far
down
the
stack
in
the
implementation
that
we're
working
on
where
it
can
go?
It
can
get
block
list
all
the
way
down
to
the
transport
layer,
because
we
can
pass
that
into
the
networking
module
which
says.
Okay.
B
B
B
Okay
and
the
conductor
is
a
kind
you
can
think
of
it
as
the
virtual
machine
host
like
it's
the
it
or
the.
What
is
it
the
hypervisor?
You
could
think
of
it
about
that
way,
and
so
it
basically
runs
instances
of
different
DNA's
yeah
right
and
it
manages
the
any
bridging
that
needs
to
happen
between
them
and
then
the
other
thing
that
it
does.
A
Monster
than
so,
this
guy
has
so,
let's
called
DNA
one
DNA
to
DNA
one
DNA
2,
and
this
has
DNA
too,
and
it's
kind
of
this
guy.
So
this
one
is
malicious,
so
this
guy
bands
bands
him
will
key
propagate
to
this
note,
3
write
the
information
that
this
note
is
malicious,
even
though
this
guy
they
are
connected
right.
They
connected
about
yeah.
B
The
idea
of
there's
the
node
ID,
which
is
at
this
level,
there's
the
DNA
ID.
That's
at
this
level.
There's
a
transport
ID,
that's
at
this
level,
so
per
DNA.
You
can
make
a
decision
about
that.
Do
you
want
that
to
like?
Is
your
warrant
DNA
specific
or
is
your
warrant
node
specific
I'm,
pretty
sure
we're
gonna
have
to
do
that?
B
I
mean
a
lot
of
this
part,
isn't
complete
and
in
the
development
of
it,
because
this
is
where
the
phase
that
all
of
us
are
in,
but
but
there
are
a
bunch
of
there
are
cases
where,
indeed
right.
If
this
one
is
malicious,
you
would
you
would
propagate
that.
This
network
has
been
compromised
and
that's
a
good
thing,
because
then
this
one
is
saved
from
whatever
other
malicious
things
that
might
be
happening.
That
way,
I
mean
it
could
be.
It
could
be
denial
of
service
attacks
which
are
DNA
independent.
A
B
So
the
DP
ki,
the
distributed
public
key
infrastructure
DNA
is
similar
to
that,
because
pretty
much
everybody's
needs
to
have
a
way
of
revoking
keys
and
getting
keys
back
in
and
there's
a
bunch
of
other
things.
That'll
be
like
that.
There's
there's
the
App
Store
where
or
the
DNA
store,
which
which
publishes
other
DNA
s
and
most
people
will
be
likely
running
that
most
people
will
likely
be
running
some
version
of
a
personas
DNA,
there's
a
bunch
of
things
that
a
lot
of
people
will
be
running.
It's
just
like
on
your
UNIX
box.
C
B
C
B
A
A
B
On
the
game,
you're
playing
right,
so
you
choose
the
game
and
in
that
it's
up
to
you
to
decide
whether
you
want
that
or
not,
if
you're
doing
Wikipedia.
How
much
do
you
need
to
store
like
and
we've?
Actually,
somebody
in
our
team
did
a
little
bit
of
math
about
how
many,
if
you
store
one
page
of
the
Wikipedia
and
what
how
was
it,
you
might
I
think
you
we
we
needed.
C
B
Is
not
even
I
mean
so
yeah,
let's
even
say
it's
two
orders
of
magnitude,
you're
pretty
much
done
it
and,
of
course
you
know,
it'll
depend
on
the
on
the
application
that
you're
running
right
and
what,
how
much
of
it
I
mean.
There
are
plenty
of
applications
where
everybody
will
store
everything,
because
the
your
your
running
of
an
application
with
a
small
team.
That's
you
want
your
calendar
and
your
shared
hacking,
DS
and
your
shared
spreadsheets.
Everybody
shares
a
copy
of
everything
and
that's
fine
and
it's
that's.
A
B
Large,
it's
difficult
if
it
was
the
Internet
Archive
which
I
found
out
is
in
the
petabytes,
that's
big,
and
also
if
you
were
doing
trying
to
do
a
YouTube,
if
you
were
trying
to
run
a
YouTube
app
well,
you
know
that
everything
you
would
do
here
you
would
do.
We
actually
had
somebody
sharding
up
video
and
writing
a
DHT
in
which
the
chunks
of
the
video
were
were
distributed
around
and
then
could
be
pulled
down
in
and
and
reassembled.
B
Just
like
any
web
torrent
type
thing,
I,
don't
know
how
about
how
that
we're
going
might
scale
actually
really
beautifully,
because
you
have
micro
channels
instead
of
thinking
that
there's
all
of
YouTube
there,
there's
micro
channels
of
YouTube
in
people
store
the
part,
that's
important
to
them.
I
think
it's
it's
scale
is
actually
really
interesting
way.
Yeah
and.
A
A
B
You
can
always
go
to
whole
chain
org.
You
can
go
to
the
github
repo
github
slash
hollow
chain.
There's
hundreds
of
repos
in
there
of
different
parts
of
the
project.
I
think
hollow
chain.
Rust
is
the
main
repo
where
core
is
being
built
out
of
right
now,
and
you
can
always
go
to
hollowed-out
host,
which
is
the
big
app
space
that
we're
the
premier
use
of
hollow
chain.