►
Description
Visit the https://archive.devcon.org/ to gain access to the entire library of Devcon talks with the ease of filtering, playlists, personalized suggestions, decentralized access on Swarm, IPFS and more.
https://archive.devcon.org/archive/watch/6/smart-contract-testing-using-waffle-framework/
Let’s learn how to effectively and easily write TypeScript smart contracts tests suites. We’re going to explore how to create a testing environment, execute transactions, assert balances, state and event emissions. This is going to be the place where developer experience and smart contract security truly meet.
Speaker(s): Bartek Rutkowski
Track: Developer Infrastructure
Keywords: smart contract testing,waffle,security
Follow us: https://twitter.com/efdevcon, https://twitter.com/ethereum
Learn more about devcon: https://www.devcon.org/
Learn more about ethereum: https://ethereum.org/
Devcon is the Ethereum conference for developers, researchers, thinkers, and makers.
Devcon 6 was held in Bogotá, Colombia on Oct 11 - 14, 2022.
Devcon is organized and presented by the Ethereum Foundation, with the support of our sponsors. To find out more, please visit https://ethereum.foundation/
A
A
Workshop,
which
title
is
testing
smart
contract
since
waffle.
My
name
is
I'm
also
one
of
the
contributors
to
the
waffle,
open
source
library
and
I'm
gonna.
Take
you
through
some
of
the
key
features
of
waffle
and
we're
gonna
code,
some
stuff
together.
So
this
is
what
we're
going
to
start
with,
as
the
Internet
situation
is
not
great.
A
Everyone
that
want
to
go
through
the
tasks
with
us
and
I
recommend
cloning,
the
repository
right
now
and
going
so
in
the
readme.
There
is
going
to
be
a
small
section,
that's
going
to
describe
what
you
need
to
do.
Basically,
it's
just
installing
the
dependencies
and
doing
some
few
basic
steps,
so
yeah
I'm
gonna
wait
a
second
for
everyone
to
do
that.
A
I
am
okay,
the
URL
is
going
to
be
visible
also
later
on
so
moving
on.
There
are
two
basic
approaches
to
testing
smart
contracts,
one
of
which
is
testing
smart
contracts
with
other
smart
contracts,
which
has
its
very
nice
properties,
but
also
the
other
approach
is
to
test
smart
contracts
with
JavaScript
or
typescript
code,
and
that's
something
that
we're
gonna
focus
on.
It
has
some
nice
things
about
it.
A
So,
first
of
all,
it's
very
easy
and
intuitive,
so
it
is
very
fast
which
is
important
if
you
want
to
test,
drive
your
code
or
if
you
want
to
make
sure
that
the
tests
are
being
added
to
the
code
as
it
as
it's
being
created
all
the
time.
It's
also
very,
very
flexible,
I
would
say
even
more
flexible
than
testing
solidity
with
other
solubility
code
and
it's
also
kind
of
the
app
native
in
a
sense
that
you
interact
with
your
smart
contracts.
A
The
same
way,
your
application
is
going
to
interact
with
your
smart
contracts
later
on
and
then
moving
on
to
the
waffle
itself,
which
is
a
library
that
utilizes
JavaScript
and
typescript,
and
it
takes
a
very,
very
minimalistic
approach.
So
it's
not
a
very
large
framework
that
forces
you
to
follow
some
certain
rules,
but
it
rather
provides
you
with
some
set
of
utility
functions
that
just
help
you
with
the
largest
pain
points.
Also
it's
blazing
past.
A
As
for
the
JavaScript
or
typescript
library,
because
some
of
the
solidity
testing
can
be
a
little
faster,
but
as
for
a
typescript
framework,
it
is
extremely
fast.
It
also
has
a
very
nice
and
friendly
syntax
and
it
obviously
is
open
source.
So
anyone
having
any
issues
or
any
problems
can
reach
out
and
also
if
anyone
has
any
ideas,
what
we
can
improve,
then
they're
welcome
to
do
so,
and
also
what
is
very
important
that
waffle
works
well
with
hardcat.
A
So
if
you
are
already
using
your
hard
cut
setup,
then
you
can
use
some
of
the
features
of
waffle
as
a
plugin
to
your
hard
hat
setup,
so
you
can
use
either
waffle
Standalone
as
a
complete
testing
solution
or
as
a
plugin
to
hard
cut,
which
is
very
nice
as
well.
We're
gonna
focus
on
using
waffle
Standalone,
but
recommend
checking
the
documentation
for
the
hard
cut
integration
as
well,
and
what
waffle
actually
does.
So
it
goes
you.
It
takes
you
through
all
the
steps
of
smart
contract
development.
So
first
it
helps
you
compile
your
code.
A
Nevertheless,
this
is
Piper
of
solidity
or
solidity
for
most
people,
it's
probably
going
to
be
solidity.
If
you
are
team
vitalik
and
you
prefer
Viper,
then
yeah
you
can
use
Viper
as
well.
Then
you
can
deploy
your
code,
whether
you
want
to
actually
prepare
a
deployment
script
for
the
mainnet
or
some
other,
actually
working,
Network
or
just
deploy
for
the
testing
purposes
and
then
provides
with
all
the
testing
utilities
like
matchers
fixtures
and
smart
contract
mocks
I'm
gonna
dive
deeper
into
that
later
on
and
what
are
the
waffles
components?
A
So
now
what
the
whole
process
looks
like
so
first
we
need
our
solidity
code.
In
this
case,
this
is
some
solidifile
called
exchange,
dot
Sol,
which
is
some
smart
contract,
and
then
we
need
our
configuration
for
Waffle.
This
configuration
that
we
see
here
is
not
actually
a
needed
configuration,
because
these
are
all
the
default
values.
So
you
don't
need
to
create
that
configuration.
You
can
just
like
skip
completely
this
the
step.
That
is
this
step,
but
mentioning
this.
A
So
basically,
you
only
need
to
import
the
the
artifact
from
the
solid
from
the
smartphone
compilation,
and
then
you
need
to
use
the
deploy,
contract
function
and
super
easy
first
argument
is:
who
is
deploying?
Second
argument
is
what
is
being
deployed
and
the
third
one
are
the
arguments
for
the
Constructor
of
the
of
the
function.
Important
thing
to
notice
here
is
that
the
token
object
that
we
are
creating
here,
which
is
the
instantiation
of
the
of
the
of
the
token,
is
tied
to
the
wallet
that
deployed
the
the
contract.
A
So,
whenever
we're
gonna
be
interacting
with
the
token
we're
going
to
be
interacting
from
from
the
wallet,
so
the
wallet
is
like
the
default
sender
of
the
transaction,
and
we
can
change
that
by
just
connecting
the
contract
to
some
other
wallet.
So
by
invoking
contract.connect,
we
can
have
some
other
person,
some
other
wallet,
interacting
with
the
with
the
contract
foreign.
A
Thank
you,
I
think
I'm
gonna
find
some
charger
or
someone
will
help
me
with
that.
Thank
you.
Thank
you
very
much
yeah!
That's
that
the
computer
is
a
low
battery,
Moving
On,
Moving
On,
so
now
interacting
with
the
network.
So
there
are
basically
three
pieces
of
the
interaction
between
the
user
and
the
network
as
a
whole.
A
So
first
we
have
our
d-app
or
a
testing
Suite
or
a
script,
and
that's
the
app
or
whatever
else
uses
a
Json
RPC
interface
to
talk
to
to
interact
with
any
ethereum
node,
which
is
like
one
of
the
nodes
from
the
ethereum
network
and
we're
gonna
break
down
all
these
like
three
pieces
and
how
sort
of
to
wrap
all
that.
So
it's
so
it
makes
sense
from
the
developer
perspective.
A
So,
first
of
all,
we
have
the
node
the
node
itself,
usually
instead
of
talking
to
the
node
or
talking
to
the
network,
we
use
some
API
like
inferior,
Alchemy,
OCT
or
a
default
provider
injected
into
the
browser
by
the
metamask,
but
also
we
can
use
an
emulated
Network
like
ganache
or
or
ability
VM
or
whatever
else.
That
is
just
a
local
institution
that
simulates
the
behavior
of
the
ethereum
network,
or
we
can
run
our
own
ethereum
node
at
B
and
the
hero
of
the
community,
which
I
obviously
recommend
but
I
understand.
A
A
Actually
web3.js
is
older
ether
system,
like
the
preferred
one
by
by
me
myself
and
a
lot
of
my
colleagues,
but
just
to
mentioned
about
that
that
there
are
two
of
them
at
least
yeah,
and
what
ethers
JS
does
is
that
basically
it
wraps
the
whole
management
of
the
keys.
It
helps
you
construct
the
transaction.
So
as
we
see
here,
we
have
the
private
key,
then
from
the
private
key
we
can
create
a
wallet
object
and
then
we
can
add
a
provider
of
the
network,
so
sort
of
connect.
A
The
the
wallet
to
a
link
to
the
particular
node
to
the
particular
API
of
the
of
the
ethereum
network
and
then,
instead
of
just
constructing
some
very
bulky,
Json
and
creating
a
HTTP
request
and
sending
that
to
the
node,
we
can
just
use
like
like
a
simple
call
like
wallet.getbalance
and
we'll
get
our
balance,
and
the
interjs
also
helps
us
override
some
some
additional
properties
of
the
transactions.
So
with
liters.js.
A
We
cannot
only
construct
like
a
basic
transactions
but
also
override
gas
limit
and
non's
value
chain,
ID,
whatever
else,
and
then,
if
we
construct
the
wrong
direction.
This
is
like
the
very
bottom
line
and
we
can
just
add
all
these
overrides
and
perform
like
a
very
custom
transaction,
and
now
we
dive
into
the
actual
features
of
the
of
the
waffle.
Because,
right
now
we
are
sort
of
discovering
the
whole
environment,
that's
around
around
the
the
car
of
the
presentation
and
what
waffle
can
do
on
the
testing
field.
A
So,
first
of
all,
we
can
have
like
a
basic
testing,
so
we
can
just
invoke
some
function
or
we
can
have
some
value
and
we
can
demand
equality
so
first
equality,
but
necessarily
it
doesn't
necessarily
need
to
be
equality.
We
can
just
we
can
also
have.
We
can
also
expect
the
value
to
be
within
a
range
of
some
values
or
to
be
close
to
some
value
which
is
kind
of
dangerous,
because,
obviously
in
the
smart
contracts,
we
want
everything
to
be
super
sharp
and
super
precise.
A
But
in
some
cases
for
example,
if
we
are
doing
some
calculations
based
on
time,
this
is
not
going
to
be
super
precise
and
you
can
use
something
like
this.
Then
we
can
test
all
the
events
and
that
sort
of
corresponds
to
what
what
I
was
talking
about
when
it
comes
to
the
the
up
nativeness
of
JavaScript
testing,
because
events
are
not
crucial
to
the
logic
of
the
smart
contracts.
A
It's
themselves,
but
very
often
they
are
super
important
from
the
the
app
standpoint,
because
we
need
to
be
notified
about
some
certain
action
that
happened
and
we
can
test
that
very
easily
with
waffle
by
just
expecting
some
transaction
to
emit
an
event
with
some
arguments
or
like
emit
multiple
events
or
whatnot.
We
can
also
test
external
calls.
A
Then
we
have
the
reverts,
which
are
also
super
cool
super.
In
my
opinion,
syntax
is
super
cool
and
which
are
obviously
super
important
to
test.
So,
first
we
can
just
test
whether
something
is
reverted,
but
we
can
also
be
very
precise
about
the
reverting
reason
so
the
what
the
what
the
error
is
and
also
we
can,
which
is
one
of
the
newest
features.
We
can
check
the
arguments
of
the
revert.
That's
one
of
the
newest
features
of
the
solidity,
and
we
have
the
reflection
of
that
in
Waffle
as
well.
A
Then
we
have
wrapper
for
the
token
balances,
as
this
is
something
that
we
test
very
often.
So
we
can
check
whether
some
transactions
modifies
balance
of
some
tokens
on
some
wallets,
and
so
we
can
do
this
for
just
one
wallet
that
we
expect
some
transaction
to
modify
the
balance
of
a
token
overall
it
of
particular
value,
or
we
can
perform
that
for
a
pair
of
wallets
or
a
triple
of
wallets
or
whatever
or
whatever
else
you
can
also
have
mock
contracts.
A
So
mob
contracts
are
just
like
a
artificial
things
that
pretend
to
be
smart
contracts,
so
we
can
set
up
a
mock
contract,
deploy,
deploy
a
more
contract
and
then
very
easily
Define.
The
behavior
of
the
mock
so
basically
just
say
that
mock
when
called
when,
like
a
particular
method
on
the
mock
is
called,
is
gonna
behave
in
a
certain
way.
So
this
is
gonna
return,
something
or
it's
gonna
revert.
A
We
can
also
specify
the
arguments
and
we
can
just
basically
model
any
behavior
on
the
on
the
mock
and
then
the
example
of
the
usage
of
the
mocs
would
be
like
this.
So
we
have
the
some
setup
that
would
retire
in
contract
and
a
mock
your
C20
and
then
the
mock.
We
sort
of
like
program
the
mock
to
return
to
return
some
value,
and
then
we
can,
for
example,
check
whether
our
contract
correctly
reacts
to
the
value
returned
by
the
mock.
A
So
in
the
first
case
that
our
contract,
after
examining
the
mock,
will
return
false
or
in
the
second
case
it
will
return
true,
because
the
monk
just
returns
some
value
that
we
expect
or
do
not
expect,
and
the
last
major
feature
are
the
fixtures.
So
this
is
an
extremely
powerful
thing,
because
normally,
when
we
have
like
a
set
of
tests,
basically
like
a
good
rule
of
testing
is
that
all
the
tests
should
be
should
be
shouldn't
depend
on
each
other.
So
each
test
should
have
like
a
separated
setup.
A
We
should
be
able
to
change
the
order
of
the
test
and
everything
should
still
work.
So
basically,
what
fixtures
allow
us
is
is
sort
of
reverting
the
state
of
the
blockchain
to
some
other
state
from
the
past.
So
basically
we
can
perform
some
setup
transactions,
deploy
some
contracts
and
maybe
perform
some
initial
transactions
and
then
save
that
as
a
fixture
and
then
revoke
the
picture
fill
the
fixture
in
each
test.
So
each
test
starts
with
the
same
state
and
we
do
not
need
to
redo
all
the
transactions
and
perform
all
these
transactions.
Again.
A
We
just
sort
of
point
to
that
state
in
the
past
that
we
want
to
sort
of
start
from
this
from
this
particular
moment
and
and
that
that
actually
is
one
of
the
things
that
make
waffle
so
fast,
because
yeah
and
now
this
is
going
to
be
like
a
first
full
setup
of
the
tests.
So
actually
this
is
this
is
going
to
be
shown
also
later
on,
so
they
cheat
sheet
when
you
start
coding,
but
here
we
can
go
through
the
whole,
the
whole
thing.
A
So
first
we
need
to
import
the
stuff
from
chai
that
we
need.
So
we
need
the
expect
utility.
That's
the
most
important
thing.
We
need
to
type
from
eaters
that
defines
contract
and
then
from
ethereum
Waffle.
We
want
a
deploy
contract
function.
We
want
a
mock
provider
function,
which
is
the
the
emulated
Network
that
we're
going
to
be
using
instead
of
the
actual
ethereum
Network
in
the
tests
and
the
solidity,
which
is
just
a
object
that
contains
all
the
all
the
custom
matches,
and
then
we
import
the
contract
itself.
A
A
A
So
this
is
an
interesting
technique
that,
instead
of
just
writing
the
code
and
then
testing
whether
the
code
is
correct,
you
first
write
the
test,
see
that
the
test
is
failing.
So
you
are
make
sure
that
the
contract
that
you
are
testing
does
not
have
this
particular
property
or
this
particular
function.
And
then,
after
you
have
the
failing
test,
you
implement
the
smart
contract
logic
and
then
see
the
Test
passing
and
then
do
a
necessary
factoring.
A
If
you
need-
and
then
repeat
so
go
on
to
the
next
property
of
the
contract
that
you
wanna,
that
you
wanna
add
and
what
we
are
going
to
be
working
on.
So
the
first
task
is
going
to
be
to
create
a
very
simple
splitter,
smart
contract,
so
a
contract
that
is
going
to
have
a
split
function
and
when
and
when
some,
if
is
going
to
be
sent
to
that
function
and
while
copy
while
the
well,
this
function
is
being
called.
A
It's
just
going
to
split
The,
Ether
in
half
and
send
to
different
addresses,
and
it's
gonna
revert
when
the
value
of
the.
If
is
going
to
be
zero
and
if
the
value
of
the,
if
is
not
dividable
by
two,
then
we're
just
going
to
refund
the
reminder
to
the
original
sender.
And
we
want
to
write
the
test
for
that
and
task
number
two,
which
is
that
they're
gonna
be
sort
of
actually
quite
a
few,
quite
a
few
of
them,
and
you
can.
You
can
do
them
in
in
an
add
new
order.
A
So
first
at
the
proper
event,
when
the
split
happens
so
just
signalize
that
the
split
was
called
with
a
with
a
particular
result.
We
also
want
to
signalize
whenever
the
non-zero
remainder
was
returned
because
the
because
we
have
that
without
we
have
that
function
as
well,
and
we
also
want
the
owner
to
be
the
only
person
that
is
allowed
to
use
to
use
the
contract.
A
A
But
there
are
going
to
be
arguments
the
function
and
maybe
we're
gonna
have
like
more
addresses
than
two,
maybe
three
or
for
or
just
a
dynamic
number
of
them.
And
of
course
we
want
to
create
tests
for
that.
So
and
that's
like
a
cheat
sheet
that
I'm
gonna
stop
on
so
first
QR
code
that
you
have
is
a
waffle
documentation
that
should
help
you
with
everything.
A
The
bottom
QR
code
is
the
repository
that
we
are
going
to
be
working
on
on
the
left.
You
see
the
list
of
the
tasks
that
are
to
be
to
be
done
and
on
the
right,
you
have
a
and
you
have
a
sort
of
a
basic
template
that
shows
you
what's
the
general
idea
of
the
of
the
test
and
how
they
more
or
less
should
look
like
yeah.
A
B
A
A
Oh,
that's
that's
a
good
point.
So
actually
I'm
gonna
switch
from
the
presentation,
oh
nice,
so
here's
the
repository.
This
is
what
it
looks
like.
So
the
first
thing
is
the
contracts
folder.
Here
there
is
The
Ether
splitter,
the
empty
one.
So
if
you
go
for
the
solid
team
lamentation
yourself,
then
you
should
start
your
work
here.
If
you
want
to
use
the
already
created
contract,
it's
gonna,
be
here.
The
Ether
split
are
ready
and
with
the
split
function
it
doesn't
have
all
the
features
from
the
task
2.
A
You
can
add
them
later
on
and
then
the
test
section
so
first
there's
some
reference
in
the
in
the
templates
file
and
the
tests
themselves
should
go
into
the
ether
splitter
and
the
tests
where
everything
is
set
up,
and
here
you
can
also
see
that
we
use
ether
splitter.
So
we
import
the
the
empty
third
splitter.
B
A
C
This
is
a
writing
kind
of
given
when
then
pattern
or
kind
of
or
PVD
or
the
behavior
driven
test
or
that
kind
of
things
so
that
kinds
of
the
things
in
the
web
too.
So
when
it
comes
to
Webster,
it
seems
like
the
security
is
also
in
the
important,
so
I
think
that
the
the
mental
model
for
testing
in
Dion
web3
world
is
really
important.
So
I
think
also
I,
really
wonder
you
guys
are
thought
in
Beyond
testing,
especially
in
the
Webster
world,.
A
Yeah,
absolutely
so
I
think
that
one
super
important
technique
and
sort
of
like
mental
model
around,
like
not
only
testing
but
the
developing
smart
contract
as
a
whole,
is
is
that
test
driven
development
because,
like
when
you're,
like
writing
a
so
I'm,
actually
gonna
stand
up.
So
if
you
are
writing
a
solidity
code,
it's
super
important
that
the
contract
actually
does
what
it
needs
to
do
so
that
you
don't
have
some
unnecessary
lines
that
you
don't
have
any
things
that
were
put
somewhere,
and
you
thought
that
they're
gonna
be
useful.
A
A
Your
contract
so
actually
write
a
very
explicit
expectations
about
your
code
and
Define
what
you
wanna,
what
Behavior
you
want
to
achieve
from
the
from
the
contract
and
then
Implement
only
the
code
that
that
sort
of
like
performs
the
logic
that
that
does
it
that
is
required
to
to
fulfill
the
sort
of
to
make
the
test
pass
yeah
and
then
you
need
to
go
like
through
the
whole
stack.
So
so
there
is
sort
of
no
no
differentiation
like
whether
you
should
use
unit
tests
or
integration
tests
or
or
some
other
type
of
tests.
A
A
You
should
play
around
with
the
whole
thing
you
need
to.
You
also
probably
should
develop
like
the
up
or
the
script
that
is
meant
to
interact
with
the
smart
contracts
in
parallel
to
the
smart
contracts
themselves.
So
all
of
like
these
two
like
remain
in
sync
yeah
I,
don't
know
if
there
are
any
other
tips
that
I
can
think
of.
Maybe
someone
can
add
something.
A
A
You
just
need
to
use
a
different
compiler,
which
is
also
like
I,
think
you
need
to
specify
in
the
waffle
conflict
config
that
you
are
compiling
not
solid,
but
you're,
compiling
viper.
Well,
that
should
be
it
I'm,
pretty
sure
this
is
somewhere
in
the
documentation.
I,
don't
use
Viper
personally,
so
I'm
not
very
familiar
with
that
setup,
but
yes,
I.
Preserving
this
part.
D
So,
can
you
also
expand
the
discussion
about
testing
in
solidity
and
testing
outside
solidity,
because
that's
that's
kind
of
a
Hot
Topic
with
other
Frameworks
like
Foundry,
that
they
use
sorry
and
they
have
you
know,
limitations
or
things
that
are
that
need
to
be
work-rounded?
What
is
what
is
your
view
on
this
sure.
A
So
actually,
I
think
that
the
main
advantage
of
of
using
solidity
testing
is
the
fact.
So
there
are
two
things:
okay,
one
is
the
the
pace,
so
the
the
testing
in
solid
is
definitely
faster
and
and
just
having
everything
inside
of
the
of
the
evm
just
makes
the
test
run
faster,
so
which
might
be
important
for
some
people,
and
it
is
sometimes
actually
important
if
you
want
to.
A
You
know
like
run
the
tests
very
frequently,
which
makes
sense-
and
you
should
do
that
so
this
is
this-
is
a
nice
property
but
then
like.
If
you
have
like
some
continuous
integration
system
on
your
repository,
then
it's
probably
not
that
important,
because
even
like
the
JavaScript
tests
are
not
gonna,
be
that
long.
A
So
that's
that's
one
thing
which
is,
which
is
just
the
performance
which
is
which
is
better
on
the
solidity
side,
and
the
other
is
the
fact
that,
when
using
like
typescript
or
JavaScript
test,
there
is
this
Json
RPC
middlemen
and
the
there
is
also
like
casting
of
all
of
the
types.
So,
for
example,
the
when
you
call
a
function
and
then
something
is
being
returned.
This
is
like
a
some
Json
and,
and
the
big
number
that's
being
returned
from
the
from
the
solidity
or
Viper
code
is
just
a
very
large
number.
A
That's
not
able
that
JavaScript
is
not
able
to
process,
so
you
need
to
cast
it.
You
need
to
have
special
types,
and
there
were
times
when
it
was
actually
a
problem
that
there
were
that
we
didn't
have
like
a
good
implementations
of
of
big
numbers,
and
some
people
were
just
casting
to
Strings,
then
comparing
strings,
and
this
wasn't
great
but
now
I
think
that
it's
not
that
much
of
a
problem
anymore.
A
Yeah,
actually,
yes,
I
think
I
haven't
been
reading
this
kind
of
tests
myself,
but
we
definitely
still
do
test
if
our
front
ends
with
a
typical
like
web.
Two
tools
that
even
just
you
know
like
display
the
whole
thing
and
then
like
click
into
like
the
particular
like
virtually
like
click
into
like
the
particular
sort
of
components
and
yes
and
actually
perform
transactions,
though
in
this
case
we
would
need
something
that
would
just
work
very
fast.
E
I
might
try
to
expand
so
we
what
we
do
in
true
file.
We
run
the
whole
local
blockchain
with
financial,
hard
hat.
We
also
run
a
local
the
graph,
and
then
we
run
the
front
end
and
click
through
the
front
and
send
you
the
transaction
through
metamask
on
this
local
network.
So
this
is
what
we
do,
but
it's
separate
from
Waffle
right:
okay,.
F
Hey
guys,
did
you
manage
to
download
an
Instagram,
build
Etc,
yes
hit
it
and
how
is
it
going
yeah?
So
my
proposition
is:
we
are
going
to
plug
in
a
different
computer
and
Live
code
with
you
and
if
you
didn't
manage
to
download
it,
you
can
come
here
and
like
we
can
do
it
together.
So
it's
more
interesting
and
some
people
don't
have
computers,
so
you
can
do
it
with
us
here.
F
F
F
B
E
E
E
F
F
E
F
F
E
F
Maybe
let's
start
with
just
one
address
this
Charlie
okay,
so
we
can
do
like
proper
tdd,
which
is
just
start
with
simple
example
and
then
go
to
more
advanced
ones.
So,
right
now,
what
we
want
to
do
is
the
first
check
that
the
initial
balance
is
equal.
Zero
then
call
this
split,
splitter
and
split,
and
then
let's
expect,
for
example,
this
this
balance
to
be
equal.
One.
F
D
B
D
F
F
E
E
B
E
E
B
E
B
A
A
Okay,
guys
we
need
to
we
need
to
finish
so.
We
didn't
manage
to
do
a
lot
within
a
short
period
of
time
and
not
very
perfect
Internet
situation.
But
if
any
one
of
you
wants
to
continue,
then
we
are
here
like
outside
of
the
outside
of
the
room
and
we
have
our
booth,
so
you
can
drop
by.
We
can
talk
and
we
can
help
you
to
continue
with
everything.
So
yeah
thanks
a
lot
and
see
you
around
the
Defcon.