►
From YouTube: PSF TSC Meeting - 04/14/21
Description
Technical Steering Committee (TSC) meeting.
Here is the agenda from this meeting:
https://github.com/Permissionless-Software-Foundation/TSC/issues/7
A
A
C
A
A
Yeah
yeah
and
since
you're
here
I
I
want
to
talk
about
maybe
moving
forward
with
with
some
grants
for
the
nft
stuff.
Let
me
go
ahead
and
share
the
agenda.
Stoian.
Do
you
have
anything
specific
you
want
to
cover
today?
We
could
you
know
depending
on
if
it's
a
burning
thing,
we
can
cover
it
right
now
or
we
can
cover
it
after
we
go
through
the
agenda.
A
A
It
now
uses
the
new
utxo.getcall.
That's
been
added
to
the
bchjs,
javascript
library
and
what's
nice
about
this,
is
it
tease
us
up
for
work
with
nfts,
because
you
just
make
this
one
call
you
give
it
an
address
and
it
comes.
It
returns
all
the
utxos
associated
with
that
address,
hydrated
with
slp
token
information,
if
they're
slp
tokens
and
categorized
into
different
arrays,
depending
on
whether
that
token
is
whether
it's
like
a
type
1,
slp
token
or
an
nft
token
or
group
token
or
mint
baton.
A
C
A
A
So
people
using
the
web
wallet
should
not
experience
rate
limits,
but
if
you're
building
your
own
app
and
you're
calling
bchjs
or
using
minimal
slp
wallet,
it
will
count
against
your
rate
limits
so
yeah.
So,
yes,
and
no
and
again,
that's
just
really
to
to
keep
things
to
keep
things
fair
so
that
so
that
people
aren't
penalized
or
unfairly
penalized.
You
know
if
you're,
just
making
very
low
computationally
heavy
in
terms
of
computational
heaviness,
if
you're
making
just
like
a
call
to
the
full
node
to
get
a
transaction.
A
That's
really
light,
and
that's
one
api
call,
whereas,
like
this
one
utxo
get
call,
will
will
set
off
a
whole
chain
reaction.
That's
that's
very
computationally
heavy,
so
we
need
a
way
of
sort
of
making
that
all
fair,
so
that
that
was
the
best
I
could
come
up
with
was
sort
of
tracking
the
internal
api
calls
and
having
that
count
against
your
rate
limit.
C
C
A
Yeah,
that's
a
good
point.
That's
a
good
point.
So
in
that
case
that
get
call.
So
if,
if
you
don't
have,
if
you're
calling
it
on
addresses
that
don't
have
tokens
it's
not
as
heavy
because
it
won't
need
to
make
it
won't
need
to
hydrate
those.
Your
the
the
the
hydrate
call
will
come
back
very
quickly,
saying
like
I
I
don't.
I
haven't
detected
any
tokens
that
that
you
know
that
I
suspect
so
it.
B
A
A
It's
an
array
of
just
unvalidated
tokens,
so
that
makes
it
easy
for
a
wallet
developer
to
basically
just
ignore
that
array,
and
that
way
they
can
be
sure
that
they
they're
not
at
risk
of
burning
a
token
and
so
that
that's
a
possibility.
This
is
where,
like,
depending
on
a
wallet
developer
like
they
have
options
they
they
could
just
use
the
straight
up,
bchjs,
library
and
and
do
these
like
they
can
either
use
the
utxo.
A
Get
call,
but
then,
if
they
want
to
optimize
from
there,
that
call
is
really
just
a
combination
of
lower
level
calls
that
are
also
available
in
bchjs,
so
it's
possible
to
depending
on
how
the
developer
wants
to
do
it.
I
want,
I
think,
the
different
ways
in
which
they
want
to
optimize
it's
totally
possible
to
basically
get
all
the
utxos
back
from
electrumx
and
then
scan
each
one
for
an
op
return
and
then
and
then
basically
ignore
the
ones
that
have
an
op
return
or
have
an
op
return.
A
C
Because
on
the
telegram
groups
there
was
several
like
calls
for
the
how
to
see
bsh
as
a
service
and
the
full
stack
that
cash
was
mentioned
as
a
possible
solution,
but
because
now
there
is
still
a
lot
of
funds
about
this
around
these
tokens.
So
we'll
be
there
sop
or
there
was
several
another
proposals,
so
some
of
the
wallets
they
just
care
for
fast
bsh
payments
too.
C
B
C
C
A
They
definitely
can,
and
if
there
was,
if
there
was
a
big
interest
in
this
of
like
hey,
we
want
fast
low,
not
heavy
api
calls
it's
just
bch.
I
could
create
another
end
point
that
could
that
could
service
that,
though,
that
need
yeah,
it's
definitely
possible.
I
mean
the
the
real
trick
there
for,
for
everyone
is,
if
you
don't
care
about
tokens,
it's
just
not
burning
tokens.
A
A
A
Tell
you
the
group
token
that
it
came
from,
and
so
now
that
we
have
this
the
slush
fund
for
bounties.
That's
been
that's
been
approved.
We
have
funds
for
that.
So
I'm
thinking
about
just
rolling
that
into
a
bounty
to
have
you
create
those
rest
api
endpoints,
since
it's
taking
me
forever
and
then
and
then
that's
everything
we
need
to
start
creating
plugins
for
cash
that
can
they
can
nicely
display
nfts.
A
So
if
that's
of
interest
to
you,
let's,
let's
talk
about
that
offline
and
we'll
work
on
getting
a
bounty
together
and
put
a
scope
of
work
together
for
that
work,
because
I
think
I
think
you're
perfectly
positioned
to
do
it.
You
understand
everything.
That's
going
on
and
I'm
tired
of
holding
you
back.
C
Yeah,
it's
good
to
have
some
progress.
Yeah
I
made
some
open
source
like
viewer.
It's
a
ready,
react
component
name
nft
card,
so
you
can
just
put
this
inside
the
wallet
you
need
to
display
the
the
nfts.
Even
now
oh
cool,
it
does
not
depends
from
psh
gs
or
slp
gs.
Whatever
it's
just
rest
calls,
oh
cool.
It
will
work
even
now
with
any
wallet.
A
C
A
C
D
C
B
C
C
C
A
Cool
I'm
going
to
pull
up
your
library
on
npm.
Just
so
people
know
what
we're
talking
about
it's.
It's
bcp,
js,
yes,
and
so
this
is
a
tool
that
that
you
developed
for
analyzing
nfts
on
the
bitcoin
cash
chain
and
yeah,
and
you
have
these
types
like
different
types
of
media
formats,
so
you're
saying
that
four
is
ipfs.
A
C
C
B
C
B
A
B
A
D
A
Okay,
so
going
back
to
the
agenda,
so
that's
cool,
so
that's
yeah,
we're
cooking
along
on
the
nft
front.
So
that's
great
the
great
to
see
because
I
think
the
bubblishness
of
nfts
is
starting
to
decline.
I
don't
know
that's
just
a
gut
feeling.
I
could
be
wrong
about
that,
but
I
think
that
enough
people
have
been
impressed
with
nft
tech,
but
it's
here
to
stay
and-
and
it
should
it's
just
like
in
2017,
I'm
so
reminded
of
2017
at
this
point
where
there
was
like
this
mania
in
price.
A
But
there
was
this
undercurrent
of
like
steady
development
that
happened
like
before
the
price
spike
and
after
the
price
spike-
and
I
think
that's
where
we're
at
like
with
the
nfts
is
we're
just
like
steadily
working
on
it
and
we're
not
going
to
get
it
done
in
time
to
to.
You
know,
keep
the
hype
going
so
there's
probably
going
to
be
a
crash
in
prices
with
regard
to
nfts,
but
we'll
just
keep.
Building
and
and
yeah.
C
A
A
A
I
mean
they're
focused
more
on
the
ethereum
side
of
things,
but
they've
got
a
lot
of
tools
for
creating
nfts,
putting
the
payload
on
ipfs
backing
the
payload
up
on
filecoin
and
I
haven't
really
had
a
chance
to
dive
into
it.
But
but
it's
very
complementary
to
the
work
I
see
you
doing.
They
will
even
soon
have
some
seminar.
I.
B
A
A
A
Call
so
if
people
want
to
pull
up
this
documentation,
it's
at
bchjs.fullstack.cache,
but
basically
you
can
give
it
I
would
I
should
have.
I
should
have
come
up
with
an
example
of
what
you
get
for
the
output,
but
if
you
look
at
a
transaction
on
the
block
explorer
yeah,
that's
what
we're
doing
right
here.
You'll
see
that
there's
inputs
on
the
left
and
outputs
on
the
right,
and
what
this
call
will
give.
You
is
the
same
information
that
you'd
get.
A
It
starts
with
the
same
transaction
information
you
get
from
a
full
node,
but
on
a
full
node
on
the
inputs.
There's
not
going
to
be
any
addresses
or
value
in
terms
of
like
how
much
bitcoin
cash
was
in
it'll
only
show
you
addresses
and
bitcoin
on
the
outputs.
So
what
this
call
does
is
it
it
sort
of?
Does
that
backwards,
work
to
to
figure
out
what
were
the
input
addresses
and
the
input
amounts?
A
So
you
have
them
both
on
the
inputs
and
the
outputs,
but
then
it
goes
one
step
further
and
it
hydrates
the
inputs
and
outputs
with
token
information
so
very
similar
to,
whereas,
like
explorer.bitcoin.com,
it
presents
this
information
graphically.
This
will
give
you
like
a
json
payload
that
contains
all
that
information.
So
it's
it's
the
same
sort
of
transaction
format
that
everybody's
been
getting
for
years
from
a
full
node
just
with
this
extra
information
added
to
it.
So
it's
pretty
handy
this.
A
A
I
was
hoping
joey
would
be
here
today,
so
he
could
confirm
this,
but
I
believe
this
is
getting
incorporated
in
cash
tab
so
that
he
can
so
that
your
wallet
can
easily
display
and
we'll
probably
roll
this
into
a
plug-in
for
wallet.fullstack.cache
too.
Now
that
we
can
easily
display,
like
your
transaction
history-
and
you
can
click
on
the
transaction
in
your
history
and
then
get
this.
This
kind
of
detail
like
was
this
tokens
and
how
many
tokens
and
how
much
bitcoin
cash
and
what
addresses
were
involved.
It
answers
all
these
questions.
A
A
I
don't
know
if
I
put
it
in
there
or
if
it's
just
some
legacy
code,
that
carried
over
from
the
bitcoin.com
rest,
that
the
that
our
the
bch
api
was
forked
from,
but
there
was
a
call
in
there
that
would
reset
the
big
number
to
only
work
with
eight
decimal
places.
So
if
you
had
an
slp
token
that
was
like
nine
decimal
places
or
bigger
it
would
it
would
truncate
it
and
it
would
result
in,
like
you
burn
those
tiny
fractions
of
of
your
token
and
anyways.
So
that
was
a
problem.
A
A
I
have
a
link
here
to
my
blog,
where
I
talk
about
ipfs
service
providers
and
there's
a
there's,
a
video
there's.
Actually,
I
want
to
point
out
three
blog
posts.
This
is
actually
like
a
series
of
blog
posts
of
research
that
I've
been
working
on
where
it
starts
talking
about
ipfs
apis,
and
then
I
introduce
chat.fullstack.cache
and
then
this
latest
blog
post
is
about
these
ipfs
service
providers
and
each
blog
post
has
a
video
or
two
to
accompl
to
accompany
it.
A
Hopefully
this
doesn't
kill
my
internet
connection
because
there
was
a
bug,
but
I'll
give
it
a
second
to
to
spin
up
here
and
but
basically
this
is
a
single
page
app
that
is
connecting
to
the
interplanetary
file
system
and
it's
currently
right.
Now,
it's
it's
going
out
there
and
it's
looking
for
other
computers
that
are
that
are
subscribed
to
this
pub
sub
channel
or
this
app
that
it
can
communicate
with
it.
Should
it
should
find
the
example
service
provider
here
pretty
soon
and
basically,
what
this
json
rpc
is.
A
A
You
know
today
is
location-based,
and
so,
if
a
state
actor
or
a
corporate
actor
wants
to
prevent
you
from
accessing
something,
they
just
block
that
location
where
the
data
is
and-
and
it's
easy
and
it's
done,
and
so
it's
just
very
easy
to
censor
people
from
from
content
on
the
internet.
That
way,
and
so
ipfs
is
really
good
at
jumping
over
firewalls
and
the
whole
point
of
chat.fullstack.cache
was
to.
A
Let
me
just
check
my
network.
Okay,
I
think
it's
being
well
behaved.
Okay,
there
you
go
just
found
there,
we
go.
We
just
found
the
service,
the
the
pier
here.
So
that's
another
pier
here
on
the
ipfs
network.
This
is
basically
a
chat
room
and
you
can
you
can
chat
with
people
and
and
once
you
have
chat,
you
then
have
everything
that
you
need
for
a
json
rpc.
A
A
Maybe
I
didn't
get
it
right,
but
if
I
go
list
peers
I
can
these
are
all
the
peers
I'm
connected
to
and
I
can
find
the
one
that
I'm
connected
to
these
are.
These
are
ipfs
handles
for
people
who
aren't
familiar
with
them,
and
so
I
just
I
just
asked
basically
it
about
itself-
I'm
going
over
this
really
fast,
because
there's
people
who
are
interested
in
this
can
do
the
blog
posts,
but
I
just
wanted
to
give
an
example
of
a
json
rpc,
so
here's
an
example
of
a
json
rpc
command.
A
So
if
I
go
here
and
I'm
not
sure
what
I
typed
in
wrong
it
should
there
we
go
now,
it
responded.
So
I
just
sent
it
a
command
and
it
responded
with
some
data
and
we've
already
got
these.
These
crud
endpoints,
where
you
can,
you
can
create
a
user
update,
a
user
get
users
delete
a
user,
so
you
can
create
a
user
get
jot
tokens.
So
this
is
a
way
of
providing
services.
Compute
computational
services
over
over
ipfs
so
like,
for
example,
wallet.fullstack.cash.
A
A
That's
behind
the
way
you
spend
money
with
bitcoin
is
the
thing
doing
the
end
to
end
encryption
and
yeah,
so
it's
really
powerful,
because
now
we
have
both
decentralization
on
the
provider
side
and
this
sort
of
robust
censorship
resistance
on
the
consumer
side.
So
I'm
I'm
pretty
excited
about
this.
I
think
this
is
a
big
deal.
A
A
A
Cryptocurrency,
so
just
moving
through
the
agenda,
a
related
idea
that
I'm
going
to
start
working
on
next
is
this
pay
to
write
database.
I
talk
about
this
in
in
this
blog
post,
as
well,
so
in
this
application,
when,
when
my
node,
which
is
in
this
web
browser,
is
talking
to
this,
this
other
node
it's
going
over
ipfs,
but
there's
this
database
called
orbitdb,
and
so
these
messages,
these
encrypted
messages,
they're
actually
getting
stashed
in
the
orbitdb.
A
And
what
this
does
is
it
prevents
dropped,
dropped
messages.
So
if,
if,
if
my
full
note,
if
it's
not
full
mode,
if
my
browser
was
to
go
offline
for
a
short
period
of
time,
like
10
or
15
seconds,
which
happens
a
lot
in
the
ipfs
network
when
it
comes
back,
it'll
get
any
messages
that
that
that
happened.
While
it
was
gone
and
so
the
same
orbit
db
tech,
I've
been
digging
into
it
and
there's
a
way
to
the
right
access
for
the
database.
A
I
have
I've.
I've
successfully
built
a
prototype
where
anyone
can
write
to
the
database,
but
in
order
to
do
so,
you
have
to
prove
that
you've
burned
an
slp
token
and
you
use
the
transaction
id
on
the
blockchain
as
your
proof
and
then
each
each
node,
that's
replicating.
The
database
will
independently
verify
that
that
this
new
entry
into
the
database
meets
this
this
rule
and
only
after
it's
been
independently
verified.
A
Will
that
node
accept
it
into
the
database,
and
so
it's
very
similar
to
a
blockchain
in
that
regard,
except
there's:
no,
there's
no
mining
and
I
think
that's
a
I'm.
I'm
really
attracted
this
because
there's
this
it's
it's
such
a
clear
and
straightforward
incentive
model
where,
if
we
build
software
around
these
pay
to
write
databases
our
token,
because
someone
would
have
like
it's
like
anybody
can
run.
So
let
me
just
give
an
example.
So
it's
not
so
highfalutin
torellis.cash
is
one
idea
I
want
to
use
this,
for.
A
They
can
share
that
data.
Anyone
can
fulfill
that
order
and
and
it
and
trade
with
you
on
a
peer-to-peer
basis
and
and
we
can
try
and
the
psf
is
incentivized
to
build
a
good
user
experience
around
this
whole
thing,
because
our
token
is
directly
becomes
directly
more
valuable
through
the
usage
of
this
database.
So
the
the
better
we
can
make
the
user
experience
we
directly
benefit,
because
in
order
to
use
it,
you
have
to
burn
our
token,
which
causes
the
price
to
go
up.
A
A
Yeah,
that's
a
good
question
so
that
it's
that
question
that
led
me
down
the
road
to
this
conclusion,
because
the
thing
about
operating
data
on
the
blockchain
is
the
incentives
are
not
aligned
and
it's
it's
a
scaling
problem
like
right.
Now
we're
doing
fine,
but
I've
been
in
a
lot
of
bitcoin
cash
developer
meetings
where
I've
like
posed
this
question.
A
Where
like
what,
if
we
thousand
x
the
transaction
volume
from
where
we
are
today,
you
know
so
we're
right
now
we're
around.
I
think
300
000
transactions
a
day.
So
if
we
started
doing
300
million
transactions
a
day,
slp
tokens
would
not
work
at
all,
like
basically
everything
that
involves
opera
turn
data
would
not
work
because
the
chain
would
get
so
big
so
fast.
A
That
we'd
have
these
massive
scaling
issues
and
and
there's
also
this
incentive
misalignment,
where
you
pay
to
write
that
data
to
the
chain
once,
but
then
everyone
from
then
on
has
to
bear
that
burden
and
you
do
not
pay
to
retrieve
the
data,
and
so
in
this
world
of
very
high
transaction
volume,
I
believe
everything's
going
to
run
as
a
pruned
node.
That's
the
only
way.
A
A
C
A
It's
actually
it's
at
its
core.
It's
it's
an
append
only
log,
because
it
works
on
ipfs
and
ipfs
is
all
about
immutable
data,
so
this
is
append
only
log.
So
that's
like
the
core
idea,
but
then
orbitdb
is
super
flexible.
It
can
be
a
key
value
store.
It
can
be
like
a
database
where
you
have
like
a
a
document,
store
they've
got
like
like
logs
and
feeds,
and
they
have
like
five
different
flavors
of
this
database,
but
at
all
at
their
core
they're.
A
But
we
don't
want
the
databases
to
get
too
big
so
every
hour
we
abandon
the
database
and
create
a
new
one
or
ev.
Every
user
does
that
and
that
keeps
the
databases
really
small,
but
it
still
achieves
the
goal,
which
is
to
prevent
dropped,
calls
or
dropped
messages
so
yeah,
it's
a
whole
another
tech,
like
a
lot
of
there's.
A
The
the
right
permissions
get
sort
of
baked
in
for
the
very
first
person
who
creates
the
very
first
instance
of
the
database,
those
those
right
rules
get
baked
into
it
and
they're
immutable
at
that
point.
If
anybody
tries
to
mess
with
them,
they'll
end
up
just
creating
a
different
database,
so
they
won't
be
part
of
that
that
database
and
then
it's
it's
immutable
and
append.
Only
so.
That's
that's
another
like
thing
to
keep
in
mind.
C
A
So
yeah,
so
this
is
just
in
the
idea
phase
right
now,
but
I
definitely
I'm
glad
we
had
a
moment
to
explore
it
and
if
anybody
watches
this
video
later
and
they
want
to
know
more
about
it
or
are
interested
in
exploring
it,
you
know
I
welcome
them
to
join
the
psf
telegram
chat
room,
but
this
is
going
to
be
this.
These
two
ideas,
the
json
rpc
over
ipfs
and
this
pay
to
write
database.
These
are
two
ideas.
I'm
very
fired
up
about.
A
I've
done
enough
research
to
know
that
like
to
essentially
eliminate
the
technical
risk
like
these
are
possible.
I
have
working
proof
of
concepts.
So
now
it's
a
matter
of
okay.
What
how
can
we
make
money
with
this
thing?
How
can
we
like
what
are
these
valuable
business
solutions
that
we
can
build
with
these
with
this
new
tech
that
that's,
where
I'm
at
with
with
these
two
things.
A
The
final
thing
on
the
agenda
to
bring
up
is
this
avalanche
slp
token
bridge.
This
is
coming
up
pretty
soon.
There's
there's
nothing
really
to
show,
but
don
wonton,
who
is
a
frequent
member
of
our
community
committee,
he's
been
funding
the
development
of
this
of
this
token
bridge
and
we've
got
the
one
way
of
the
bridge
working
where
you
can
send
a
token
from
the
avalanche
side
to
the
bitcoin
cash
side
and
we're
currently
wrapping
up
the
other
side
of
the
from
the
bitcoin
cash.
A
So,
probably
in
the
next
month,
we'll
have
a
you
know,
functioning
web
wallets
on
both
chains
and
it
won't
work
again.
I
have
to
always
emphasize
it.
This
won't
work
for
every
slp
token.
This
will
only
work
for
specific
tokens.
So
what
we'll
do
to
roll
this
out
and
let
people
play
with
it
is
we'll
have
a
token
faucet
on
both
chains,
so
you
can
just
go,
get
free
tokens
and
then
practice
sending
them
back
and
forth
just
to
just
to
learn
the
the
and
there's.
A
Also,
since
this
is
a
technical
meeting,
I
might
as
well
get
into
a
little
bit
of
the
technical
nuance.
The
way
this
works
on
a
technical
standpoint
is
on
the
bitcoin
cash
side.
There's
two
transactions
and
the
the
avalanche
side
is
actually
a
lot
more
straightforward,
the
bitcoin
cash
side
in
order
to
send
a
token
to
the
avalanche
side.
What
you
need
to
do
is
create
two
transactions,
so
you
create
a
transaction
to
send
your
token
to
the
bridge,
but
you
don't
broadcast
it.
A
You
generate
it
in
order
to
get
the
transaction
id
ahead
of
time
without
broadcasting
it
then
you
create
a
second
transaction
with
an
op
return,
similar
to
how
you
do
it.
Storing
with
the
bcp,
where
you'll
send
a
dust
transaction
to
the
token
bridge,
saying
with
the
op
return
data.
Being
you
know,
here's
here's,
the
transaction
id
that
I
want
you
to
look
for,
and
here's
the
address
on
the
avalanche
side.
I
want
you
to
send
the
tokens
to
then
after
the
bridge
receives
that
that
transaction.
It
knows
what
to
look
for.
A
Then
you
can
safely
send
the
tokens
to
the
the
bridge
where
it
will
then
receive
the
tokens,
burn
them
mint
them
on
the
avalanche
side
and
send
them
to
the
address
that
that
you
specified
in
the
op
return,
and
if
you
don't
do
that,
it's
default
behavior
will
be
to
just
send
the
tokens
back
to
you.
If
it
doesn't
know
what
to
do
with
the
tokens.
It'll
just
send
them
back
to
the
originating
address
on
the
avalanche
side.
It's
everything
can
happen
with
one
transaction
and
there's
no
confirmation
time
like
block
confirmation.
A
A
Yeah,
we,
I
think,
part
of
the
reason
why
there's
so
much
info
here
is
because
we
missed
the
I
was
out.
I
wasn't
able
to
to
host
the
last
technical
meeting,
so
we
got
like
a
month
worth
of
things
in
this
meeting,
but
yeah.
So
hopefully,
hopefully
in
two
weeks,
when
we
have
our
next
technical
meeting,
I'm
hoping
by
then
we'll
have
the
at
least
at
least
some
sort
of
command
line.
Script
to
run,
to
exercise
the
bridge,
so
that'll
that'll
be.
C
A
I
think
we're
going
to
do
both
because
the
slp,
client
and
really
what
I
need
to
do
is-
is
integrate
minimal,
slp
wallet
into
slp
clie
wallet,
so
that
so
that
we're
just
using
one
library,
one
wallet,
engine
library
and
we'll
probably
do
that
as
as
a
result
of
this
so
slp
cly
wallet
was
built
like
a
year
or
two
before
minimal
slp.
Well,
it's
it's.
A
This
sort
of
interactive
command
line
tool
for
rapidly
prototyping
bitcoin
cash
transactions,
minimal,
slp
wallet-
was
developed
just
a
few
months
ago,
and
it's
really
intended
to
be
a
front-end
library
for
web
browsers
to
to
add
so
it's
not
intended
to
be
interactive,
like
slp,
client
wallet
is
and,
and
so
I've
actually
been
been
slowly
converging.
The
two
libraries
together
so
that
min
slp
cly
wallet
would
use
minimal
slp
wallet
under
the
hood,
just
like
wallet.fullstack.cache
uses.