►
Description
In this workshop, we’re going to use the Go and JS drand clients to consume randomness rounds from the League of Entropy drand nodes. We’ll fetch the latest round, a previous round, and use the “watch” functionality to get a live feed of randomness as it is generated.
Join us for Filecoin Liftoff Week, an action-packed series of talks, workshops, and panels curated by the web3 community to celebrate the Filecoin mainnet launch and chart the network’s future. https://liftoff.filecoin.io/
Events take place all week, October 19-23, 2020. #FilecoinLiftoff
For more information on Filecoin
- visit the project website: https://filecoin.io/
- or follow Filecoin on Twitter: https://twitter.com/Filecoin
Get Filecoin community news and announcements in your inbox, monthly: http://eepurl.com/gbfn1n
A
Hello,
everyone
and
welcome
to
the
d-rand
workshop
hooray
d-rand
is
is
used
in
filecoin.
It's
it's,
the
the
it's
the
thing
the
service
or
the
system
that
provides
randomness.
That
file
coin
relies
on
for
for
things
like
leader
election,
which
is
which
is
kind
of
important
but
drand.
What
is
it
really?
A
Let's
just
get
back
to
that
here
we
go
drandt,
so
it
is
a
group
of
dram
nodes,
basically
collaborate
together
to
generate
randomness,
and
they
do
that
on
a
period
of
around
30
seconds
and
that
randomness
is
verifiable,
unpredictable
and
unbiased,
and
it's
done
as
a
service.
So
anyone
can
consume
it.
It's
public,
including
far
coin,
and
it
does
so
the
d-rand,
the
d-rank
members
of
the
league
of
entropy
group.
This.
A
This
is
the
group
the
that
are
currently
running
each
one
of
these
organizations
are
running
a
dram
node
and
every
30
seconds.
They
are
generating
new
randomness
collaboratively
and
you
can
see
down
here
the
latest
randomness
that
is
happening
and
you
just
saw
it
quickly-
change
as
it
updated
we're
currently
on
round
two
265
048
and
in
16
seconds
there
will
be
another
round
generated
by
by
these
guys
anyway.
A
Now
that
you
know
everything
about
d-rand,
well,
okay,
there
are
many
details
that
I
just
missed
out,
but
we're
gonna
talk
today
about
the
the
go
and
js
clients
and
we're
gonna
use
them
to
get
hold
of
some
of
that
box.
Fresh
randomness
from
the
diva
unloads
that
the
this
league,
this
league
event
would
be
run,
and
so
today
we're
gonna
be
mostly
getting
randomness
using
the
http,
json,
api
and
and
there's
gonna
be
live
coding.
A
A
So,
first
of
all,
we're
going
to
try
and
get
some
information
about
the
chain
of
randomness
that
that
that
that
league
of
entrepy
are
generating
every
30
seconds,
and
so
what
happens
is
that
dram
produces
a
chain
of
randomness
and
each
new
beacon
points
to
the
previous
beacon
all
the
way
along
to
the
genesis
and
so
the
chain.
The
kind
of
information
that
we're
interested
about
in
the
chain
is
the
the
period
between
randomness
generations,
the
genesis.
A
So
when
the
change
started,
if
we
know
the
period
in
the
genesis,
then
we
can
predict
exactly
when
the
next
round
of
randomness
is
going
to
be
generated,
but
also
the
public
key,
which
is
useful
for
verifying
the
rounds
are,
are
the
rounds
that
we
expect
them
to
be.
So
let's
go
let's
head
over
to
the
docs,
so
you
can
see
on
this
website.
If
you
head
over
to
developer,
then
we've
got
client
library
documentation.
A
Here,
we've
got
one
for
go
and
js
at
the
moment,
but
what
we're
going
to
do
is
first
of
all
we're
going
to
grab
the
chain
hash
from
this
page.
You
can
copy
it
from
the
page
and
head
on
over
here.
I've
got
a
new
project
here.
In
my
it's
new
go
projects,
I've
got
a
main.go
files,
not
much
in
there.
At
the
moment,
I've
got
my
go
mod.
I've
already
go,
get
it.
A
It's
got
the
the
d-rand
module
from
dram
d-rand
and
that's
in
there
that's
ready
to
go,
and
so
in
here
I've
got
just
a
main
function,
just
with
the
just
printing
out
done
when
it's
done
and
I've
got
I've
set
up
two
variables
here,
so
we've
got
a
constant
chain
hash,
I'm
gonna
paste
in
that
chain,
hash
here
and
the
chain
hash.
Let
me
talk
about
the
chain
hash
for
a
minute.
The
chain
hash.
A
It's
uniquely
identifies
the
chain
and
it
is
the
sha
256
hash
of
the
the
public
key,
the
genesis
time
and
the
period.
And
so
what
will
happen
is
that
this
client
that
we're
creating
it
will
ask
the
chain
for
that
information,
and
then
it
will
hash
that
information
and
compare
it
with
the
chain
hash
that
I've
just
pasted
in
here
and
if
they're
the
same,
then
we
know
that
the
chain
that
we're
talking
to
is
the
chain
that
we
expect
to
be
talking
to.
A
So
it's
very
important
that
we
use
this
chain
hash
or
directly
give
the
client
the
chain
info
so
that
we
we
know
we're
consuming
the
right,
randomness
and
then
urls.
Here
we
go.
We
can
copy
these
off
the
website
too.
The
league
of
entries
some
of
the
league
of
entrepy
members.
They
they
they
have
publicly
accessible,
http
apis.
There
are
also
protocol
run
gossip
sub
client,
a
relays
that
you
can
use
in
in
lippy
to
be
gossip
sub.
A
I'm
gonna
we're
gonna
use
the
http
api
today,
so
I'm
just
gonna
copy,
I'm
gonna
copy,
so
pl
run
this
one
here
and
cloudflare
run
this
one
here,
I'm
gonna
copy
these
in
so
we've
got
two
urls
there,
I'm
just
going
to
uncomment
this.
So
what
we
all
we're
doing
here
is
that
we've
got
our
chain
hashes
hex
encoded.
We
need
to
give
it
to
the
client
as
a
as
a
bunch
of
bytes,
so
we're
just
decoding
that
hex
string
into
into
some
bytes.
So
that's
all
that's
going
on
there.
A
What's
next,
let's
create
a
client.
Here
we
go
okay,
so
c
and
then
possibly
an
error.
I'm
just
gonna
ignore
errors
in
this
in
this
demo
and
hope
that
none
occur
okay,
so
client.
We
need
a
client
we're
going
to
use
client.wrap
today,
and
so
what
my
editor's
done
here
is
it's
just
imported
the
drand
client
package
for
me
and
I've
got
this
wrap
function
and
that
takes
a
a
bunch
of
clients.
A
So
this
is
really
interesting,
because
what
the
drams
client
does
is
it
wraps
multiple,
concrete
implementations,
so
we're
going
to
use
http
clients
today
but,
like
I
said
there
are
lippy
to
be
gossip,
sub
clients
and
there's
also
a
twitter
client,
because
randomness
is
also
being
tweeted
wherever
got
here.
It
is
it's
been
tweeted
to
this
league,
eventually
mainnet
thing,
so
that's
super
cool.
Let's
get
back
to
the
code,
so
we've
got
this
client
right,
we're
going
to
use
the
http
client
and
four
urls.
A
A
A
It
there's
an
option
to
to
use
in
securely,
which
will
which
will
mean
that
the
dram
client
doesn't
do
any
verification
of
the
dram
rounds
that
it
see
that
it
sees,
and
you
should
only
use
that
in
testing,
don't
use
it
as
in
a
production
service,
otherwise
use
the
chain
hash,
all
right,
so
clients
we.
This
is
what
the
interesting
thing
about
this
client
is
that
it
will
wrap
all
of
these
clients
that
you
give
it
and
you
can
consider
them
as
one
single
client
and
it
wraps
these
clients.
A
It
does
the
the
round
verification
for
you,
but
it
also.
It
also
does
special
things
like
it:
speed
tests
the
clients,
so
every
every
so
often
it
will
speed
test
each
one
of
these
clients
and
then,
when
you
ask
for
some
randomness
it
will
use
the
fastest
one,
and
if
that
fastest
one
doesn't
respond
for
whatever
reason,
then
it
will
move
on
to
the
next
one.
A
It's
got
failover
in
it,
it's
amazing,
so
there
is
there's
all
of
that
goodness
in
there,
and
you
should
totally
use
a
this
client
library
that
we've
built
if
possible,
because
it
provides
these
amazing
things
all
right.
Let
me
just
check
that
I've
told
you
everything
I
wanted
to
tell
you.
It
also
does
caching
forgot
about
that
yeah.
If
you
ask
for
a
d-round
round,
then-
and
you
ask
for
it
later-
then
you'd
have
to
go
and
get
it
again.
So
that's
also
good
good
news
all
right.
A
So
now
we've
got
our
client
we've
instantiated
it.
What
can
we
do
with
it?
Well,
I'm
going
to
get
hold
of
that
info,
because
I've
said
that's
what
we're
going
to
do
we're
going
to
get
hold
of
the
info
so
info
info,
possibly
an
error.
Let's
not
worry
about
that
it
pas
it
takes
context,
so
you
can
cancel
it
if
you
like,
but
what
this
will
do
is
we'll
get
hold
of
the
info
for
the
chain.
A
So
I've
got
a
handy
snippet
over
here
here
we
go
and
that
just
I'm
just
going
to
copy
and
paste
that,
because
this
would
take
ages
to
type
out.
But
all
we're
doing
here
now
is
we're
going
to
we're
going
to
print
out
some
of
that
information
that
we
get
so
we've
got
the
public
key
there.
As
I
said,
that's
just
being
printed
out
printed
out
as
it
as
it
comes
the
genesis
time
for
the
chain.
A
This
is
in
seconds
since
the
unix
epoch
and
what
we're
doing
is
just
whoa
whoa
whoa.
What
happened?
Okay,
there
we
go.
Don't
worry,
don't
panic!
It's
okay!
This
is
the
genesis
time
since
the
unix
epoch
in
seconds,
and
it
would
just
make
you
making
it
into
a
unix.
Let's
just
save
that,
so
it
stops
complaining
yep,
making
that
into
a
unix,
timestamp
and
then
printing
it
out.
So
we
get
something
nice
printed
out.
A
The
period
as
I
said,
for
mainnet
on
the
league
of
entropy
nodes
is
30
seconds,
so
I'm
expecting
30
seconds
to
be
rented
out
here
and
then
we're
just
we
get.
We
also
have
the
hash
in
the
info
and
we're
just
going
to
encode
to
add
that
to
hex
so
that
we
can
compare
that
with
that
hash.
We
got
up
here
and
we'll
see
that
they
are
the
same.
They
should
be
the
same,
let's
hope
they're
the
same.
Let's
run
it
go
run
main
all
right.
A
Okay,
so
here
we
go,
we've
got
the
public
key.
That's
there
genesis
time
that
is
june
july,
something
like
that
16
17.,
that's
when
it
happened.
The
period
is
30
seconds
like
I
said,
rad
and
the
chain.
Hash
is
the
same
chain
hash
as
we've
got
up
here
all
right.
It's
working,
hooray,
okay,
but
this
isn't
interesting
at
all.
You
know
what's
interesting,
actually
getting
randomness,
and
this
is
just
the
information
about
the
chain.
So
let's
get
some
randomness.
A
Let's
get
the
latest
random
value
that
has
been
generated
latest
we
can
use
for
that
purpose.
There's
a
function
called
get
and
this
allows
you
to
get
the
latest
randomness
value.
Here's
some
context,
and
I
we.
What
we
need
to
do
is
give
it
a
round
number
here
and
so
every
time
we
the
d
round,
generates
a
new
round.
It's
it's
given
a
sequential
number
and
but
we
don't
know
what
the
latest
round
is
but
but
but
well
I
could
look
at
the
website,
but
we
don't
know.
A
Usually
if
I
pass
zero
here,
then
it
would
just
give
me
the
current
round
the
latest
round
that
has
been
generated.
So
let's
pass
a
zero
here,
all
right,
okay
and
then
I've
got
a
handy.
I
keep
doing
pressing
the
wrong
button.
I
cut
a
handy
snippet
here
which
will
print
out
that
round
information.
So
here
we
go
and
all
we're
doing
here
is
we're
printing
the
latest
round.
A
That's
the
round
number
there
that's
very
cool
and
the
actual,
the
actual
randomness
that
we've
generated
and
we're
just
going
to
encode
it
as
as
hex,
because
that
is
makes
it
easier
to
look
at
in
the
terminal
all
right.
So
let's
save
that
and
we
will
run
it
here.
We
go
so
let
me
move
up
a
little
bit
okay,
so
we
had
the
public
key
genesis
period
chain:
hash
we've
got
the
latest
round.
Here
we
go.
This
is
what
we're
looking
for
is
265
068
we've
got
beb
latest
randomness.
A
If
we
check
that
against
the
website,
we
should
have
every
time
I
try
this
it
changes
out
from
under
me.
Okay,
here
we
go
again
one
more
time:
two,
six:
five:
zero,
six,
nine
and
67
bc.
So
two
six:
five:
zero,
six,
nine
sixty
seven
bc,
yes
great
cool,
so
we
are
getting
the
latest
randomness,
which
has
also
been
verified
by
our
website.
Perfect
that
that's
great
what
about
historical
randomness?
We
can
get
that
too.
So,
let's
get
some
old
randomness,
because
why
not?
A
A
One
two
three
four
good
idea:
good
idea,
all
right:
let's
run
that
again
old
round
one
two,
three
four
out
it
came
perfect
and
that
is
that
looks
like
the
randomness,
as
I
remember
it.
From
that
time,
if
I
run
that
again,
then
I
should
get
the
same
thing,
because
it's
the
same
round,
but
it's
always
the
same.
It
doesn't
change,
it
doesn't
change.
So
that's
great
old,
randomness,
perfect
all
right!
I've
done
some
things.
What
should
we
do
now?
Let's?
A
So
the
other
thing
that
you
can
do
in
in
the
client
is
you
can
watch
for
randomness,
so
you
can
get.
You
can
get
the
fire
hose
of
randomness
right
into
your
eyes,
if
you
so
wish,
and
you
call
the
c
dot
watch
watch
function.
This
gives
you
back
a
channel,
and
so
I
can
use
a
for
loop
on
the
channel
because
why
not
rand
I'm
going
to
call
it
rand
range?
A
You
can
range
over
that
watch
channel
and
what
this
will
do
is
it
will
give
me
the
the
latest
round.
Oh,
I
need
some
context.
Let's
put
the
context
in
there
it'll
give
me
the
latest
round.
I'm
gonna
set
a
new
round
new
round
new
new
new
new
okay,
oh
no,
I
didn't
call
it
neo
called
around
there.
We
go
round
perfect,
so
this
is
a
new
round
that
has
come
in,
but
what
watch
will
do
is
give
him
the
current
round
first.
A
A
Oh
helps,
if
I
save
it,
doesn't
it
there
we
go
there.
We
go
all
right,
okay,
so
let's
have
a
look.
We've
got
the
latest
round
new
round,
so
this
is
the
latest
round
here,
and
so
what
will
happen
is
that
when,
after
30
seconds
elapses,
then
a
new
round
of
randomness
will
be
generated
and
that
will
be
delivered
on
our
channel
to
our
our
program
and
it
will
print
out
the
next
round.
So
there
it
is
hey,
hooray,
that's
great.
A
So
we've
got
around
you'll
notice
that
we
didn't
the
program
didn't
finish.
We
did,
we
didn't
get
our
done
printed
and
that's
because
we
haven't
finished
the
we're
still
in
the
loop
we're
still
watching
for
randomness
when
we
can't
get
out.
How
do
we
do
that
and
go
people
in
people
who
use
go
are
all
like
just
use
the
content.
A
Okay,
there
we
go
contest
so
sort
of
passing
this
background
context.
Here
we
pass
in
our
special
context,
which
we
created
from
the
background
context,
but
it
has
a
timeout
and
we're
saying
after
30
seconds.
Just
stop
cancel
the
context,
so
it
will
be
cancelled.
So
what
I'm
expecting
to
happen
here
is
that
this
will
I'll
get
the
current
round.
So
two
six
five
seven
seven
the
latest
round
and
then
I'll
get
thirty
sec
other
works
less
than
thirty
seconds.
A
Ish
later
we
will
get
the
next
round
as
it's
generated
and
then
after
this
30
seconds
elapses,
then
this
context
will
be
cancelled.
We
will
exit
the
loop
and
our
done
will
be
parented.
So,
okay,
now
we
just
got
it
awkwardly.
Wait
there
we
go
okay,
that
was
quick,
perfect,
so
yeah
we
got.
I
expected
exactly
that
so
perfect,
hooray!
That's
how
that's
how
you
derand
client
in
go
all
right.
This
is
going
well
so
far.
How
are
we
doing
for
time?
A
16,
okay,
okay,
okay,
perfect,
all
right,
we've
got
loads
time
all
right.
What
should
we
do
now?
Yeah?
Okay,
let's
make
this
so
that's
fun
and
you
can
use
that
in
your
go
applications
and
stuff,
but
what
what
we
should
do
now,
seeing
as
we've
got
so
much
time
together
and
it's
been
fun
so
far
and
nothing
has
gone
wrong.
Let's
make
a
a
web
application
yeah,
let's
do
it.
I've
got
this
dram
dice
roller
thing.
A
I've
got
a
repo
here,
so
if
you
want
to
clone
it
and
look
at
the
code,
then
you
can
go
ahead
and
do
that.
But
let
me
let
me
show
you
it.
Let
me
show
you
it
okay
here
it
is.
I
started
it
up
there
here
it
is
okay,
it's
a
dice!
It's
a
twenty-sided
dice!
What
hi,
okay
anyway,
so
dice
whatever
roll
the
dice.
If
we
roll
the
dice.
A
Four,
okay,
all
right,
so
this
is
this
is
great.
This
is
great.
This
is
actually.
This
is
actually
a
expected,
because
this
is
a
four
roller
dice.
This
rolls
the
number
four
guaranteed
randomness
is
broken,
it's
broken,
isn't
it
so
here
we
go,
we've
got
the
dice
roller.
This
is
the
html.
This
is
the
code.
This
is
the
dice,
it's
a
div
and
it
has
the
current
rolled
value
in
the
middle
we've
got
a
button.
We've
got
some
style,
you
don't
care
about
style.
A
A
But
all
you
need
to
know
is
that
you
start
the
dice
rolling
by
calling
roll
and
and
it
keeps
putting
different
numbers
in
the
dice,
and
it
will
keep
doing
that
forever
and
ever
and
ever
until
you
call
stop
and
when
you
call
stop,
you
give
it
a
number
to
settle
on
and
it
will
stop
the
dice.
Then,
with
that
number
all
right,
let's
have
a
look
at
what's
happening
in
the
main
function,
so
we
just
call
a
spain
function.
So
we
we
get
the
dice
element.
A
We
get
that,
which
is
that
div
we
get
the
roll
the
button,
the
roll
button
and
we
attach
an
event
listener
to
the
role
button
which
calls
that
role
function.
It's
saying
start
the
dice
rolling,
okay,
great
great
great
and
then
there's
a
set
timeout
here
after
five
seconds,
as
you
can
see
just
there,
what
it
will
do
is
it
will
tell
the
current
roll
to
stop
on
the
number
four
and
that's
how
I
knew
it
was
gonna.
Be
for
every
time,
okay,
so
this
is
broken.
A
A
We
need
the
drand
js.
Client.
Dramjs
client
is
really
similar
with
in
its
api
to
the
golang
client
on
purpose.
So
you
don't
feel
right
at
home
when
using
it,
so
I've
imported
it.
Here,
we've
got
the
client
as
we
did
in
golang,
we've
got
http,
which
is
the
http
client,
and
then
I've
got
this
sniff.
This
is
just
the
chain
hash
and
the
urls
as
we
had
them
before,
as
you
will
remember
from
the
golang
part
the
chain
hash
here.
A
A
Okay,
so
I
need
an
async
on
this
fun
action
now
async
there
we
go
so
we're
using
client.wrap.
Again,
we're
using
http.4
urls,
so
this
creates
a
bunch
of
clients
and
then
it
gets
wrapped
by
the
the
big
client
that
does
all
of
the
optimization
and
verification
and
caching
and
all
sorts
so
awesome
same
same
thing,
easy
easy
to
do,
and
so
with
that
client.
What
we're
going
to
do
is
instead
of
this
set
timeout.
A
A
A
They
don't
know,
and
so
what
this
is
doing
is
it's
saying
give
me
the
round
number
when
it
was
this
time
so
by
putting
date.now
in
we're
saying
give
me
the
round
number
right
now,
so
the
current
round
number
it
could
be
computed
because
we
know
the
the
genesis
and
the
and
the
period.
So
so
that's
that's
great.
We
don't
have
to
go
and
get
that
round.
We
just
compute
it
so
next
round
num.
A
So
the
next
round
number
is
what
we
want
in
a
roundabout.
So
wait
we're
saying
that
okay,
so
brand
brand
equals
always
okay.
So
now,
instead
of
so
javascript,
we
have
to
await
on
stuff.
We
don't
have
a
context
here,
but
the
javascript
api
takes
a
a
signal,
a
signal,
and
that
is
a
a
a
a
signal
that
you
might
get
from
a
new
abort
controller
signal
and
what
what
you
can
do
with
that.
A
A
A
Okay,
all
right
so
now
that
we've
got
this
random
number,
that's
great,
but
it's
just
a
bunch
of
bytes.
It's
it's
random,
random
bytes
and
what
we
need
to
do
now
is
we
need
to
convert
that
that
bunch
of
random
bites
into
a
into
a
number
a
number
between
1
and
20
inclusive,
because
we
have
a
20-sided
dice.
A
Let's
do
it,
I've
got
you
guessed
it
okay!
I
did
this
honestly.
I
can
explain
it.
The
randomness
is
encoded
in
hex,
so
we're
saying
make
me
a
big
int
from.
I
have
no
idea
why
standard
doesn't
like
this,
but
dig
in
is
the
thing.
So
just
just
don't
worry,
don't
worry
so
get
give
me
a
big
based
on
the
hex
encoded
randomness
that
got
returned
to
me
from
the
api
mod
20,
because
we
have
a
20-sided
dice,
and
that
gives
us
a
number
in
the
range
of
zero
to
19.
A
I
think,
and
then
we
plus
one
because
we
want
we
actually
want
one
one
to
twenty
and
then
we've
got
a
big
hint
that
we
need
to
be
like
not
a
big
int.
So
we
do
a
two
string
with
base
ten
and
then
we've
got
our
number,
so
we've
got
a
random
number
amazing
and
what
we
can
do
instead
of
putting
four
here,
we
can
put
none
here
and
in
I'm
just
checking
my
work
because
I
said
a
lot
of
words
and
in
theory
that
should
just
work
now.
A
Here
we
go
okay.
Now,
because
this
is
random,
there's
a
possibility-
it
hasn't
happened
to
me,
yet
it
could
land
on
four
and
then
you'll
be
like
this.
Is
this
doesn't
work
but
but
believe
me,
it
is
definitely
coming
from
d:
rand,
20,
hey!
Oh!
No!
It's
still
going
still
13.
all
right,
all
right!
Okay,
there
we
go.
13
works,
totally
works.
It
can't
come!
A
It's
truly
unbiasable
randomness
from
d-rand
from
the
league
of
entropy
nodes
from
the
main
net
that
is
used
by
firecoin
also,
and
we
are
using
that
to
to
roll
a
dice
in
our
browser,
because
why
not
so
that's
cool
and
that
will
that
will
do
another
random
number
when
it
comes
in
320
this
up
to
30
seconds
between
between
bro
successful
world
13?
Okay,
no,
it's
not
a
13
role.
I
promise
we
set
that
off
but
anyway,
oh.
A
Can't
wait
for
this
one
and
then
I'll
show
you
the
network
tab.
What's
going
on
20
20.,
okay,
great,
I
don't
know
what
happened.
There
seems
I'm
having
some
interesting
internet
internet
troubles.
Okay,
so
what
happens?
If
we,
if
we
clear
these
for
now,
you
can
see
what's
happening.
Is
it's
asking
api.dram.for
the
round
101?
A
That's
cool,
and
so
the
other
thing
to
note
is
that
the
js
api
also
has
the
the
watch
watch
channel.
It's
an
async
iterator
and
yeah
they're,
both
they're
both
very
similar
in
their
functionality,
but
that
is
d-rand
and
that's
how
you
harness
unbiasable,
verifiable
randomness
that
filecoin
also
uses,
and
you
can
use
it
in
your
application
in
go
or
in
js,
and
it
would
be
rad
to
see
clients
in
other
languages
as
well.
All
right!
That's
all!
I
really
have
to
say.