►
Description
Weekly Meeting of the Grothendieck Team.
B
B
A
A
C
Yes,
for
today,
I'd,
like
I,
wanted
to
show
you
a
simple
demonstration
of
sending
a
transaction
to
the
network
I'm,
showing
that
a
client
is
able
to
process
it
and
also
give
you
a
little
summary
of
of
the
process.
That's
way
that
we
did
running
all
the
transactions
from
the
Genesis
and
how
how
the
debugging
look.
So
let
me
stop
a
shame.
I
stream.
C
C
C
B
C
C
This
is
the
same
private,
key,
okay
and
I'm,
going
to
send
it
to
my
other
account
that
I'm
not
going
to
share
the
private
key
off
and
I'm
going
to
transfer
total
available
balance.
That
means
all
bars
reduced
by
the
necessary
fee
and
that's
the
that's
the
generated
transaction
and
I'm
just
going
to
send
it.
Yes,
I'm
sure-
and
here
I
got
a
confirmation
that
I
can't
that
the
transaction
was
submitted.
This
is
this
is
the
hash
now
I
should
be
able
to
see
it
here.
C
Okay,
there,
this
you
can
see
that
every
seat
has
been
generated
through
this
transaction.
It
has
used.
21,000
guess,
which
is
just
under
two
Gasper,
is
for
a
simple
value
transfer
and
see.
If
we
look
for
the
block
number,
it
has
been
part
of
this
block
three
six.
Seven!
Let
me
let
me
just
quickly
confirm
that
yeah,
the
screw
White's
a
lot
of
those
here.
C
C
A
Okay,
thanks
Roddick,
and
so
just
for
I
mean
for
everybody
else
and,
to
recap:
we've:
that's.
The
scallop
client
is
running
as
an
ordinary
node
connected
to
the
etherium
classic
network,
we're
creating
transactions,
broadcast
them
to
the
network,
and
we
can
see
they're
being
executed
correctly
against
our
EVM.
C
Yeah,
so,
unless
there
any
questions
regarding,
that's
I'd
like
to
jump
onto
the
summary
of
the
space,
which
is
actually
something
we
kept
as
a
as
a
document
as
we
went
along
executing
all
the
transactions
from
from
the
Genesis,
we
made
a
little
log
of
all
the
bugs
that
we
noticed
of
the
blocks
that
failed
execution
on
a
client
and
and
well
as
it
has
been
a
really
fun
process.
I
have
to
say
well
discovering
those
bugs.
Sometimes
they
were
really
silly.
C
C
C
Well,
the
VM
operates
on
256
bit
numbers,
but
for
certain
operations
it
really
doesn't
make
sense
to
deal
with
such
big
numbers
like
accessing
parts
of
byte
arrays
like
like
code
or
you
put
data
to
the
transaction.
These
are
only
ever
relatively
small
areas
of
small
byte
arrays.
So
the
yellow
paper
notices
that
this
convention
of
to
ins
have
to
be
dealt
somehow,
but
it
doesn't
didn't,
wasn't
precise
singling
in
how
to
do
that,
so
so
yeah
we
had.
C
C
But
then
again,
one
would
have
to
define
exactly
what
correctness
is
so
yeah,
but
that
is
definitely
a
subject
for
another
meeting.
However
I
just
wanted
to
like,
for
example,
points
out.
This
is
a
this.
Is
a
task
I
made
many
weeks
ago
about
the
certain
ambiguity
in
the
definition
of
the
color
code
instruction,
and
so
this.
C
C
A
A
Egg
is
it
I
think
it's
that
you're
using
children,
but
there
is
efforts
underway
to
do
some
formal
specifications
of
of
the
EVM
I.
Don't
think,
there's
anybody
I
mean
I,
don't
think
it's
happening
for
any
other
client
I
mean
we
have
seen
evidence
of
where
the
clients
have
diverged
in
the
past
because
of
the
misinterpretation
of
some
of
the
rules
and
then
very
quickly
came
back
together.
A
So
we'll
have
a
it's
not
so
much
an
early
warning
system,
but
we
certainly
have
a
warning
system.
Should
things
go
wrong,
we'll
know
straight
away,
so
that's
TX
execution.
The
next
phase
that
we're
going
that
we're
looking
at
is
web.
The
web
query
in
command
API.
So
this
is
supporting
all
the
Jason
interfaces.
I'm
trying
to
make
the
thing
make
the
client
that
we
have
useful
to
the
outside
world.
So
Lucas
you've
had
a
look
at
the
Jason
API
is
have
you?
Can
you
tell
us
how
you're
getting
all
of
those.
A
D
So
I'm
working
on
integration
with
ETH
Minor
and
it's
looking
good
because
we
are
able
to
provide
some
static
data
to
the
minor
taken
from
the
actual
network
and
then
receive
proof
of
work
generated
by
the
minor.
So
what
is
left
on
our
side
is
to
implement
the
construction
of
new
block
for
mining
and
then
the
inclusion
of
that
minor
proof
of
work
and
when
it
is
done,
then
we
actually
have
a
high
performance
miner
that
we
can
use
with
our
client
to
be
just
another
node
in
the
network.
A
Okay,
great
and
anyone
of
any
questions
for
Adam
or
Waukesha
Matt,
okay,
okay,
so
I.
The
only
other
thing
to
mention
is
the
only
little
piece
of
work.
It's
gonna
be
it's
gonna
be
started
pretty
soon.
It's
just
around
some
of
the
modulation
of
code
base,
so
first
one
we're
going
to
tackle
will
be
the
network
layer
which
will
just
involve,
and
just
just
basically
you
try
to
control
the
coupling
of
that
with
the
rest,
the
system
and
provide
a
module.
That's
that
that
can
be
configured
with
maybe
a
handshake
validator.
A
So
that's
so
that
we
can.
We
can
reuse
that
and
then
we'll
move
up
to
the
stack
and
try
and
do
the
same
formula,
consensus
and
the
ledgers
so
that
we
have
a
really
modular
code
base
that
we
can
mix
mix
in
my
according
to
according
to
what
we
need.
So
hopefully
that
will
them
still
at
eight
experiments
going
forward
with,
with
with
with
various
bits
of
functionality
that
we
want
to
try
out.
So
that's
going
to
be
starting
fairly
soon
as
well.
A
Okay
and
for
for
those
of
you
who
are
in
still
in
Poland
just
to
remind
you
that
we're
all
on
argentinian
time
at
the
moment,
I'm,
actually
speaking
to
you
from
when
Azhar
is
here
with
without
Anna
Nico
and
so
far
I
can
tell
you.
It's
been
in
a
very
pleasant
alone.
I
may
pass
out
at
any
point
which
is
jet
lag,
but
so
far
it's
been
going
really
well
and
okay.
If
there's
no
more
questions,
guys
I
think
that's
that's
about
it.
Thanks
very
much
listening
and
talk
to
you
soon.