►
From YouTube: Retrieval Market Builders Demo Day - Myel, W3DT Bedrock, FC Retrieval, & FilSwan - June 9, 2021
Description
Every other week, the Retrieval Market Builders get together to share progress in their projects in a demo format. We want to sincerely thank all of our collaborators for demoing their developments and helping to improve the FIL Retrieval Markets one demo at a time.
June 9, 2021, Demo Day: In this video, you can find quick demos regarding the following -
• ResNetLabs' Content Routing Team discussing smart records
• Myel Gateway demo provided by Thomas.
• W3DT Bedrock team discussing basic selector use for retrieval of DAG sub-tree from FIL deals.
• FC Retrieval presenting Poc 2 results regarding publishing and receiving offers using payment channels.
• W3DT's own Hannah Howard demoing Dealbot.
• FilSwan showing off an S3 compatible storage tool to Filecoin.
__________________________________________________________________________________________
If you would like more information about the Demo Days please follow the link below to the Demo Days planning document.
https://docs.google.com/document/d/1IrNbBm2_P79Xi2fXFj9YUfQ0PjWjreGdPYFjFntD1QM/edit#heading=h.akao8aspby4
A
If
we
still
have
minutes
to
visit
those
questions,
then
then
we'll
start
from
the
top
to
bottom
for
the
ones
that
we
have
time,
but
given
that
everyone
packed
a
demo
today,
so
I'm
not
sure
if
we
will
to
have
our
time
for
discussion
alive,
make
sense
to
everyone
all
right.
Some
nods
well
welcome
to
everyone
that
just
joined
okay.
So
let's
get
started
alfonso
when
I
kick
us
off
with
the
first
demo.
A
Yes,
so
hello,
everyone,
I
guess
you
see
a
few
slides
I'll
try
to
be
fast.
I
wanna
introduce
what
we're
doing
around
smart
records
smart
records
in
the
end.
What
we
are
trying
to
do
is
a
public
blackboard
for
protocols,
so
this
is
part
of
our
compostable
routing
project
in
the
compostable
routing
project.
In
the
end,
what
we're
trying
is
to
make
routing
in
systems
and
distributed
networks,
something
that
can
be
composable
so
that
protocols
don't
depend
one
to
another.
We
can
use
the
one
that
we
want.
A
We
can
configure
the
behavior
of
our
country
routing
and
that's
the
idea.
The
basic
idea
of
compostable
routing
as
part
of
compostable
routing.
We
have
smart
records,
smart
records,
it's
the
persistence
layer
so
in
the
end,
is
the
data
that
protocols
will
use
to
interact
one
with
each
other.
So
what
we're
trying
to
solve
here
is
that
actually
right
now
we
don't
have
a
standardized
shared
public
medium
in
order
to
share
data
between
different
protocols.
A
We
have
the
dhc
when
we
have
provided
records
peer
records
and
we
can
check
information,
but
we
it
has
it's
only
used
by
the
dht.
We
don't
have
a
way
of
maybe
fetching
these
provider
records
using
bitswap
or
any
other
protocol,
and
the
idea
is
to
generalize
the
dht
and
the
key
value
to
get
of
the
dht
so
that
we
can
store
arbitrary
data
and
we
decouple
it
from
the
transport.
A
So
we
would
be
able
to
use
different
provider
records
or
store
whatever
we
want
in
dhc.
Without
having
to
mess
around
with
the
dht
protocol
implementation,
we
would
be
able
to
have
different
protocols
and
different
versions
coexist.
We
could
have
different
versions
even
of
a
retrieval
market
protocol,
leveraging
the
information
that
the
different
these
different
versions
are
using
in
the
system.
We
could
do
fair
exchange
and
we
could
unlock
all
the
kind
of
information
where
we
store.
Like
indexing
information.
A
We
can
have
orders
using
the
store
in
smart
records
and
we'll
see
in
a
moment
a
quick
example.
So
the
model
is
pretty
straightforward.
Every
edge
peer
has
their
own
space
in
the
smart
record,
visual
machine
in
order
to
store
information
and
they're
able
to
store
whatever
they
want,
and
they
only
merge
and
like
mess
around
with
the
information
in
their
public
space,
and
then
someone
that
is
fetching
the
record
will
be
able
to
aggregate
according
to
the
information
that
peers
have
been
posting.
A
This
is
the
data
types
that
we
have
in
viennese
ipld
with
an
additional
type,
which
is
a
predicate
that
is
used
for
smart
tags
and
also
to
trigger
different
information,
so
trigger
different
actions
in
the
smart
record,
in
the
composable
routing
and
in
the
smart
record
framework,
and
for
I
mean
all
of
these
data
also
has
a
metadata.
So
we
will
be
able
to
material
data
like,
for
instance,
a
ttl
in
order
to
let
records
expire
and
what
I
want
to
show
you
now.
A
There
are
a
bunch
of
of
reports
with
code
that
you
can
check
out
and
this
can
be
used.
I
can
share
it
inside
and
I
want
to
show
a
quick
example
of
a
child
application
built
on
top
of
smart
records
and
also
house
as
reachable
smart
tag,
and
some
smart
tags
would
work
in
an
example.
So
I'm
gonna
share.
I
don't
know
if
I'm
running
out
of
time.
Please
pick
me
if
I'm.
A
A
A
I
mean
we
call
it
that
it's
an
easy
tool
that
we
use
to
debug
smart
records,
where
you
fetch
the
smart
record
for
the
in
a
certain
key,
and
you
can
see
here
that
with
it's.
This
is
what
we're
storing
the
smart
record.
So
for
a
nickname,
we
have
the
messages
and
the
different
sequence
numbers
that
would
allow
like
the
client
at
the
end.
What
it's
doing
is
fetching
the
the
the
records
and
make
sense
of
what
are
the
updates
and
what
is
the
information
that
it
needs
to
show
in
this
ui?
A
So
this
is
an
example
of
something
that
we
could
do
and
I'm
going
to
show
you
what
are
smart
tags
so
here.
What
I
have
is
a
simple
example:
where
what
we're
doing
is
initializing
three
different
hosts.
We
have,
I
mean
we
connect
two
of
them.
We
start
we
put
h1
being
the
server.
The
smart
record
server
needs
to
the
client
and
we
have
a
bunch
of
records
that
we'll
see
in
a
moment
that
have
predicates
and
these
predicates.
What
they
will
do
is
trigger
actions
and
what
we
do
is
like
update.
A
A
A
What
it
says
is
that
we
check
that
what
it's
behind
and
like
after
it
it's
a
link,
then
here
we
would
have
a
link
for
a
cid
and
we
can
have
like
a
list
of
different
places
where
dcid
is
so,
we
could
store
information
about
what
is
the
link
in
ipfs
and
then
the
peer
id.
We
could
put
the
sector
id
in
case.
A
If
this
is
most
addressed,
this
will
be
processed.
So
when
we
update
here,
we
have
another
record.
These
are
merged
because
I'm
putting
like
I'm
the
same
peer
writing
the
same
record,
and
we
see
that
here
the
predicates
are
removed
because
the
the
vm
makes
sense
of
it
like
here.
We
see
that
it
checked
that
it's,
it
was
a
valid
cid,
so
it
left
it
there
here.
A
A
A
D
Yeah,
so
I'm
gonna,
I'm
gonna
demo,
our
gateway
to
do
that.
I'm
gonna
use
actually
an
app
that
was
built
during
the
web3
weekend,
one
second,
so
this
is
kind
of
an
app
that's
built
on
top
of
the
gateway
that
we
made.
So
it's
kind
of
a
way
to
start
from
the
use
case,
mostly
to
really
narrow
down
on
what
is
needed
for
the
retrieval
market
to
function
and
kind
of
power.
Some
of
the
current
web
3
use
cases
that
are
out
there.
D
So
we
kind
of
made
this
concept
during
web3,
and
so
it's
kind
of
this
basic
kind
of
dab
experience
that
you
have
and,
for
example,
I'm
kind
of
minting
an
nft.
So
I'm
going
to
upload
something
I
want
to
upload
this
gif
of
fastly
being
down
today
to
make
this
kind
of
a
a
you
an
important
moment
in
history.
D
So
this
is
the
gif
it's
ready
to
submit,
and
so
I'm
just
kind
of
selecting
a
cover
and
then
once
I'm
ready,
we
can
imagine
how
it
would
look
like
for
to
pay
for
the
storage
in
that
situation.
But
right
now
this
is
not
implemented,
and
so
right
now
what
happens?
Is
it's
immediately
getting
cashed
on
our
gateway?
So
then,
when
it's
done,
you
kind
of
have
that
root
c
id
and
everything,
and
then
it
it's
already
kind
of
cached
there
on
the
gateway.
D
And
so
then
what
you
know
you
can
just
have
it
there
and
eventually
it
we're
looking
at
ways.
I
mean
it's
not
a
priority,
but
eventually
it
could
be
aggregated
into
a
storage
deal,
but
what
we're
most
interested
in
right
now
is
kind
of
the
retrieval
capability.
So
right
now
you
know,
caching
is
satisfying
for
it
for
this
app
and
so
our
users
can
kind
of
run
a
pop
node
if
they
wanna
replicate
the
content.
D
I
want
to
make
sure
the
the
node
is
completely
clean,
and
so
I
can
pick
kind
of
my
region
so
right
now
I'll
just
pick
global
in
europe
I
mean
actually
so
global
is
kind
of
the
free
region,
so
I
don't
need
to
pay
for
transfers
and
so
automatically
I'm
kind
of
joining
the
network,
and
I
can
kind
of
see
if
I'm
connected
to
the
nodes.
So
it
looks
like
I'm
connected
to
the
gateway
and
another
node
and
so
by
default.
D
I
think
it
takes
a
little
time,
so
it
would
take
60
seconds,
but
within
those
first
seconds
I'm
basically
automatically
replicating
the
most
popular
content,
that's
on
the
gateway.
So
by
joining
the
network,
I
can
already
have
content
dispatch
from
me
to
my
node.
So
I
think
we're
just
going
to
check
it
out
see
if
there's
anything
so
it
looks
like
it's
still
taking
some
time
to
get
here.
But
what
happens
is
I'm
I'm
also
exposing
the
same
gateway
so,
like
the
gateway?
D
That's
running
you
know,
that's
hosted
is
the
exact
same
way
same
node
same
code,
that's
running
here.
So
if
I
wanted,
I
could
run
this
dap
with
my
local
node
and
not
rely
on
our
gateway,
for
example,
and
so,
if
I
want,
I
can
retrieve
that
content.
So
I
could
retrieve
the
content
from
the
vault
directly
from.
D
And
then
it
should
load
it
if
everything
goes
well
from
the
node,
so
this
is
actually
telling
me
that
it's
replicated
15
okay,
so
this
is
still.
This
is
giving
me
some
information
about
what
is
in
that
transaction.
So
this
is
the
the
gif
there's
actually
the
username
as
well
and
the
preview,
so
I'm
actually
interested
in
in
the
the
gif.
So
I'm
just
gonna
go
like
this,
and
here
it
is
so
it's
fetched
it
from
the
the
gateway.
So
I'm
actually
now
I'm
I'm
fetching.
D
Oh
my
nose
crashed,
but
essentially
what
happens
is
I
should
have
as
well
some
of
the
most
popular
content
from
from
the
gateway
cached
as
well
here
and
so
kind
of
the
plan
that
we're
doing
is
basically
the
the
gateway
doesn't
cache
everything,
so
it
doesn't
have
unlimited
storage.
So
what
happens?
Is
it
only?
You
know
it
has
kind
of
this
eviction
scheme
where
it
will
just
start
offloading
and
removing
the
least
popular
content,
but
it
automatically
replicates
content
to
of
the
peers
in
the
network.
D
So,
by
default,
once
it
it
wants
to
get
content
that
it
doesn't
have,
it
will
start
paying
providers
to
retrieve
that
content
from
other
nodes
that
join
the
network.
So
this
is
kind
of
how
we're
on
boarding
our
first
providers
and
then
the
gateway
is
a
way
to,
like
you
know,
start
onboarding,
content
and
caching
it
and
then
we're
looking
at
ways
to
store
it
as
well.
You
know
on
regular
falcon
deals,
so
this
is
the
demo
right
now.
A
E
Yes,
hello,
everybody
cool,
so
what
I'm
going
to
show
you
today
is
a
very
rudimentary
way
of
doing
retrievals
from
falcon
for
just
a
part
of
the
dag
that
is
stored
in
a
in
a
deal
now.
This
is
all
very,
very
early
work.
The
upside
is
that
it
works
with
unmodified
miners
on
powerpoint
today.
So
all
you
need
is
basically
just
to
apply
pr
to
your
already
existing
pr
to
your
client,
and
you
will
be
able
to
do
this
yourself.
E
The
downside
is
that
you
kind
of
need
to
know
what
you
put
into
the
deal
ahead
of
time
and
have
some
sort
of
structure
and
so
on
and
so
forth.
So
let's
go
to
that
real
quick.
So,
as
you
know,
we
are
on
a
project
called
energy
storage,
where
basically,
we
take
a
bunch
of
really
really
small
content
and
aggregate
it
together
into
deals
and
then
produce
some
alcohol.
E
This
is
one
of
the
contents
of
such
deals.
What
we
actually
do
is
we
opted
for
very
like
basic
old-school
unix
that
has
explicit
sharding,
where
we
literally
take
the
we
normalize
everything
into
cit
version
one,
and
then
we
bastards,
two
city
version
one,
and
then
we
just
take
the
last
two
characters.
E
Put
it
into
a
directory,
then
take
gloves
four
characters,
put
it
into
another
directory
and
then
put
them
the
entity
or
whatever
the
content
is
there
itself
it
can
be
a
file,
it
can
be
like
any
other
deck.
It
doesn't
mean
that
gateway
should
be
able
to
render
it,
but
the
actual
directory
structure
is
renderable
and
the
other
important
thing
is
that
once
we
put
all
of
this
together,
we
have
a
so-called
batch,
manifest
united
united
json,
where
we
put
a
full
record
of
everything
that
we
place
in
this
particular
deal.
E
E
E
E
Is
that
and
then
get
me
like
the
deal
idea
and
which
miners
have
it
so
this
particular
video
has
been
stored
with
five
minus
and,
as
I
showed
you
earlier,
we
have
the
very
first
file
being
a
specific,
well-known
defined
thing.
So
let's
go
ahead
and
retrieve
that.
So
what
I'm
doing
here,
I'm
saying
you
know,
like
usual
standard
trip,
alola
local
for
the
sake
of
the
demo,
so
that
I
actually
pulled
it
from
my
own
note.
E
So
we're
going
to
run
that
it's
going
to
say
success
and
we're
going
to
see
what
we
have
in
manifest.json
and
what
we
have
is
this,
so
we
basically
have
our
preamble,
which
is
basically
a
very,
very
short
thing
to
let
you
and
like
figure
out
what
you're
looking
at
then
a
summary
like
how
many
we
we
aggregate
in
here.
How
are
they
sorted?
So,
for
example,
we
could
do
binary
search
on
the
rest
of
this
file.
E
If
you're
looking
for
a
particular
piece
of
content,
and
then
we
have
each
individual,
you
know,
I
think,
listed
all
whatever
many.
You
know
thousands
of
them.
So
then
what
we
do,
let's
say
we
want.
I
know,
let's
take
one
of
this
larger
one.
So,
for
example,
this
one-
let's
say
we
want
to
pull
out
this
cid.
E
E
E
And
it's
again
going
to
run
and
it's
going
to
retrieve
just
the
13
kilobytes
530
of
this
particular
file,
and
if
I
didn't
do
a
lot
below
local,
it
would
actually
go
ahead
and
do
the
deal
with
the
miner.
There
are
still
some
things
that
we
are
working
on
specifically
here,
like
I
already
skipped
my
payment
channel,
because
I
I'm
expecting
a
max
price
of
I'm
basically
asking
that
I
don't
want
to
to
pay
the
fuel
right
now,
but
right
now.
E
Basically,
what
happens
in
the
background
is
that
the
miner
is
unpacking
this
deal
into
a
box
or
just
to
give
me
this
little
piece
piece
of
data
in
another.
Hopefully,
two
to
three
weeks,
we
will
land
improvements
where
the
miner
will
not
have
to
do
that,
and
this
retrieval
will
actually
be
very
possibly
in
the
sub
second
range
and
yeah.
That's
pretty
much
my
demo
and
please
ask
questions
for
later.
A
All
right,
thank
you,
so
much
riva
by
the
way,
if,
as
folks
present,
if
you
have
links
to
either
the
the
code
that
you
use
or
the
scripts
that
you
used
or
the
the
slides
that
you
used
and
if
you
want
to
share
them,
one,
that's
like
that'll,
be
great
as
well
cool.
Let's
go
to
the
next
one.
This
one
is
from
the
pegasus
team.
So
peter
and
xenia.
G
Yeah,
I'm
here
so
I'm
just
gonna,
provide
the
very
brief
overview
for
people
who
haven't
been
following
this.
So
we've
got
a
single
hot
dht
that
we've
been
working
on
for
this
current
poc
that
we're
almost
ready
to
deliver,
and
so
zhenyang
is
going
to
show
a
quick
video
which
will
walk
us
through
it
anyway.
Over
to
you,
john
yang.
G
H
So
I
haven't
accelerated
the
video
which
I'll
do
it
manually
now.
So
basically,
what
I
did
is
I
run
a
plc
to
integration
test,
so
we
haven't
got
a.
Unfortunately,
we
haven't
got
a
user
interface
ready,
so
everything
right
now
is
through
an
integration
test.
So
I
just
quickly
just
quickly.
Is
there
a
way
to
like
accelerate?
Maybe
not
yet.
G
But
yeah,
so
what
jen
yang's
saying
is,
though,
that
we've
got
servers
which
are
being
run
as
docker
containers
and
you've
got
libraries
which
offer
programmatic
apis,
and
so
at
the
moment,
yeah
we
don't
have
like
command
line
tools
to
operate
those
programmatic
apis.
The
idea
is
to
integrate
those
libraries
into
applications
yeah
anyway.
I
just
use.
H
H
Cool:
it's:
okay!
Okay!
It's
my
slide
again:
yes,
yep
good,
okay!
So
yes,
I
probably
just
explained
what
happens
in
the
video
now,
so
I
just
briefly
go
through
what
happens
in
the
plc2
test.
So
what
happens
first
is
that
we
first
start
a
network
of
32
gateways
and
three
providers
gateways
are
configured
in
a
way
so
that
their
ids
are
spent
over
the
entire
dht
ring,
in
this
case,
that's
from
o
on
zero
zero.
H
So
in
order
to
minimize
the
offer
size,
instead
of
sending
the
original
offer
back,
it
will
one
will
generate
a
subsidy
offer
containing
only
the
cid.
That
client
is
asking
for
plus
a
microproof,
showing
that
the
cid
requested
is
indeed
part
of
the
original
cid
array.
So
you
could
imagine
that
a
provider
can
pack
a
few
hundreds
or
maybe
a
few
thousands
of
cids
into
the
same
city
offer.
So
in
this
way
we
can
minimize
the
bytes
transferred
between
between
gateways
and
clients.
H
So,
in
this
case
after
client
to
receive
the
offer,
it
will
do
two
things:
first,
verifying
the
microproof
to
make
sure
that
cid
1
is
indeed
part
of
the
original
group
offer
and
second
verifying
the
offer
signature
to
show
that
this
offer
is
indeed
coming
from
a
provider.
So
a
provider
zero
here
is
just
an
another
screenshot
of
the
process
and
apparently
it
has
only
like
three
lines
of
logs,
but
you
know
the
story
stories
behind
it
up
to
this
point.
H
It
is
basically
what
we
have
done
for
plc1
integrated
with
the
payment
system.
Next,
we
test
the
dht
network,
starting
from
publishing
offers,
so
provider
can
choose
to
publish
offer
to
the
dht
network.
For
example,
in
this
case,
we
use
provider
0
to
publish
a
cid
offer
containing
cid
4
to
the
phd
network.
The
provider
identifies
16
gateways
in
the
network
whose
ids
are
closest
to
cid
4,
in
this
case
from
gateway
6
to
gateway,
21
and
here's
an
another
screenshot
of
testing
publish
dht
offer.
H
So
if
a
client
couldn't
find
the
offer,
you
stand
off
a
discovery.
For
example,
client
does
a
standoff
for
discovery
with
gateway27,
but
gateway
tournamentism
couldn't
find
any
offer
containing
cid
4
locally.
So
what
the
client
can
can
do
is
the
client
can
choose
to
ask
the
gateway
27
to
discover
the
offer
using
the
dht
network.
H
H
H
Then
the
client
verify
each
response.
They
call
them
to
obtain
the
actual
offer
and
here's
the
the
login
when
we
do
the
dht
discovery
and
that
probably
isn't
very
informative
yeah.
Finally,
we
add
some
new
gateways
to
the
system
to
test.
If
gateways
provide
us
in
the
existing
network
can
detect
this
new
gateway
and
can
update
their
dht
ring
correctly.
So,
yes,
this
is
briefly
what
happened
in
the
video
we
showed
earlier
and-
and
it
is
actually
a
very
simplified
version
of
the
actual
testing.
H
A
B
F
A
C
Yeah
so,
basically
like
we're
working
on
the
proposal
of
s3,
compatible
storage
gateway
to
firecoin,
so
basically
like
there
was
a
couple
of
people
was
asking
in
the
slide
about.
There
was
a
project
called
a
firebase
which
is
give
you
a
bridge
from
from
s3
feels
like
sdk
to
the
cr
storage.
So
now
people
is
asking
that
we
have
something
similar
in
the
private.
C
So
as
a
lot
of
people
was
using
that,
so
we
decided
to
make
the
mineral
io
and
then
we
take
it
for
the
io
repository
and
add
the
sun
function
with
icon.
So
basically,
to
easily
understand
is
that
we
are
exporting
the
key
to
volume
key,
so
we
can
copy
the
file
locally
and
then
from
logo.
We
can
upload
to
remote
menu
instance
of
the
upload.
There
will
be
able
to
generate
car
file
and
start
sending
deals
to
the
bracket
network.
C
C
C
C
C
Yeah,
this
is
the
mini
server.
We
started
as
a
container
locally
and
you
will
be
able
to
make
synchronize
it
using
the
tool.
You
can
export
those
security
key
and
the
server
address
and
using
the
wallet
which
one
you
want
just
in
the
deals,
but
you
needed
to
running
a
node
locally,
so
you
can
still
have
an
idea.
C
C
C
C
That's
pretty
much
about
the
demo,
so
we
still
have
work
finished.
Yet
the
remaining
part
is
after
it
was
stored.
How
can
we
retrievable,
though,
put
those
id
on
the
gui
interface,
so
user
can
directly
copy
the
side
and
start
downloading
and
using
the
gui
to
bring
the
share.
So
this
part
I'm
not
done
yet,
but
the
first
part
of
the
command
line
almost
done
yeah.
Let's
just
quick
thank
demo.
A
A
A
A
question
for
you
from
juan
about
the
language
for
the
smart
records
and
its
ipld
compatibility:
okay,
yep!
So
actually
we
have
a
super
set
of.
I
mean
the
language
compiles
to
ipld.
So
under
the
hood
we
have
ipld
and
it
marshals
to
ipld
and
it
could
be
store.
I
mean
it's
ipld
in
the
end,
but
it's
a
schema
over
ipld
yeah.
A
One
thing
we
want
to
try
is
actually
because
I
know
and
danny's
working
on
reflect
and
reflect
tool
for
ipld.
So
we
want
to
try
because
right
now
we
use
schemas,
but
we
want
to
see
how
it
works
with
reflex
and
ipld
so
that
we
can
have
code
types
the
same
way
that
we
have
code
types
right
now.
So
this
is
something
that
we
want
to
explore.
A
F
B
J
B
Cool
so
yeah
deal
bots
the
so
the
pl
will
eventually
be
publishing
the
results
of
the
videobots
we
run
to
so
that
they
can
be
used
by
like
reputation,
services.
It
will
theoretically
be
maybe
possible
for
multiple
people
to
be
running
gearbots
and
multiple
representation
services
to
be
consuming
them.
That's
not
yet
happening.
The
code,
however,
is
open
source
and
you
can
run
your
own
dealbot
and
use
it
to
you
know.
B
J
B
And
it's
available,
you
could
just
find
it
at
falcon
project,
slash
dealbot
and
there's
a
there's,
a
readme
that
shows
some
of
the
commands
that
you
run
to
to
get
things
started
and
how
you
can
cue
things.
I
am
actually
very
briefly
going
to
bring
up
my
terminal,
which
is
connected
to
a
running
dealbot
miner.
You
can
see
I've
got
this,
let's
see
yeah,
we
have
our
controller
running
here.
I'm
gonna
actually
stop
it
for
just
a
second,
so
you
can
see
here
we're.
J
B
Is
the
command
we're
starting
up
a
deal
bot
we're
telling
it
where
it's
gonna
listen
and
serve
its
api
or
starting
up
a
deal
about
controller
we're
gonna,
we're
telling
it
where
to
serve
its
api?
It
stores,
you
know
the
tasks
in
a
database
here
we're
just
using
sqlite,
but
you
can
also
use
postgres
and
then
and
then
over
here
is
where
we
are
actually
running.
B
Well,
that
might
not
have
been
the
best
plan
to
stop
our
controller
for
our
next,
in
any
case
so,
and
here's
our
command
to
start
up
our
our
daemon
and
you
can
see
we're
telling
it
to
start
we're
telling
it
where
lotus
is
and
and
then
we're
also
telling
it
how
to
connect
to
to
the
controller,
and
so
it's
starting
up,
and
if
there
are
tasks
available,
then
it
will
start
pulling
those
tasks
off
here.
I'm
gonna
go
ahead
and
actually
start
up
a
few
tasks.
B
Just
so
you
all
can
see
this,
and
if
you
look
at
so
here's
a
list
of
five
minor
deals,
these
are
all
going
to
be.
Retrieval
deals,
we're
putting
you
know.
So
it's
just
a
pair
of
miners
and
payloads
cids
you
can
just
this
is
just
a
json
file,
and
so
now
I'm
gonna
run
our
script,
which
will
actually
allow
us
to
import
those.
So
this
is
gonna
go
ahead
and
cue,
those
up
into
the
controller.
B
If
we
go
back
over
to
the
controller,
we'll
see
that
they've
been
queued
up
and
then
we
are
probably
going
to
see
that
if
we
go
back
over
to
our
deal
bot
that
it
is
now
starting
to
oh
whoa,
well,
that's
an
error
that
we
will
need
to
check
afterwards.
You
can
see
that
it
started
to
pull
off
tasks
and
execute
them.
We'll
need
to
we'll
need
to
fix
that
in
a
moment
in
any
case
yeah.
So
that's
what
it
is.
It's
it's
it's
mostly.
B
I
don't
know
how
much
y'all
were
gonna
wanna
like
do
it
immediately.
I
mean
run
dealbots
immediately
for
your
own
work,
but
it's
nice
to
know
it's
out
there
and
it
should
particularly
those
of
you
guys
who
are
in
the
reputation
world.
This
will
be
probably
a
useful
tool
for
you,
the
relationship
between
dealbot
to
the
markets.
It
finds
and
makes
deals
on.
Yeah
I
mean
so
so
we
are.
B
The
dobot
is
intended
to
be
a
sort
of
like
impartial
deal
maker
that
you
know
we're
taking
various
steps
to
make
it.
You
know,
ideally
not
very
gameable
for
minors
and
the
intent
is
for
it
to
publish
the
results
of
its
deals
and
in
a
way
that
makes
them
you
know,
and
those
deal
the
the
deals
will
be.
You
know
relatively
impartially
made
so
that
you
get
some
sense
of
how
minors
are
doing
in
serving
deals.
A
All
right,
folks,
okay,
thank
you!
So
much
for
the
great
demos
and
questions
on
on
slack
well,
see
you
in
two
weeks
keep
up
with
the
great
progress,
and
I
see
that
there's
like
a
lot
of
people
asking
for
links
to
to
try
things
out.
So
if
you
have
time
to
share
those
yeah
well,
I
think
there
will
be
more.
There
will
be
more
questions
after
people
get
to
try
it
out
as
well.