►
From YouTube: Baseline Protocol - The (BASE)ics - Baseline Architecture Simplified for Everyone ft. Keith Salzman
Description
This presentation was part of our inaugural #AmsterBased event, live from Amsterdam, Netherlands!
AmsterBased is a Baseline Protocol event as part of EFDevConnect
Details on the protocol can be found at baseline-protocol.org
The (BASE)ics: Baseline Architecture Simplified for Everyone
By: Keith Salzman, Zero Knowledge Developer at ConsenSys Mesh
A
A
A
A
In
your
mind
that
are
really
necessary
to
make
it
over
that
initial
learning
curve
of
understanding.
You
know
what
what
are
the
concepts
behind
baseline?
What
are
these
strange,
fluid
architectures
behind
the
the
baseline
protocol
itself
from
a
standards
point
of
view,
so
there
there
are
a
couple
things
that
I
will
ask
you
to
keep
in
mind
during
this
talk,
especially
if
you're
new.
You
know
that
I
I'm
presenting
from
the
point
of
view
that
you
know
the
the
baseline
protocol.
It
is
a
protocol.
A
A
You
know
maybe
we're
just
saying
it
is
existing
and
it
is
acting
as
it
should
be
for
the
point
of
this
example
right
and
that
the
implementation
in
real
life
may
look
very
different
depending
on
you
know
the
the
actual
case,
I
won't
say
use
case,
because
stefan
doesn't
like
that.
The
example
right
that
you
are
implementing
right,
okay,
I
think
I
think
that's
it.
Are
you
guys
ready
to
begin?
A
Okay,
there
you
go
so
before
we
kind
of
dive
into
a
real
simplified
example,
to
kind
of
elucidate
some
of
the
architectures
behind
the
implementation
or
behind
the
the
protocol,
the
standard
itself,
just
of
course
starting
off
with
a
little
bit
of
background.
So,
of
course,
we
have
baseline
protocol
launched
march
2020.
We
have
the
co-founders
microsoft,
ui
consensus,
open
source
standards
projects.
A
This
project
is
governed
by
oasis,
the
open
standards
body
and,
of
course,
we
have
you
know
plenty,
as
you
can
see
all
of
our
icons
of
all
of
these
great
sponsors
we
have
here
so
many
great
icons.
Please
look
at
them
now.
Yes,
some
of
them
are
here
today.
Some
of
them
are
not
okay
and
and
just
to
kind
of
set
the
the
base
the
baseline
set
the
ground
behind.
A
You
know
what
what
was
the
initial
question
kind
of
asked
and,
of
course
I
I
was
not
there
during
its
inception
right,
but
what
was
the
initial
question
or
or
something
close
to
it,
that
baseline
or
the
the
co-founders
of
baseline
were
kind
of
asking
themselves
to
solve?
Well,
if
you
listen
to
stefan,
you
probably
got
it
right,
which
is
it
you
know
in
today's
world.
A
We
have
all
of
these
enterprises
who
are
holders
of
this
complex
data
and
they
are
attempting
to
or
should
be
attempting
to
communicate
with
each
other
right,
and
although
that
does
happen
today
in
some
form
that
this
there
can
be,
this
can
be
very
problematic
in
terms
of
you
know.
How
do
we
speak
to
each
other
in
an
efficient
low-cost
way
where
we
can
guarantee?
We
are,
are
synchronized
and
we
have
security
data
integrity
all
these
things
right.
A
A
Try
to
carry
this
definition
in
your
mind,
we
have
a
standard
that
enables
two
or
more
state
machines
to
achieve
and
maintain
data,
consistency
and
workflow
continuity
by
using
a
network
as
a
common
frame
of
reference.
So
this
is
very,
very
basic
right.
We
have
the
standard
baseline
itself
a
guideline.
A
So
the
second
definition
here
the
set
of
tools
and
libraries.
I
think
this
one
is
a
little
bit
harder
to
wrap
your
mind
around.
You
may
be
asking
yourself,
you
know:
where
are
those
tools
and
libraries?
Well,
the
simple
answer
is
that
inside
the
baseline
repo,
while
there
are
core
packages
that
will
help
kind
of
define
or
interfaces
of
how
and
what
tools
should
be
implemented
that
really,
if
you're,
looking
again
for
those
concrete
tools,
you're
going
to
look
out
for
those
outwards
towards
those
concrete
implementations?
A
I
see
a
couple
of
yeses
all
right.
There
are
these
terms
and
concepts
I'm
going
to
keep
coming
back
to
the
slide.
If
I
can,
if
these
buttons
are
fast
enough
in
case,
we
need
to
define
some
concept
from
a
diagram
that
we're
looking
at
there's
a
couple
of
things
here
again
the
consensus
controlled
state
machine
that
I
mentioned
ccsm.
A
So
really
for
us,
these
are
logical,
constructs
they're
shared
you
know,
between
transacting
counterparties
of
let's
say
requesters
and
providers
and
implemented
on
the
ccsm.
So
I
think
it's
it's
it's
difficult.
Unless
you've
been
part
of
baseline
for
a
while
to
really
you
know,
wrap
your
head
around,
you
know
what
what
is
this
baseline
protocol
instance
and
where
does
it
exist?
A
You
know
out
in
the
ether
online
off
chain
on
chain
and
we're
gonna
discuss
that
a
little
bit,
but
for
a
lot
of
the
diagrams
we're
just
going
to
assume
this
thing
has
been
implemented
properly
and
try
to
see
the
overall
flow.
Okay
in
the
next
diagram,
we're
going
to
see
we're
going
to
look
at
work,
steps,
workflows
and
work
groups.
A
It
could
be
anything
it
could
really
just
be
sending
a
message
from
one
party
to
another.
In
this
case
we're
gonna
be
buying
some
product,
a
buyer
and
a
seller.
Okay,
and
we're
going
to
look
at
the
flow
of
just
a
work
group
from
a
high
level
and
then
I'm
going
to
dive
into
in
detail.
You
know
how
we
go
through
the
flow,
so
let's
go
ahead
and
do
that
right
now.
A
A
So
again
the
examples
today
they're
not
exactly
going
to
be
in
reality,
but
just
again
for
simplicity
and,
let's
say
a
work
group,
a
member
has
some
input
for
this
work
step,
so
that
could
be
an
actual
purchase
order
right.
So
if
you
decide
to
purchase
something-
and
they
may
include
based
on
the
agreement
between
the
buyer
and
seller,
the
two
parties
that
information
they
agreed
upon
as
well
as
some
kind
of
let's
say
proof
in
a
lot
of
instances,
you've
seen
us
mention-
maybe
zero
knowledge
proofs.
A
A
The
state
object.
That
is
passing
that
output
will
then
become
maybe
an
input
to
the
next
workflow,
which
could
be
something
between
a
seller
and
a
manufacturer
just
for
example.
It
could
be
really
anything
at
this
point
and
of
course,
work.
Group
b
will
have
its
own
bpi
subjects,
it'll
be
governed
by
some
master
agreement
or
agreement
that
they
have
and
something
similar
will
happen
here
again,
transaction
of
data
messaging,
depending
on
you
know,
what's
within
that
agreement
and
then,
of
course,
we'll
have
an
output
and
so
on
and
so
forth.
Okay,
all
right.
A
A
Okay,
you
know
we
have
a
request
for
a
purchase
order.
We
create
the
purchase
order,
it's
been
approved,
the
vendor
receives
it.
We
create
an
invoice
and
it
kind
of
goes
back
and
forth
right.
So
there's
not
to
say
that
there
aren't.
You
know,
of
course,
guarantees
in
this
current
system
today,
but
it's
it's
easy
for
us
to
see
how
this
can
get
messy
right,
how
you
know,
maybe
we
go
down
through
the
flow
and
realize
something
is
wrong
and
we
have
to
back
up.
A
There
has
to
be
some
kind
of
manual
reconciliation
and
at
what
cost
does
that
come
right?
I
think
everybody
here
or
online
has
obviously
dealt
with
these
kinds
of
things
in
their
life
and
it's
easy
to
imagine
how
we
can
have
these
systems
in
some
kind
of
weird
asynchronous
state
and
so
on
and
so
forth
right.
So
we
set
the
stage.
This
is
kind
of
the
the
problem
we're
talking
about.
It's
very
simplified.
There's
two
parties
here,
but
as
you
blow
this
up.
A
All
right-
and
so
here
is
that
kind
of
solution
applied
the
baseline
protocol
solution
applied
to
that
situation
right.
So
this
is
where
I'm
trying
to
make
the
connection
of
hey.
That's
the
problem
we
had
before
now
we're
gonna
go
through
the
actual
flow
in
detail.
I'm
gonna
go
through
the
flow
in
detail
of
you
know.
How
do
we
guarantee
that
we
can
avoid
having
to
go
synchronization
and
and
all
in,
let's
say,
hopefully,
a
trustless
environment
with
zkp's?
Again,
my
preference
all
right,
so
we
have
the
bpi
in
the
middle.
A
A
We
have
the
buyer
and
we
have
the
seller.
Okay,
so
let's
say
they
already
have
an
agreement
between
them.
There's
already
a
we
call
it
msa
a
master
services
agreement
between
the
two
parties
here
that
are
in
the
bpi
in
their
own
work
group
in
the
bpi
and
that
contract
logic,
which
will
I'm
going
to
say
it's
like
a
codified
contract
logic.
They
may
have
an
actual
like
legal
pr
paper
presentation
between
them
or
representation
between
them,
but
we're
going
to
codify
that
logic.
A
A
Then
you're
gonna
have
to
provide
this
certain
specific
data
information
whatever
it
is,
they
do
so
and
then
the
bpi
itself
has
this
tool
to
generate
a
cryptographic,
proof
that
we
are
in
compliance,
and
you
know
we
can
then
update
the
contract
state
that
this
purchase
order
is
in
compliance
so
far
right
now
what
that
cryptographic
proof
is
again
we're
not
worried
about
that
right.
Now
I
keep
having
to
make
plugs.
A
If
we
are
serious
else,
if
we
see
ourselves
as
a
buyer,
we
are
ready
to
send
that
proof
off
to
the
seller
right
now
how
we
send
that
to
the
seller,
whether
in
this
diagram,
seen
as
moving
through
the
bpi
or
if
we've
set
up
a
relay
or
some
kind
of
messaging
protocol
directly
between
them,
we're
not
going
to
get
into
the
specifics,
we're
just
going
to
say.
We
have
a
way
to
transfer
that
message:
protocol
over
we're
going
to
submit
the
order
with
the
cryptographic
proof.
A
So
we
have
all
that
data
required
by
the
seller.
The
proof
that
we
are
in
compliance,
maybe
hiding
some
private
input
and
we're
going
to
send
that
to
a
place.
The
seller
can
retrieve
it
right,
the
seller
retrieves
it
they
get
the
message
containing
the
order
and
the
cryptographic
proof.
The
first
thing
they
want
to
do
is
they're
going
to
want
to
validate
the
proof
right
again,
in
this
case
simplistic,
we're
thinking
of
a
single
proof.
A
A
So
if
we
get
a
negative
result,
we
we
already
know
that
whatever
was
sent
to
us,
it
is
not
compliant
with
what
we
agreed
to
right.
It
doesn't
need
to
go
beyond
that.
This
is
not
a
valid
order
right,
but
if
we
get
a
positive
result,
we
have
verified
this
proof,
and
then
we
say:
okay,
this
is
a
valid
order,
and
now
we
need
to
do
what
our
side
needs
to
do,
which
is
to
take
the
data
or
information
from
our
system
to
say
that
we
are
accepting
this
order.
A
This
will
generate
a
cryptographic
proof
that
they
are
actually
within
compliance,
and
they
will
bundle
that
up
with
returning
acceptance
of
the
order
and
they'll
send
that
back
by
some
messaging
protocol
to
the
buyer
right
so
now,
at
each
step
you
know
we're
kind
of
having
this
state
change
right.
You
can
think
of
it
as
like.
A
single
state
object,
that's
kind
of
moving
in
between
here
it
starts
off
as
the
order
with
the
proof
created.
A
It's
validated
updated
with
the
information
the
seller
needs
to
put
in
also
bundled
with
their
own
proof,
and
then
kind
of
you
know
sent
back
to
the
buyer
to
say
yes,
everything's
good
everything
is
in
compliance
on
both
sides.
Let's
send
it
back
one
more
time,
so
you
can
validate
to
receive
that
final
kind
of
message
from
us
to
say
we're
going
to
send
you
your
stuff,
whatever.
A
A
Whenever
we
get
a
positive
or
negative
result,
that'll
tell
us
right
away
if
that
party
is
acting
in
a
way
that
we
have
agreed
upon
and
if
not,
then
there's
no
way
for
us
to
reach
that
next
state
of
which
we
have
to
go
back
and
then
do
some
kind
of
like
manual
reconciliation
like
a
asynchronized
state.
Again,
I'm
just
that
were
unsynchronized
in
this
case
now.
Normally.
A
A
I
think
you
really
need
to
look
to
those
implementations.
There
are
plenty
of
examples
in
the
the
baseline
repo
itself
and,
as
you
go
online
and
get
involved,
you
run
into
those
examples,
and
I
implore
you
to
dissect
more
than
one
to
see
that
the
actual
implementation
between
them
really
there
is
a
lot
of
leeway
and
flexibility
if
you're
following
the
actual
baseline
protocol
standard.
A
A
A
You
know,
what
do
you
think
has
what
advantages
or
disadvantages
and
so
on
and
so
forth,
but
for
now
we
can
think
of
it
as
just
a
logical
construct
that
it's
implemented
on
a
ccsm
but
in
reality
a
shared
state
machine
where
portions
will
exist
on
and
off
chain.
Where
we've
seen
in
other
presentations,
there
will
be
like
a
a
baseline
proxy
on
top
of
a
connector
and
so
on
and
so
forth.
A
A
This
gets
kind
of
a
bit
technical,
so
I'm
not
going
to
go
through
it
all,
but
we
can
see
that
all
right
within
a
bpi
we'll
have
let's
say
a
middleware
layer
and
that
mineral
layer
may
have
you
know
a
a
workflow
section,
a
messaging
protocol
section
that
may
exist.
You
know
outside
of
the
the
ccsm
that
may
allow
for
kind
of
direct
messaging
within
the
bpi.
Just,
for
example,
we'll
have
some
kind
of
processing
layer
that
may
have
storage.
I
encourage
you
to
get
and
go
and
look
at
this.
A
I
think
this
is,
you
know
fairly
technical
in
in
its
representation.
If
you're,
not
a
you
know,
advanced
baseliner,
but
I
personally
kind
of
keep
this
image
aside.
As
I'm
looking
through
implementation,
see.
Oh
aha,
I
see
this
is
where
they
have
done
kind
of
workflows.
Maybe
this
is
their
middleware
layer
and
it
may
not
appear
exactly
as
this
all
in
this
single
layer
right.
A
Okay,
so
now
we're
gonna
zoom
out
a
little
higher
up.
We
did
the
whole.
You
know
like
one
by
one
workflow
that
I
really
spent
a
lot
of
time
on
that
you
guys
are
probably
really
tired
of
where
I
went
did
step
by
step
and
now
we're
gonna
kind
of
zoom.
Out
still
the
same
simple
example
right:
we
have
a
what
I
call
the
mid-level
architecture,
so
the
middle
of
our
architecture,
we're
not
kind
of
fully
zoomed
out.
A
Yet
we
were
down
at
the
low
level
looking
at
like
one
by
one
right
and
now
we're
kind
of
zooming
up
and
just
seeing
okay.
Well,
you
know
this
is
how
how
do
I
think
of
all
these
things
kind
of
together
I
saw
the
buy
or
the
cellular
bpi,
so
we
have
on
the
left.
We
have,
let's
say
a
commercial
transaction
application
from
buyer
to
seller
and
really
sometimes
you
could
think
of
this
in
a
concrete
implementation.
A
As
the
like
a
baseline
proxy
and
a
connector,
you
know
with
some
legacy
system
off
over
there
and
then
the
seller
same
thing,
some,
maybe
proxy,
a
connector
and
a
you
know:
legacy
system
off
there.
We
have
the
state
object,
which
is
not
only
moving
between
them,
but
also
through
some
baseline
protocol
core
stack
that
middleware
and
processing
that
we've
seen
that
we've
discussed.
A
You
know
how
to
kind
of
think
of
that
shared
state
machine.
It
is
also
kind
of
communicating
with
these
internal
apis
through
the
ccsm
abstraction,
where
we
can
think
of
that
as
kind
of
housing.
Our
bpi
contracts,
the
contracts,
the
agreements
that
we've
made
between
parties
that
dictate
how
they
interact.
You
know
how
can
we
buy
and
sell?
A
What
do
we
need
to
include
for
this
to
move
to
the
next
step
and
be
totally
synchronized
and
kind
of
this
trustless
environment
and
be
sure
that
we
have
you
know
the
data
integrity
on
top
of
low-cost
implementation
from
the
legacy
systems?
Okay,
and
as
if
we
can
kind
of
you
know,
take
this
and
map
it
into
our
minds
of
what
we've
learned
so
far
from
the
low
level
like
moving
back
before
back
and
forth
between
two
parties.
You
know
this
is
kind
of
the
next
level.
A
Up
of
really
how
you'd
start
to
think
about
where
to
implement
things
at
all
those
specific
things
that
we
abstracted
in
the
last
diagram
and
then
we'll
take
that
and
we'll
kind
of
expand
it.
You
know
horizontally
outwards
to
say
well.
Well,
two
parties
yeah,
there
are
some
cases
and
it's
easier
to
think
about
two
parties.
A
It
makes
it
simplified
for
us,
but
you
know
really,
as
you
all
know
or-
and
I
stated
in
the
beginning-
is
that
this
is
about
this
large
multi-party
compute,
complex
problem
with
enterprises,
and
it's
never
going
to
be
that
simple
right
unless
you
and
your
friend
just
want
to
baseline
something
between
the
two
of
you,
which
you
can
totally
do
and
then
so
we
move
out,
we
say:
okay!
Well,
this
is
really
you
know
we're
getting
more
towards
real
life
of
you
know.
A
A
So
this
is
to
complete,
in
your
mind
the
idea
of
okay
at
the
very
lowest
level,
two
parties,
buyer
and
seller,
the
next
level.
Up
in
the
first
level,
we
assume
the
bpi
is
doing.
You
know
everything
it
needs
to
be
able
to
do.
We
go
to
the
next
level
up
and
we
say
okay,
I
need
to
know
a
little
bit
more
behind
the
scenes
of
what
this
architecture
looks
like.
A
Well,
it
was
still
two
parties,
we
expanded
it
to
three,
but
we
can
see
the
different
levels
of
kind
of
architecture,
still
very
kind
of
abstract
and
may
not
physically
be
represented
as
they
actually
are.
But
it
still,
you
know,
helps
us
and
then
we
zoom
out
to
the
highest
level
where,
if
you
read
through
the
standard,
you
can
see
that
there
are
parts
of
the
standard
that
apply
to
having
multiple
bpis
and
them
interact
with
each
other.
A
A
But
maybe
this
is
just
the
person
who
was
the
first
person
in
the
bpi
or
in
the
work
group
right
how
it's
named,
and
they
are
all,
in
this
case
communicating
by
a
single
state
channel
on
which
we
may
be
using
possibly
multiple
ccsms.
Okay,
so
you
now
have
those
three
tiers
of
understanding
of
kind
of
a
architecture
of
what
can
be
done
with
the
baseline
protocol,
all
right
now,
that
is
kind
of
somewhat
the
end
of
the
technical
of
me
trying
to
help.
A
You
know
what
is
this
kind
of
amorphous
thing
in
my
mind
to
help
shape
it
to
something
that
you
can
imagine
and
work
with
within
your
mind
as
you're
entertaining
examples?
Okay,
so
I
hope
that
has
helped.
Of
course
I
have
to
talk
about
some
companies
that
were
inspired
by
the
baseline
pattern
right.
A
This
is
one
of
the
kind
of
great
benefits
of
having
a
baseline
r
d
team
is,
as
we
think
about
these
implementations.
We
happen
to
have
many
spinouts
on
ideas
that
were
originally
baselined,
so
we
have
this.
This
was
the
original.
You
know
question
itself
that
came
as
a
spin-off
of
how
can
we
enhance
current
asset
diligence
practices
to
allow
counterparties
to
verify
asset
performance
without
exposing
sensitive
data?
I'm
not
sure
how
deep
you
have
to
be
in
to
come
to
that
question
itself.
A
It
seems
like
a
very
like
I
don't
know,
deep
and
thought
philosophical
financial
question,
but
somebody
asked
that
question
right
and
that
led
to
in
labs,
so
a
facilitator
and
issuer
of
real
world
assets,
pools
and
defies,
and,
of
course,
if
anybody's
been
paying
attention
to
any
of
the
baseline
shows
or
anytime
john
is
on
anything
at
all.
This
is
a
question.
How
can
we
use
the
pattern
to
enable
cryptolithography
and
digital
rights
management
to
protect
originals
for
nfts?
That
was
the
question
that
john
was
asking,
which
I
think
is.
A
A
You
know
my
team
and
I
I
should
it's
not
really
my
team,
I'm
part
of
the
team
sonal's
team,
it's
a
shout
out
to
the
virtual
people,
sonal's
team
and
I
you
know,
have
a
lot
of
stuff
we're
cooking
up,
so
we're
we're
hopeful
that
in
the
near
future,
we'll
have
many
different,
spin-outs.
Okay.
So
just
a
shout
out
to
that
all
right.
A
So
with
that
with
that,
with
that
great
amount
of
knowledge
that
I've
transferred
to
you
now
as
a
as
a
new
baseliner,
let's
say,
or
a
middle
level,
baseliner
the
advanced
ones
you
guys
already
know
you're
doing.
Is
you
know
how
do
I
contribute
to
the
protocol
or
really
really
for
me
when
I
originally
wrote
this
slide,
it
was.
It
was.
What
do
I
do
next?
Where
do
I
go
or
something
like
that?
So
I
encourage
you
to
actually
read
the
standard.
A
It's
a
great
read.
It's
perfect
not
boring
at
all.
I
I
I
do
encourage
you
really
to
read
it.
Sometimes
you're
gonna
have
to
put
it
down
and
pick
it
up.
Put
it
down
pick
it
up,
but
definitely
read
the
standard
right
now.
If
you
only
just
read
the
standard,
you
know,
maybe
that's
that's
it's
difficult
to
to
put
that
to
even
to
what
we've
learned
today,
those
models
of
the
architecture.
A
So,
in
addition
to
reading
the
standard
you
know,
look
through
the
existing
examples,
read
part
of
the
standard
it'll
go
over,
let's
say
bpi
implementation
or
one.
You
know
focus
of
the
bpi
and
then
look
through
the
examples
that
are
online
say.
Oh
again,
aha,
I've
identified
I
made
this
connection
here
is
how
it
is
in
this
implementation.
A
Here
it
is
defined
in
the
standard
here
I
see
it
in
the
diagram.
How
can
I
connect
these
things
in
my
mind?
Do
I
agree
that
this
implementation,
in
fact,
does
follow
all
the
things
in
the
standard
and
while
you're
reading
the
standard,
you
know
the
thing
that
I've
heard-
and
I
like
to
say,
is
the
standard:
is
this
living
breathing
piece
of
work?
A
No
matter
what
andreas
freund
says
and
how
great
he
is,
I
think
he
really
his
intention
is
for
you
to
question
it,
and
he
welcome
welcomes
this
question,
and
so
do
I,
when
you're
reading
the
standard
question
it
right
when
you're
looking
at
implementations,
question
them.
Is
this
the
right
way
to
do
this?
We
are
actively
and
always
having
standard
meetings
and
revising
the
standard
through
all
kinds
of
critiques
that
people
offer
right.
So
read
the
standard.
Look
through
those
examples.
A
Look
at
previous
baseline
shows
demos,
technical
walkthroughs
and
then
contribute
to
the
work.
So
it
doesn't
mean
that
you
have
to
be
a
dev.
I'm
I'm
assuming
I'm
I'm,
assuming
that
a
lot
of
you
here
are
either
a
dev
or
business
side,
but
for
anybody
here
online
you
know
contributing
to
the
open
source.
Work
is,
is
much
more
than
just
being
straight
technical
developer.
Right,
there's
a
lot
more
to
it.
A
You
can
be
kind
of
part
of
the
community
help
out
with
the
standard
itself
help
with
outreach
to
get
people
involved
in
baseline,
there's
really
many
ways
way
beyond
the
scope
that
I
know
that
I
would
say
probably
only
sonal
patel
is
aware
of
in
operations,
but
the
first
way
to
start
is
our
nice
get
involved,
link?
Okay,
so
you
know
how
do
I
contribute?
That's
how
you
contribute.