►
Description
The Baseline Protocol team takes you through the code of the v0.1 update.
Previous video: https://youtu.be/0vXoSb5bVks
Next video: https://youtu.be/R0AEww6fKLk
Go to https://baseline-protocol.org for more information.
A
A
To
walk
us
through,
hey
kyle,
we're
going
to
walk
through
our
the
bri
one,
that
is
the
baseline
reference
implementation.
One
code
base
and
specifically
we're
gonna,
go
through
the
base
applicator.
The
base
example
in
that,
so
that
we
can
see
how
you
put
the
the
baseline
protocol
together
baseline
app
or
the
allison
bob
app.
I
think
we've
called
it
before
the
the
official
naming
of
that
is
bri
one
and
that's
where
you'll
find
it
in
the
repo
so
kyle.
Won't
you
take
it
away
and
show
us
show
us
how
this.
B
In
the
baseline
repo
under
examples
bri1
under
example,
you
see
radish
34
and
you
see
bri
one
dri.
One
now
contains
a
directory
called
lib
and
a
directory
called
base.
Example.
Lib
has
a
couple
of
of
directories
in
it
from
previous
erp
connector
demos.
More
on
those
later
base,
example
contains
what
was
formerly
referred
to
as
baseline
app
and
the
allison
bob
demo.
The
baseline
app
class,
as
previously
discussed,
is
now
called
participant,
stack.
B
A
A
So
this
is
a
a
point
of
view
on
use
on
baseline,
each
of
the
reference
implementations
and
that's
why
we
number
them
right.
You
have
bri
one
bri,
two,
where
different,
it's
kind
of
like
the
the
ver,
the
difference
between
a
yellow
paper
and
geth
right
death
would
be
an
implementation
of
the
ethereum
yellow
paper.
A
B
A
A
B
A
Reason
we
should
say
that,
strictly
speaking,
folks
could
could
again,
you
know,
make
another
reference
implementation
that
didn't
include
that,
but,
but
you
guys
did
such
a
great
job
on
it
for
people
that
are
implementing
it.
It's
important
to
note
that
it's
not
there's
nothing
about,
provide
that.
You
know
nothing
about
baselining
that
requires
provide.
A
B
So
if
you
know,
for
example,
if
you
wanted
to
say,
create
another,
create
another
application
before
we
get
into
the
actual
details
of
the
application,
if
you
wanted
to
create
an
you
know,
an
additional
you
know
app.
If
you
wanted
to
create
an
additional
example
or
your
own
app
like
your
own
implementation,
that's
based
on
bri
one
and
how
it
uses
the
provide
stack.
B
A
A
A
A
B
Before
before,
no
it's
the
messaging
package
from
the
baseline
protocol,
however,
before
you
before
you
do
that
you
know,
you'll
you'll
actually
want
to
contribute
a
provider
implementation
so
like
kafka,
for
example,
or
whatever
that
might
be.
You
would
add
that
provider
to
the
core
package
submit
a
pull
request
and
then
that
would
be
included
in
a
release
of
the
messaging
package
and
then
you
would
import
that
package
and
use
it
so
like
basically
like
we
skipped
a
step
here
of
actually
writing
the
kafka
implementation
of
the
imessaging
for
the
imessaging
services.
B
B
B
B
A
B
B
B
You
know
the
stack
and,
and
you
can
see
it
all
in
one
place
it
you
know,
and
so
that's
sort
of
yes,
the
introduction
you
would
set
up
your
own
participant
stack,
so
what
it
does
is
it
essentially
creates
a
couple
of
users.
Bob
and
alice
have
actual
users
within
the
idit
container,
and
then
the
item
container
is
essentially
the
you
know:
an
implementation
of
the
the
registry
of
the
local
registry
interface
and
essentially
like
when,
when
you
register
your,
you
know
your
organization
items
it
automatically.
B
It
uses
vault
to
sign
transactions
for
you
that
end
up
putting
your
organization
in
the
word
registry
contract
on
the
blockchain
once
alice
and
bob
have
users
and
tokens
in
items.
If
they
say,
faucet
is
deconfigured
in
the
on
the
in
f
runtime,
using
an
environment,
variable
called
faucet,
faucet,
private
key
and
faucet
address
are
the
two,
the
two
environment
variables.
If
those
are,
if
those
are
present
at
runtime,
faucet
will
be
configured
which
will
basically
just
subsidize
all
the
all
the
all
the
gas
on
the
on
the
network.
B
B
You
you
could
use
other
networks
very
easily,
but
we've
chosen
robson
because
it
most
closely
resembles
the
the
public.
You
know
maintenance.
So
currently
we
are
using
robson
and
and
if
a
faucet
is
configured
properly,
then
you
will
then
alice
and
bob
won't
have
to
worry
about
having
ether
on
the
rocks
and
test
net.
They
will
just
they
will
just
the
transactions
will
just
be
subsidized
automatically.
A
B
Actually
you
know
interpreted
if
and
so
that
this
means
that
we
can,
instead
of
waiting
to
initiate
alice
like
when
we,
when
we
invite
her,
we
we
just
initiate
her
with
the
initiate
we,
we
bootstrapped
the
participants
that
her
participants
back
with
the
initiator
set
to
false,
and
what
that
does.
Is
it
just
means
that
that
it's
not
going
to
automatically
set
up
the
work
group
that
will
be
bob's
job
bob's,
like
the
designated
initiator
in
our
example,.
B
So
once
we've
once
we've
bootstrapped
the
bob
stack
and
the
the
bob
and
the
alice
participants
back
with
bob
being
designated
as
the
initiator
of
the
work
group
and
alice
being
basically
like
just
having
an
instance,
you
know
set
up
so
what
you
know
waiting
for
bob.
You
know
to
invite
her.
The
actual
the
actual
tests
are.
You
know,
starting
to
start
start
running,
and
so
what
we're
doing
here
is
here.
We
can
go
ahead
and
kick
that
off.
B
You
want
to
run
npm
test,
but
you
want
to
run
it
with
a
couple
of
you
want
to
run
it
with
those
environment
variables
such
that
the
such
that
you
know
the
the
transactions
will,
the
faucet
will
be
configured,
transactions
will
be
subsidized
and
you
will
see
them
on
rousten
all
right.
So
we're
going
to
run
that
you're
going
to
see
the
provide
stack
and
the
nethermine
client
start
go
ahead
and.
B
B
B
So
what
what
we
do
now
is
we
hurry
up
and
wait
for
the
the
transactions,
the
deployment
of
the
work
group?
So
what
we've
done
is
we've
created
a
work
group
in
bob's
local
registry
and
we've
we've
authorized.
You
know
a
a
bearer
to
a
bear
off
a
bearer
token
to
interact
with
that
local
registry
and
that
is
is
affecting
affecting
the
deployment
of
the
org
registry
contracts
of
the
robson
test
that,
but
let
me
pull
up.
A
B
Yeah,
so
what
you
see
here
like
one
minute
ago,
we
have
a
a
subsidy
transaction
that
was
sent
like
a
0.1
ether
subsidized
transaction
that
was
sent
to
to
bob
and
bob
has
is
now
you
see
this
contract
creation
transaction
that
bob
is
sitting,
that's
actually
it's
actually
the
books,
that's
deploying
it's
actually
deploying
a
contract
that
will
that's
the
order
registry
is
more
or
less
than
being.
You
know,
that's
being
deployed.
B
Yeah,
so
what
you'll
actually
see
is
yeah.
This
is
actually
a
a
contract.
That's
going
to
deploy
the
erc
1820,
and
so
what
you'll
see
is
some
assertions
happening
over
here
around
that
the
erc
1820
registry
was
deployed
and
that
then
the
the
erc
1824
registry
was
deployed,
and
then
you
will
then
it'll
it'll
move
on
to
the
next
part
of
the
test.
B
So
not
not
as
part
of
this
initial
work
group
setup,
because
the
you
know
the
the
evolution
of
the
design
here
is
that
you
may
have
more
than
there's
no
coupling
of
of
the
shield
contract
to
the
work
group
or
the
org
registry
at
all,
and
so
so
it's
actually
not
deployed.
Yet.
As
part
of
this,
you
know
as
part
of
this
initial
work
group
setup.
So
it's
deployed
and.
A
B
B
B
A
B
B
The
default
k1
key
pair
right
here
that
bob
was
created
for
bob
right
here.
This
is
the
this
default
k1
key
pair
it
you
know
the
the
the
public
ethereum
address.
Representation
of
that
key
pair
is
is
the
is
it
becomes
the
primary
key,
as
you
would
consider
like
you
know,
or
as
you
think
of
that
term,
in
the
context
of
like
a
traditional
relational
database
that
that
becomes
a
primary
key
in
the
org
registry
contract
for
bob
corp.
That's.
B
A
B
And
that's
that's
another
thing
that
our
vault
implementation
provides.
Is
the
ability
to
prevent
signing
of
transactions
with
certain
keys,
as
well
as
automatically
increment
the
account
like
the
the
non-specifically
or
the
account
index
on
an
hd
wallet,
for
example?
So
that's
another.
Combining
these
two
approaches
is
a
way
to
eliminate
your
leaking
of
information
in
in
the
context
of
the
baseline,
critical.
B
A
B
B
B
This
is,
this
is
just
like
you
could
just
drop
this
in
an
email
and
and
alice
can
click
on
the
link
and
if
you
have
like
some
sort
of
handler
for
that,
alice
can
like
just
any
anyone
any
citizen,
any
citizen
or
or
product
owner,
or
anyone
at
the
organization
could
accept
the
invite
and
the
invite
contains.
You
know
all
of
the
all
of
the.
A
A
B
B
Yeah
yeah
and
so-
and
so
here
you
know,
here's
what
you're
seeing
over
here
now
so
like.
Basically,
what
we
saw
was
alice
getting
that
in
you
know,
an
invite
that
looked
like
that.
Getting
and
basically
you
know
accepting
the
invite
setting
up
her
local
instance
of
ident,
based
on
based
on
the
you
know,
based
on
the
details
she
she
got
over
here.
She
was
able
to
understand.
B
Another
exciting
development
will
be
around
when
this
is
is
actually
implemented
as
like
something
that
looks
like
protocol
buffers
or
similar,
and
so
we've
gone
through.
You
know:
we've
gone
through
the
the
test
suite
here.
We
you
know
say
one
other
thing:
maybe
that
was
it
so,
oh,
so,
basically
you
know
here's
here's
where
here's
the
assertions
where
alice's
is
a
local
local
participant
stack
has
the
proper
references
to
all
of
the
contracts
that
she
needs
to.
B
B
A
B
That
yeah,
and
so
so
alex,
is
basically
what
this
this
this
set
of.
This
set
of
tests
is
asserting
is
that
alice
is
ready.
You
know
to
interact
with
bob,
and
then
this
is
asserting
very
similarly
to
how
bob
you
know.
Alice
has
her
set
her.
Her
keys
set
up
alice,
has
been
registered
in
the
org
registry
contract.
You
see
how
these
on
chain,
these
tests,
that
are
that
are
asynchronous
and
are
sort
of
non-deterministic
in
terms
of
robson's
actual
current.
B
A
A
A
B
B
A
A
B
Just
to
add
one
more
one
more
thing
to
that,
like
you
know
as
this
evolves
and
we
and
we
had,
you
know,
identify
a
mainnet
and
like,
for
example,
if
the
ethereum
public
blockchain
is
used
for
the
phone
book,
you
can
see
that
being
like
a
singleton,
and
you
can
see
that
becoming
quite
large
in
terms
of
the
number
of
people
that
are
in
that
in
that
singles
red.
You
know,
contract.
A
B
B
Yep
and
so
one
more
one
more
thing
to
note
here
like
in
the
in
the
actual
code
of
the
test,
suite
is
basically
how
there's
a
shared.
You
know
a
shared
context,
a
couple
of
a
couple
of
them
actually
there's
like
a
behave
like
a
work
group
organization,
so
both
alice
and
bob's
participant
instance,
like
their
participant
stack
instance,
basically
gets
gets
evaluated
here
and
so
like
that's
that's
where
that
is
where
you
see
this
running
right
here.
So
that's,
that's!
B
That's
basically
exercising
both
of
the
participants
and
then
should
behave
like
an
initial
work
group
organization
that
that's
that's
the
initiator,
so
bob.
That's
that's
bob
just
being
being
evaluated
here,
bob's
participants
back
and
since
it
is
and
then
should
be,
like
an
invited,
work.
Group
organization
that
shared
context
is
only
is
only
mr
alice.