►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hello,
everybody
and
welcome
to
the
team
gralton
geek
weekly
status,
update
today
is
Tuesday
the
28th
februari.
It
might
be
Pancake
Tuesday,
who
you
are
it
is
here
so
the
phases
that
we
are
in
currently
to
ongoing
phases
are
the
block
synchronization
and
the
EVM
or
transaction
execution.
We're
rapidly
approaching
the
end
of
block
synchronization
and
we're
in
pretty
good
shape
with
the
with
transaction
execution
as
well.
So
I
think
we'll
go
straight
into
demonstration.
We
have
a
demonstration
today
of
our
EVM,
so
over
the
last
week.
A
The
two
sets
of
tasks.
I
guess
that
we've
been
we've
been
working
on,
one
is
to
say
some
cleanup
where
r
and
block
synchronization
so,
for
example,
using
persistent,
no
keys,
I'm
creating
a
distributable
execution
and
then
on
the
other
side,
we
had
a
significant
bit
of
work
to
do
on
the
EVM
as
regards
integrating
with
the
rest
of
the
system.
A
B
Yes,
I
do
hello.
Can
you
see
my
screen?
Yes,
that's
great
wait.
Ok,
so
today's
demo
is
going
to
be
about,
but
you
can
see
the
plan
on
in
there
in
the
right
window.
It's
going
to
be
about
certain
API
changes,
the
API
that
allows
the
virtual
machine
to
access
the
etherium
world
site,
that
is
the
accounts
and
their
code
and
Sturgis
and,
and
that
was
motivated
by
binder,
need
to
implement
and
the
call
instructions.
The
three
instructions
you
see
here
called
Concord
and
delegate
co.
B
B
Ok,
so
regarding
the
API
changes
previously
our
contracts
I
contacted
low
ever
quite
simple.
The
instruction
set
of
instructions
that
we
had
implemented
allowed
for
mostly
stateless
contract
to
execute,
like
the
Fibonacci
sequence,
calculator
that
was
shown
previously.
Actually
that
one
was
updating
storage
so
so
it
has
blue
state.
But
that
was
a
very
naive
implementation.
It
was
changed
in
this
iteration.
B
B
These
three
instructions
are
used
for
interacting
with
external
accounts
code.
So
let
me
try
to
explain
the
difference
between
them
and
the
call
instruction
is
what
is
known
canonically
as
message
code.
A
message
code
can
be
viewed
as
an
internal
transaction
occurs
during
the
execution
of
code.
It's
not
an
actual
transaction.
It
doesn't
end
up
on
the
blockchain,
but
the
results.
The
effects
of
applying
at
its
are
pretty
much
the
same.
B
Also.
If,
if
the
call,
if
there
is
either
value
passed
with
the
call,
then
we
will
transfer
that
value
from
account
a
to
account
be
and
on
the
other
friends
call
code
and
delegated
code
instructions
and
can
be
viewed
simply
as
fetching
the
code
of
an
external
account
but
executing
it
in
in
the
context
of
our
own
account.
So,
for
example,
when
account
a
does
delegate
called
to
account
be
that
account.
B's
code
is
executed,
and
if
it's
puts
any
any
values
on
the
storage,
then
accounts
a
storage
will
be
updated.
B
Also,
no
value
transfer
will
be
other
performed.
Not
the
balances
of
those
accounts
will
not
be
directly
affected,
and
now
the
difference
between
cole
code
and
delegate
call
a
very
subtle
the
certain
constants
that
are
seen
by
the
executing
code
like
addresses,
of
of
color
and
on
Andreas,
and
the
important
thing
is
that
the
delegate
called
instructions
are
the
platter
as
a
remedy
for
certain
quirks
called
God
has
in
regards
to
those
constants
I'm,
not
gonna,
go
into
the
details
here
is:
it
is
beyond
discovered
demo.
B
But,
interestingly,
what
has
been
the
functionality
that
is
implemented
with
solidity
that
previously
relied
on
coal
code
now
is
now
now
compiles
to
delegate
whole
instruction.
It
was
soon
so
cold
code
can
be
viewed
as
an
absolute
instructions
and
that
reason
I'm
not
I'm,
not
going
to
mention
it
further.
B
B
We
we
are
going
to
call
this
with
the
regular
column.
The
message
calm
and
the
library
in
lib
and
now
the
difference
in
contract
and
in
the
library
is
exactly
that.
That
calls
to
library
will
be
compiled
to
delegate
call
instruction
contrary
to
to
a
regular
contract,
which
will
be
cold
with
a
coma
instruction.
A
B
Is
passed
to
it
now,
and
this
here
is
an
interesting
bit
it's
this
is
simply
casting.
We
have
some
address
here
and
we
cast
it.
We
assume
it
is
the
address
of
the
quarry
account.
It
doesn't
have
to
be
true
actually,
but
we
assume
that,
and
we
we
call
the
function
incremental
now
thought
what,
when
pouring
the
little,
we
simply
we
simply
calling
the
instruction
of
the
lid
now
how
that
works.
B
Library,
library
sensibility
cannot
update,
stop
Virg
and
makes
perfect
sense
because
library
doesn't
know
anything
about
the
account
that's
going
to
execute
its
code,
so
any
changes
to
storage
are
forbidden
by
70.
Laps
I
can
still
circumvent
that,
but
by
using
a
sentry
mode
and
do
some
value
storing
and
the.
A
B
Why
I'm
doing
is
that?
Of
course,
I
want
to
show
you
and
that
this
code,
in
fact,
in
fact,
runs
in
different
contexts
and
another
slight
difference
is
that
this
function
is
payable,
which
means
we
can
transfer
some
value
while
executing
it
library
functions
cannot
be
payable.
It
would
make
sense
since
there's
never
any,
never
end
value
transfer
you
when
using
delegate
call
em.
B
B
A
B
So
let
me
move
here,
so
this
is
the
file
with
far
put
the
solidity
code
and
and
well
I've
done
that
before
so
I'm
just
coming
to
take
a
command
from
from
history
and
and
compile
it,
it's
quite
quick.
Let's
look
at
the
results.
We
have
your
files
here,
the
bin
files
for
all
three
contracts
and
the
abim
files.
B
It's
a
bit
unfortunate,
though,
that
the
naming
convention
is
different
for
those
files
full
of
pinon
for
ABI,
it's
practical
for
for
the
EVM
runner
for
those
to
be
named
the
same
so
I'm
just
gonna
fix
that
quickly.
Ok
and
now
we
can
all
now
we
can
almost
do
a
run
and
the
DVM
runner.
Let
me
just
show
you
one
more
interesting
thing:
that's
here,
we
simply
call
call
live
increments
without
any
address.
B
B
Ok
answer
an
interactive
shell
appears
that
will
allow
me
to
run
some
commands
and
first
gonna
start
with
creating
the
lib,
ok,
I
think
that's
created,
and
we
can
see
it's
a
dress
now
when
creating
contracts,
the
address
is
actually
deterministic.
So
so
because
of
that,
I
can
simply
use
the
command
from
history.
You
may
notice
that
address
is
the
same
as
this
one.
So
let
me
link
that
and
now
let
me
show
you
the
up
in
the
file
again.
B
B
Okay,
and
now
we
can
look
what
accounts
we
have
created.
We
have
all
those
three
icons
and
a
certain
dummy
account
that
was
used
to
create
those
accounts.
You
know,
if
we
look
at
some
info
about
Kali,
for
example,
we
can
see
some
information.
For
example,
its
balance
is
0
0,
whereas
the
colors
balance
is
exactly
thousand
to
the
bike.
We
asked
to
it.
B
A
B
B
What
else
can
we
do?
We
can,
for
example,
if
you
can
view
closed
storage,
it's
initialized
to
0
value,
but
probably
the
most
interesting
thing
is
that
we
can
view
the
colors
code,
and
this
is
simply
the
bytecode
presented
in
a
sort
of
human
readable
way.
Well,
the
interesting
bit
is
that
we
would
expect
to
find
exactly
one
delegate
calling
instruction
here,
yeah
and.
B
Thing
at
the
end,
solidity
compiler
always
put
some
metadata
I
want
the
end
of
the
code.
Ok
I
think
I've
explained
enough
to
actually
start
presenting
some
functions.
Some
interactions
between
contacts,
all
color
will
call.
Oh
I
hope
that
totally
let
me
check
the
Collies
address
again.
Ok,
this
is
the
address
and
color
will
roll
that
address.
B
Ok,
so
there
is
some
kassius.
The
return
value
is
1
by
the
way,
I
may
have
not
said
that
those
functions
within
the
negative
simply
take
a
value
from
sorry
comment,
constant
address
and
put
an
incremented
value,
baka
college,
and
they
also
return
the
same
body.
So
we
would
expect
to
see
that
the
color
storage
is
remain
the
same
two-zero
surveillance,
Kali
storage
should
be
one
yes
and
also
come
as.
B
A
B
When
we
call
you
comment
on
the
Kali,
we
pass
a
constant
value
of
one
way,
so
call
is,
balance
should
be
increased
to
one
and
call
your
colors
balance
should
be
decreased,
exactly
what
you
expect.
So
let
me
maybe
just
random
more
times
just
to
see
what
happens
two
three
four
and,
as
we
will
expect
holster
dissipated
cholesteryl.
It
remains
the
same
and
the
balances
get
subject
right.
B
One
more
interesting
thing
is
that
color,
the
EVN
runner
enables
us
to
specify
gas
to
be
used
for
the
for
the
for
the
function.
Call
if
we
don't
provide
this
by
default.
It
is
maximum,
does
value,
as
we
can
see
previously.
Gas
used
was
thirteen
thousand,
so
if
we
gonna
pass
only
thousand
to
it,
that
should
result
in
an
out
of
gas
exception
exactly,
with
the
other
hand,
pants
enough
gas
that
should
be
just
fine
and
by
the
way,
I'm
going
to
show
you
that
you
can
also
press
some
value
to
it.
B
B
B
B
B
B
Okay,
you
know
just
like
there's
a
question
to
you
not
sure.
If
you
noticed
the
gas
card
collection,
you
can
see
that
for
the
first
call
to
library,
substantially
higher
dose
22,000
for
for
the
first
one
and
seven
thousand
for
all
the
other
ones,
and
it
was
actually
similar
with
calling
the
contract
first,
it
was
28,000,
then
the
follower
subsequent
calls.
It
was
thirteen
thousand,
and
so
my
question
to
you.
B
B
B
A
B
The
last
thing
I
said
yes
cooker,
ganas
uttered,
ok,
I
started
talking
about
conclusions,
so
so
I
said
that,
with
the
with
this
new
API
to
interact
with
the
stage
with
the
external
accounts,
with
their
code
is
Raj,
we
are
very
close
to
completing
the
whole
set
of
instructions
implemented
the
good
to
be
implemented
EVM.
There
are
two
more
bit
more
involved:
instructions
left
which
are
create
and
self-destruct,
but
they
are
already
in
progress,
and
this
new
API
should
really
help
all
with
implementation.
B
Also,
a
bunch
of
a
bunch
of
new
constructions
were
implemented
just
for
the
sake
of,
and
always
called
these
captions.
There
were
mostly
spoken
sentence
once
weirdos,
and
so
you
may
also
wonder
about
this
evm
brother,
because,
obviously,
since
it
didn't
just
appear
overnight,
so
was
it
worth
the
effort
just
for
this
demo?
Well,.
B
B
B
B
And
that
determines
that
the
input
data
of
that
transaction
is
code
to
be
executed
during
account
creation.
Now
this
code
isn't
the
same
code
that
ends
up
in
this
account
the
code
ducks
that
exit
its
first
sort
of
an
initialization,
for
example,
it
can
initialize
even
show
a
certain
values
in
storage,
it
can
create
other
contracts
and
so
on.
So
so
yeah
we
execute
this
code.
Young
utilization
and
the
return
data
of
that
code
actually
becomes
the
code
of
the
contract.
B
B
A
Yes,
thanks.
Ok,
anyone
else
have
have
another
question:
no,
ok,
thanks
Roddick.
That
was
a
very
comprehensive
demonstration
and
very
interesting
and
might
even
become
a
little
bit
of
a
reference
for
this
going
back,
trying
to
explain
some
of
this
to
ourselves.
So
thanks
for
that
and
okay.
So
where
does
that
leave
us
I'm
going
to
share
and
the
screen
and
just
show
where
we
are.
A
A
Here
in
the
next
in
the
next
week,
I
don't
think
you
can
actually
see
the
yeah.
You
can
see
that
you
can
see
the
dates
now.
So
this
this
should
be
some
time
in
of
next
week
and
then
transaction
execution
is
is
jus
as
well.
Now,
as
I've
said
before,
this
is
this
is
including
roughly
about
a
week
or
two
weeks
of
our
reserve.