►
Description
Topics covered
----------------------------
0:54 - About the client
1:18 - About the guest
1:30 - Intro Ethereum JS team
2:30 - Building blocks for JS/ETH community
3:39 - Ethereum’s imminent mainnet Merge
4:33 - Merge ready fully functional (experimental client)
5:40 - Excitement along the way
6:33 - What does it mean for developers?
08:41 - A merge capable EVM/VM
10:28 - in-browser / in-app (WIP)
11:07 - Ultralight SDK for Portal Network
12:20 - New Sync mechanism
14:45 - Snap Sync - Gateway to mainnet syncing
18:22 - A decentralized backbone for JS/ETH ecosystem
19:19 - Contact of team
20:25 - Questions & Answers
20:47 - What is needed for Ethereum JS to become a fully functional client?
22:42 - Advantages of browser environment
26:26 - Why Ethereum JS releases are not added to the EF blogpost for upgrade public announcement?
29:09 - Challenges during the Merge devnet
31:10 - Future of Ethereum JS after the Merge
33:22 - Licensing - Why MPL 2.0
35:11 - Resources & contribution
36:20 - Any message for the community?
Resources:
-----------------
https://docs.google.com/presentation/d/18x1l4plj_HokVjotpsVF-oJYuK1KWJzeZc4HGujQsPI/edit?usp=sharing
Lodestar and The Merge with Gajinder Singh - https://youtu.be/aUg5ZFT59fA
TheMerge playlist - https://www.youtube.com/playlist?list=PL4cwHXAawZxqoLxXqZqT4hcYhoHoP6w12
KnowYourClient - https://www.youtube.com/playlist?list=PL4cwHXAawZxoruie1hmYWJfiakpYivXft
PEEPanEIP playlist - https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F
Check out upcoming EIPs in Peep an EIP series at https://github.com/ethereum-cat-herders/PM/projects/2
Follow at Twitter
-----------------------------------------------
Gajinder Singh @Gajpower | Pooja Ranjan @poojaranjan19
Check out upcoming EIPs in Peep an EIP series at https://github.com/ethereum-cat-herde...
Contact Ethereum Cat Herders
---------------------------------------------------
Discord: https://discord.io/ethereumcatherders
Twitter: https://twitter.com/EthCatHerders
Medium: https://medium.com/ethereum-cat-herders
GitHub: https://github.com/ethereum-cat-herde...
Website: https://www.ethereumcatherders.com/
A
A
Testing
devnet
and
public
test
net
merge.
Ethereum
blockchain
is
just
a
couple
of
weeks
away
from
the
main
net
March
as
ethereum
Caterers.
We
are
committed
to
sharing
information.
We
are
know
your
clients
to
increase
your
options
as
a
node
operator
to
choose
the
client
that
suits
you
the
best
and
is
convenient
running
a
note
post
merge
if
you
are
ready
to
be
an
ethereum
node
operator,
continue
watching.
A
Welcome
to
p
penny
episode,
85
I
am
pujaranjan
with
me,
is
an
ethereum
client
developer,
gajendra
Singh
and
we
are
going
to
know
more
about
ethereum
JavaScript
client
about
the
client
currently
managed
by
the
ethereum
foundation.
Ethereum
JavaScript
monoripo
is
one
of
the
oldest
client
repo
for
ethereum
blockchain
and
has
been
in
active
development
for
execution
layer
for
quite
some
time
now,
which
has
also
participated
in
the
merge
testing.
We
will
learn
more
about
ethereum
JS
in
this
episode
with
kashinder
Singh
about
the
cast.
A
B
I
am
gajendra
and
I'm
happy
to
be
here
to
represent
ethereum
JS,
which
is
basically
a
much
ready,
JS
execution,
and
we
we
are
quite
popular
on
GitHub
we
have
1.9
K
GitHub
Stars.
The
team
is
led
by
hogar
joham
Andrew
Gabriel,
myself,
Scotty
Army.
We
are
a
couple.
We
are
a
few
of
the
team
members
and
then
there
there
are
a
lot
of
many
come
a
lot
of
contributors
who
have
really
contributed
into
ethereum.js.
It's.
A
B
Yep,
so
loads
are
also
belongs
to
the
JavaScript
plan
and
ethereum.js
and
lots
are
sort
of
you
know
the
same.
So
the
going
full
stack
on
the
JS
tribes,
JavaScript,
typescript
ecosystem,
so
yeah,
coming
to
ethereum
JS
now
but
really
ethereum.js
provides,
is
the
building
blocks
for
the
JS
ethereum
and
web
3
community.
So
what
what
we
have
this?
We
have
the
code
base,
which
is
really
modular.
B
Payloads,
which
is
really
the
blocks
that
are
part
of
our
traditional
chain,
they
will
be
subsumed
into
the
beacon
chain
and
that
responsibility
of
minting
the
blocks
of
adding
the
blocks
into
onto
the
chain
we'll
go
to
the
beacon
chain,
but
the
responsibility
of
executing
those
blocks
and
modifying
ethereum
evm
straight
Still
Remains
with
the
execution
clients
and
they
CL
clients
and
execution
clients
have
to
work
and
turn
them
to
achieve
this.
So.
B
To
that
end,
we
have
a
major,
very
fully
functional
client,
which
is
a
bit
experimental
in
nature,
and
I
will
tell
I
will
go
why
it's
experimental
a
bit
later
into
the
presentation,
but
we
we
basically
have
great
success
on
kill,
testnet,
which
is
sort
of
not
replicated,
so
you
can
run
a
Sony
polia
with
any
of
the
CL
combinations
and
hopefully
basically
you
know
we
will
sink
to
the
Head
for
go
early
as
well.
You
can
try
us,
but
yeah.
B
The
fun
thing
about
girly
running
us
on
goalie
will
be
that
you
know
you
will
have
to
put
a
lot
of
resources
as
well
as
patients
for
us
to
catch
To,
The,
Head
and
the
reason
for
that
is
again
we'll
go
into
a
later
part
in
the
presentation
mainnet.
We
are
also
merge
ready
for
mainnet,
though
we'll
have
similar
challenges
as
mainnet
is
also
quite
big,
and
but
we
we
can
be
a
merge
capable
for
minute
as
well.
B
So
we
we
demonstrated
that
ethereum
JS
client
is
a
full
stack,
merge
capable
client,
so
since
our
main
audience
is
developers,
so
what
does
it
mean
for
them?
Now?
The
hard
Fork
support
in
all
our
libraries
we
have
the
post
much
hard
folks
about
which
really
means
is
that
you
know
they
can
build
and
test
post
much
transactions
and
if
they
want
to
even
go
further,
they
can
accurately
estimate
Advance,
accurately
estimate
the
gas
cost
using
some
of
our
Advanced
features
and
for
for
the
developer
suits
and
test
Suites.
B
They
can
provide
safe
and
finalized
pointers,
which
is
the
main
value
proposition
that
proof
of
stake
brings
to
the
ethereum
ecosystem.
Is
that
it
that
you
know
with
the
latest
pointer
you
can
you
have
the
finalized,
as
well
as
save
pointers
that
you
can
use
to
access
the
state
earlier?
You
use
to
have
let
us
and
then
wait
for
confirmations
for
you
to
basically
say
that.
Okay,
you
know
the
block
is
freeze
and
now
I
can
release
the
funds.
B
But
now
we
have
these
goodies
coming
from
the
CL
land
and
that
are
also
available
in
ethereum,
JS,
suite
and
readily
can
be
used
by
by
the
test
and
developer
Suites
using
our
libraries,
and
we
also.
Basically,
you
want
to
get
want
to
pave
the
way
for
in
app
and
in
browser
like
clients,
and
the
reason
for
that
is
that
now
the
CL
clients
have
can
also
bring
to
bring
onto
the
table
like
clients,
but
they
don't
really
marry
it
with
the
execution
and
that's
where
ethereum
JS
libraries
come
into
picture.
B
You
can
marry
ethereum
straight
with
those
like
client,
headers
and
basically
can
give
you
the
picture
of
this
of
of
the
contract
or
the
address
or
what,
whatever
section
of
the
state
that
you
want
to
be
concerned
with,
and
that
is
really
the
value
proposition
of
light
clients
and
all
that
is
possible
through
a
much
capable
evm.
So
we
we
have
our
evm
modularized
into
evm
and
VM.
B
Basically,
evm
is
the
main
thing
that
executes
the
code
and
VM
is
the
module
that
really
brings
together
the
blocks
and
transactions
and
the
states
to
marry
into
that
evm.
That
can
run
the
code
so
with
the
merge
capable
evm.
Now
you
can
consume
and
run
post,
merge
blocks
and
supre
compiles
are
available
to
the
developers
and
when,
in
the
future,
when
the
new
heart
post
much
hard
folks
will
come
in.
B
Obviously,
those
will
also
get
available
because
we
are
through
the
barrier
of
the
merge
and
after
that,
providing
new
hard
folks
and
new
pre-compiles
will
just
be
a
routine
task
for
us
and
doing
all
this
merge
efforts
makes
our
evm
and
VM
really
battle
tested,
because
what
really
so
would
a
developer?
Who
is
using
IDE
or
a
test
Suite
based
upon
ethereum
JS
libraries?
They
would
want
that,
okay,
whatever
they
are
developing,
it's
accurate
and
it
will
work
on
the
mainnet
in
the
exact
way
that
that
they
have
developed.
B
So
for
that,
it's
important.
It's
very
imperative
that
we
ethereum
JS,
is
able
to
sync
and
run
test
Nets,
and
and
for
that
reason
we
also
want
to
think
and
run
mainnet.
But
for
that
there
are
a
couple
of
challenges
that
we'll
have
to
solve
first,
and
the
good
thing
about
our
VM
is
if
Yem
and
evm
is
that
you
can
run
in
browser
in
app.
This
is
sort
of
work
in
progress,
but
we
have
made
good
progress
that
you
can
basically
get
finalized
and
latest
pointers
to
the
blockchain.
B
B
B
We
had
to
introduce
new
sync
mechanisms
as
with
everybody
else,
and
so
once
we
are
off
the
proof
of
work.
The
only
way
execution
client
can
get
new
data
is
through
the
engine
API.
So
basically
the
CL
clients
will
Source
or
create
the
blocks
will
build
the
blocks
and
Source
the
blocks,
and
then
those
blocks
are
provided
to
ethereum.js
using
the
engine
API.
But
there
is
one
constraint
over
there
that
CL
clients
and
the
El
clients
have
to
be
in
lockstep.
B
For
example,
you
are
at
head
X
in
the
CL
client,
so
you
have
to
be
on
the
corresponding
head
x,
dash
in
the
El
client
for
for
the
new
payload
to
for
the
new
block
to
come
and
be
executed.
But
what?
But,
if
you
are
not
at
X,
you
know
you
are
at
x,
minus
five.
So
to
solve
that
problem
we
can
swing.
Is
what
really
solves
that
problem
and
what
it
really
means
is
that
CL
clients
will
tell
you
where
the
head
is,
and
then
you
will
go.
Do
a
reverse
backfill.
B
You
will
to
to
the
point
to
the
point
where
or
to
the
last
state
that
you
had,
and
if
you
don't
have
anything,
then
all
the
way
to
till
Genesis
or
all
the
way
till
the
state
is
that
you
have
synced
using
snap
sync.
So
you
you
will
backfill
to
that
state.
You
will
backfill
all
your
headers
and
blocks
to
that
state
and
then
you
will
execute
forward
and
bring
your
client
straight
to
the
current
state,
and
there
is
a
little
bit
of
complication
here
that
the
cl
had
is
also
moving.
B
So
you
have
to
take
care
of
all
these
facts,
but
once
you
take
care
of
all
this,
it's
basically
relatively
simple
that
okay
CL
tells
you
where
the
head
is
you
backfill,
and
then
you
execute
all
these
blocks
and
bring
your
state
up
to
the
mark.
Where
CL
says
the
head
should
be,
and
then
you
can
put,
then
you
can
move
in
lock
step
with
the
CL.
From
that
point
onwards,.
B
B
For
for
consensus,
client,
the
state
is
of
the
order
of
100
to
150
MBS
right
now
for
the
main
net
Beacon
chain,
but
for
execution
layer
of
the
state
runs
into
hundreds
of
GBS
right.
So
it
it
is.
Itself
is
quite
big,
and
if
you
look
at
the
history,
it's
that
that
is
that
is
huge,
and
even
if
you
use
them
mainstream
clients
to
to
fill
to
run
all
the
blocks
without
using
snapsing.
It
will
take
weeks
for
you
to
sync.
B
If
you
have
a
very
good
Hardware,
so
snap
sync
is
basically
it
offers
you
to
download
and
download
a
snapshot
of
the
straight.
The
ethereum
virtual
machine
is
in
and
basically
build
your
own
State
locally,
using
account
range
store
and
range
byte
codes,
so
these
are
the
matches
that
are
available
and
then
there
is
further
complication
that
the
state,
the
snapshot
that
you
are
building
the
state
from
it's
not
really
static.
It's
also
moving
because
the
clients
are
getting
new
blocks
and
they
also
have
to
recycle
their
snapshots.
B
So
then
there
is
a
process
of
State
heal
that
you
will
have
to
sort
of.
You
know
rebuild
some
of
your
state
nodes.
State
MPT
notes,
try
nodes
so
that
you
know
your
state
is
up
to
the
mark,
so
so
there.
So
this
is
the
work
in
progress.
This
is
what
we
are
focusing
upon,
and
this
is
one
of
the
biggest
thing
that
will
enable
us
to
sync
mainnet.
B
Apart
from
the
fact
that
we
are
also
trying
to
be
performant
on
our
evm,
so
the
client,
the
window
for
ACL
client
for
in
the
is
12
seconds
for
a
slot
right.
So
CL
clients
expect
an
El
client
to
execute
a
block
in
about
two
to
three
seconds,
and
that
is
a
sort
of
a
challenge
for
us
right
now.
So
we
we.
So
we
have
to
have
the
two
prong
effort
going
in
this
Direction.
B
One
two
basically
enable
us
to
sync
sync,
the
head
and
then
to
make
our
evm
performance,
and
for
that
we
have
done
tons
of
refactoring
recently,
and
some
more
factoring
is
in
the
pipes
to
make
our
evm
VM
really
performant.
We
are
thinking
of
basically
running
parts
of
our
evm
throughout
through
native
code
through
wasn't
code
so
that
we
can
move
out
of
the
limitations
of
the
JavaScript
virtual
machine
and
be
really
performant
over
there.
B
So
what
what
we
are
trying
to
build
using
ethereum
ethereum
JS
is
a
decentralized
backbone
for
for
the
ecosystem
and
to
make
sure
that
you
know
we
we
can
enable
like
clients.
We
can
enable
things
like
portal
Network.
Apart
from
enabling
our
developers
run,
merge
right,
then
our
developers
develop
and
execute
Mercury
transactions
as
well
as
merge
ready
code.
B
So
this
is
what
we
are
trying
to
make
sure
that
you
know
we
provide
them
with
something
that
really
works
and
something
that
they
can
really
rely
on,
and
thank
you
for
listening
to
us
and
you
can
clone
our
repo
from
the
GitHub
and
you
can
do
God
contributions.
The
team
is
really
helpful
and
welcoming
so
you,
you
are
most
welcome
to
figure
things
out.
B
A
A
We
know
it
even
participated
in
the
merge
cabinet
testing
and
merge.
Definite
testing
is
something
where
some
of
the
mainstream
clients
even
missed,
participating
for
a
few
initial
days.
My
question
to
you
will
be:
why
do
you
call
it
an
experimental
client?
What
is
needed
for
ethereum
JS
to
be
a
mainstream
client
for
node
running
purposes?.
B
Right
so
the
reason
we
are
terming
it
as
experimental
is
that
I
mean
we
would
basically
like
to
do
more
test
string
around
it,
build
more
test
cases
around
it
around
our
client,
how
it
behaves
in
various
conditions.
When
you
know
you
don't
really
expect
that
things
are
working
in
your
way,
so
basically
the
failure
cases,
but
most
most
of
the
times
our
client.
Our
client
has
shown
that
it
it
works,
and
for
us
to
be
really,
you
know
to
come
out
and
say
that
okay,
you
know
use
us.
B
We
need
our
evm
to
be
a
little
bit
more
performant,
because
we
have
two
to
three
time,
two
to
three
seconds
window,
to
run
a
full
mainnet
block,
and
second
thing
is
that
we
we
have
to
basically
make
sure
that
we
are
able
to
snap
sync
and
basically
not
require
people
to
run
all
the
blocks
since
Genesis
all
the
way
till
ahead,
so
that
these
are
the
two
major
challenges
that
we
have
and
we
are
trying
to
solve.
So
once
I
think
we
we
overcome
them,
we
make
good
progress
on
them.
B
A
A
My
next
question
is
about
the
features
one
of
the
key
features
that
was
mentioned
in
load
star,
the
client
and
in
this
ethereum.js
as
well.
That
is
the
availability
of
the
browser
environment.
Would
you
like
to
talk
about
the
advantages
of
browser
environment
and
maybe
invite
possible
users
for
ethelium.js.
B
So,
basically,
typically,
what
what
would
happen
right
now
is
that
you
have
some
client
code
that
will
call
a
Json
RPC
API
of
some
Gateway
provider
or
if
you
are,
for
example,
running
your
own
ethereum
node,
basically
of
your
home
server
or
write,
so
it
has
to
have
good
capability
in
terms
of
the
hard
drive,
as
well
as
the
Computing
resources
right.
So
what
really
is
important
is
that
you
know
in
the
in
this
scenario.
What
really
happens
is
that
people
then
trust
a
particular
provider,
and
then
it
becomes.
B
The
network
basically
is
very
easy
to
censor
and
how
how
to
make
sure
that
you
know
so.
Most
of
the
people
are
concerned
with
a
particular
slice
of
the
state,
for
example,
they
are
predict
they
are
concerned
about
the
addresses,
or
they
are
concerned
about
running
a
particular
contract
right.
So
they
are
not
really
concerned
about
the
end
ethereum
state
that
is
out
there.
So
how?
B
How
can
you
enable
them
to
basically
take
a
slice
of
the
state
and
run
it
in
your
own
client
or
in
your
own
browser,
and
be
assured
that
the
data
that
you
are
getting
is
all
up
to
the
mark
right?
So
all
that
is
possible
right
now,
through
various
apis
as
well,
but
I
mean
running
something
for
a
slice
that
is
some.
That
is
the
thing
that
we
are
going
for
to
run
your
contract
or
to
read
the
contract
in
on
a
particular
State
slice.
B
So
that
is
something
that,
in
browser
or
like
clients
will
enable,
for
example,
you
know
you
have
your
own
ethereum
address
and
all
you
are
worried
about
is
the
tokens
that
you
have
on
your
on
your
address
right
or
you
want
to
extend
or
exchange
the
tokens
now.
For
that
you.
What
we
want
is
that
you,
you
should
really
Source
the
state
from
a
provider
like
portal
Network,
and
you
can
Source
the
slide
state
for
yourself
and
then,
basically,
you
can
run
the
contract
code
itself
in
the
browser
and
then
submit
the
transactions.
B
B
We
demonstrated
using
ethereum
JS
libraries,
how
you
can
basically
fetch
a
contract
balances,
not
only
ethereum
balances,
so,
but
so
that
is
for
an
erc20
contract,
where
you
know
the
mapping
of
how
the
of
of
the
storage
slots
with
your
addresses,
but
for
any
generic
contract
that
you
can
run
on
evm,
because
evm
is
a
turing,
complete
machine
right,
so
so
any
contract
that
you
can
run
on
on
evm.
We
want
you
to
provide
you
the
ability
to
do
that
in
in
your
client
or
in
your
browser.
A
That
is
awesome,
I
really
hope
the
game
and
other
app
developers
find
it
very
useful,
all
right.
Moving
ahead
to
the
topic
of
merge,
I'm
aware
the
participation
of
ethereum
jsn,
the
tablet,
but
I
did
not
recall
the
mention
of
client
release
in
EF
blog
post,
though
I
understand
there
was
a
decision
to
skip
certain
upgrades,
but
I
am
assuming.
We
are
moving
ahead
with
merge
and
that's
why
we
have
a
merge,
ready
release.
A
B
B
But,
apart
from
that,
our
Twitter
releases
of
ethereum.js
do
mention
that
we
are,
for
example,
sipoli
already
and
now,
as
we
added
go
early,
we
are
globally
ready,
but
now
to
sync
goalie
and
run
it
in
postmaster
State
one
would
basically
really
needs
to
let
our
client
run
for
weeks.
For
example,
right
so
I
mean
we.
B
We
want
to
overcome
these
challenges
before
we
want
to
signal
to
the
wider
community
that
okay,
you
know
you
can
take
us
seriously,
but
in
terms
of
the
ecosystem
in
terms
of
our
libraries,
we
are
definitely
there
and
we
definitely
can
take
the
claim
to
our
users
of
our
libraries
that
you
know
you
can
use
them
without
worrying
because
they
do
their
job
well,
right.
We,
we
are
much
ready
in
that
sense,
but
as
a
client,
there
are
few
still
more
challenges
to
conquer.
A
B
Correct
so
our
audience
has
been
developers
and
there
is
still
going
to
be
our
Focus.
So
our
entire
merge
effort
is
to
make
sure
that
our
entire
infrastructure
is
totally
up
to
date
and
any
any
developer
can
basically
use
that
and
develop
something
that
really
that
that
can
reliably
work
on
midnet
as
well.
A
Sweet,
so
we
did
talk
about
couple
of
challenges.
I
would
be
curious
to
learn
about
challenges
during
the
merge
devnet
phase.
If
there
was
any
I
heard
that
ethereum
JS
was
doing
good
and
was
being
compatible
with
the
Lord
star.
It
was
a
very
good
client
combination
for
like
testing
the
merge
yeah.
If
you
would
like
to
share
something
on
that,
yep.
B
So
so
we
we
did
have
our
share
of
challenges.
You
know
we
didn't
have
Beacon
Singh
for
a
while,
and
so
basically
you
know
if
you
would
run
if
you
would
want
to
run
ethereum
JS
you
would
make.
You
would
have
to
sort
of
make
sure
that
okay,
ethereum
JS
is
synced
up
to
the
main,
to
the
merge
point
and
then
CL
client
is
synced
up
to
the
merge
point,
and
then
you
make
sure
that
they
are
they
move
from
there
in
lock,
step
right.
B
So
so
developing
Beacon,
sync
or
optimistic
sync
was
one
of
the
big
challenges
that
we
overcame
and
they
have.
They
have
been
other
challenges.
For
example,
you
know
that
is
sort
of
we
we
encountered.
You
know
we
ran
when
we
tried
to
Ram
all
the
blocks
and
we
try
to
run
more
merge
blocks
and
post
much
blocks.
We
came
across
few
of
the
bugs
that
were
there
in
our
VM
or
evm
code,
or
so
that's.
That
is
something
that
the
entire
merge
have
effort.
A
That's
awesome,
so
let's
talk
a
little
bit
about
the
future
of
ethereum
JS.
Maybe
after
the
merge
you
did
mention
about
their
plans
for
Network
upgrade
post
merge.
We
recently
learned
about
the
sipolia
test
net
undergoing
the
post.
Merge
upgrade
to
introduce
2124,
EIP
I
believe
for
a
specifying
number
of
block
number
that
nodes
can
use
to
identify
peers
who
have
gone
through
much
and
not
is
ethereum
JS
participating
in
that.
B
A
B
Yeah
yeah,
so
with
regard
to
our
audience,
you
know
we
definitely
make
sure
that
we
are
supporting
all
the
hard
folks.
We
are
supporting
all
the
eips
that
are
there
because
I
mean
for
for
the
developers
and
IDs
that
are
using
us.
We
are
the
go
to
Library
provider
that
is
out
there,
and
so
our
transaction
library
is
really
popular
and
some
of
the
big
players,
some
of
the
IDS
and
test
Suites,
are
using
our
evm
and
VM.
So
definitely
all
the
all.
A
Nice
all
right,
my
next
question
is
related
to
licensing
I
totally
understand
if
you
would
like
to
skip
this
question
because
it's
not
directly
related
to
client
development,
yet
people
are
sometimes
curious
to
know
why
it
is
the
way
it
is.
Why
is
MPL
2.0
license
instead
of
gnu
GPL,
which
is
like
a
preferred
license
for
all
open
source
client.
B
Yeah
I
I'm,
so
basically
I
think.
My
theory
is
that
we
want
people
to
basically
build
their
proprietic
Road
using
our
libraries.
If
you
knew,
if
you
use
new
licenses,
basically
you
want,
you
will
have
to
open
source
your
entire
code
base,
but
with
with
our
current
licensing
MPL
licenses,
you
can
build
your
own
propriety
code
because
we
want
the
ecosystem.
We
want
all
these
wallet
providers
nft
projects,
ID
projects
right,
press
Suites.
B
We
want
all
these
guys
to
have
to
build
their
own
propriety
code
using
our
infrastructure
without
worrying
about
having
to
open
source
their
code.
So
so
the
important
part
of
running
and
executing
ethereum
that
that
is
that
is
open
source
and
we
just
want
to
enable
how
they
want
to
integrate
with
the
ethereum
ecosystem,
using
our
libraries
and
our
current
licensing
is
what
allows
them
to
do
that.
A
B
So
if
someone
is
interested,
they
can
hop
on
to
our
GitHub
or
they
can
come
to
our
Discord
right.
Our
entire
code
base
is
open
source
and
you
can
come
over
there.
You
can
look
at
the
code
base.
You
can
look
at
the
issues
that
are
there
and
if
you
want
to
contribute,
you
can
contribute.
We
already
have
a
very
good
number
of
contributors
which
have
contributed
to
the
code
base
and
you
can
also
come
to
ethereum
JS
Discover
right
ethereum.js
has
its
own
Discord
and
you
can
come
over
there.
B
A
Absolutely
open
source
project
always
invite
Community
contributions,
so
whoever
and
whatever
way
they
could
contribute.
They
are
always
welcome.
Well,
it's
time
to
wrap
up
anything
else
that
you
would
like
to
share
with
the
community
related
to
the
client
development,
the
merge
upgrade
or
anything
in
general
yep.
B
A
On
this
note,
thanks
to
our
Channel
subscriber
for
watching
and
listening
to
this
special
episode
on
know,
your
crime
series
check
out
descriptions
for
related
links
hit
like
and
share
to
increase
the
reach.
Should
you
have
any
question
on
this
or
any
other
EIP?
Let
us
know
at
eatcath
her
business
card
we'll
be
back
soon
with
another
interesting
talk
till
then
keep
watching
or
keep
listening.
Keep
sharing
your
love
with
ethereum
caterers.