►
Description
Integrating Besu EVM and Ethereum Transactions into Hedera Hashgraph - Danno Ferrin, Hedera Hashgraph
The explosive growth of DeFi and DAOs have created a very powerful one-two punch for common interfaces in Smart Contracts and User Experience: the Ethereum Virtual Machine (EVM) and the Ethereum JSON-RPC APIs. This has resulted in the ubiquitous availability of software and hardware wallets through which nearly all public chain transactions are conducted in the greater ethereum ecosystem. In this presentation Danno will discuss the process that Hedera Hashgraph went through to increase their compatibility with the greater etheruem ecosystem. Hedera replaced their existing EVM with the Hyperledger Besu EVM, supported the processing of raw Ethereum transaction format, and exposing JSON-RPC communication relays. Danno will also discuss the techniques used to address incompatible features of Hedera with Etheruem in a user friendly way, and the Hedera unique services exposed as system contracts.
Sessions Details & Slides (if available): https://sched.co/14H53
Access All Sessions: https://events.linuxfoundation.org/hyperledger-global-forum/program/schedule/
----
Hyperledger – Open Source Blockchain Technologies
Hyperledger is an open source community focused on developing a suite of stable frameworks, tools and libraries for enterprise-grade blockchain deployments.
It serves as a neutral home for various distributed ledger frameworks including Hyperledger Besu, Fabric, Sawtooth, Indy, as well as tools like Hyperledger Avalon, Cactus and libraries like Hyperledger Aries, Ursa. Learn more about Hyperledger projects: https://www.hyperledger.org/use
Discord: https://discord.gg/rVCn4j7UFd
Case Studies: https://www.hyperledger.org/learn/case-studies
Training & Certification: https://www.hyperledger.org/learn/training
Tutorials: https://www.hyperledger.org/use/tutorials
Webinars: https://www.hyperledger.org/learn/webinars
Events: https://www.hyperledger.org/events
Vendor Directory: https://www.hyperledger.org/use/vendor-directory
Subscribe to the Hyperledger Newsletter: https://www.hyperledger.org/newsletter
Follow-us on Twitter @Hyperledger
Learn about Hyperledger Membership: https://www.hyperledger.org/about/join
#Hyperledger #Blockchain
License
Creative Commons Attribution license (reuse allowed)
A
I'd
like
to
welcome
everyone
who
showed
up
today,
I
guess
the
coffee
chat's
still
going
on
it's
hard
to
get
things
started
once
everyone
starts
chatting
again,
but
this
is
being
broadcast.
It's
going
to
be
recorded,
so
it's
going
to
be
here
when
people
are
ready
for
it
today,
I'm
talking
about
integrating
basude,
the
basic
evm
and
ethereum
transactions
into
the
hedera
public
network,
but
first
my
name
is
Dan
o'farin
I'm,
a
principal
software
engineer
at
swirls
labs
and
that's
a
company
that
works
for
it
for
the
hedera
network.
A
It's
a
couple
more
slides,
I'll
talk
about
it,
I'm
one
of
the
maintainers
for
the
hyperledger
basic
project
and
I've
been
with
hyperledger
Basu.
Since
it
was
onboarded
into
into
the
into
the
hyperledger
ecosystem.
It
started
out
as
a
project,
it
consensus
called
Pantheon,
and
then
we
brought
it
into
hyperledger
and
I've
been
there
ever
since
on
the
hyper
on
the
hyperledger
side,
I'm.
Also,
a
member
of
the
technical
steering
committee
I've
served
two
terms.
A
This
term
I've
also
been
serving
as
the
vice
chair,
underneath
Tracy
Kurt
she's
been
doing
a
great
job,
so
I
just
have
to
fill
in.
For
the
occasional
meeting
it's
it's
she's
doing
a
great
job
in
being
the
lead
of
the
technical
steering
committee,
but
first
we
should
talk
a
little
bit
about
what
is
hedera.
Hedera
is
a
permission
public
Ledger.
It's
a
proof
of
stake:
public
Ledger,
where
the
participants
that
are
producing
the
producing
the
The
Ledger.
A
You
know
how
they
have
their
stake
in
it,
but
it's
not
a
blockchain.
I
almost
want
to
say
you
know
it
is
blockchain,
but
it's
not
a
blockchain,
but
one
of
the
unique
things
is
it
uses
the
the
hashgraph
consensus
algorithm
and
what
makes
it
different
from
most
traditional
blockchains
is
in
this
consensus
algorithm.
There
is
no
block
proposer
all
of
the
different
nodes
that
are
in
consensus.
They
contribute
their
transactions
continually
through
a
complex
acyclic,
directed
graph
process.
A
Where
you
take
your
history
in
someone
else's
history,
and
then
you
can
read
through
all
that
data
and
with
enough
spreading
of
the
of
the
various
nodes,
you
can
come
to
a
very
complete
conclusion
about
when
transactions
came
in,
which
order.
So
they
go
through
this
at
high
speed.
They
perfectly
order
everything.
Then
we
just
evaluate
the
evm
transactions
through
hashgraph
and
there's
no
leader,
there's
no
memory
pool,
there's
no!
Oh,
no
weird
stuff
like
that,
going
on
with
sandwich
Trading
on
top
of
that
are
built
a
number
of
services.
A
On
top
of
this
hashgraph
algorithm,
to
provide
The,
Ledger
type
services
that
people
are
looking
for
in
in
a
distributed
Ledger.
The
first
one
is
a
native
token
service,
and
this
we
can
trade,
fungible
and
non-fungal
tokens
through
the
API
represented
natively
in
the
in
The
Ledger
I
mean
you
don't
have
to
go
through
a
smart
contract
system.
These
are
actual
tokens
built
into
hedera.
A
A
Now
who
runs
hedera
these
these
stakers
I
mentioned
is
26
members.
It's
a
26-member
governing
Council
I
was
wrong
before
and
I
said
it's
23.
it's
up
to
26.
It
could
conceivably
hold
up
to
29.,
but
there's
some
pretty
big
names
in
there.
You
might
recognize
Google
IBM,
some
specialized
names
is
as
well.
We
got
Deutsche
Telecom
and
the
way
that
they
manage
this
network,
the
technical
aspects
of
it.
You
know
they
meet
in
their
meetings.
They
vote
on
fees
and
a
lot
of
other
stuff.
A
But
as
far
as
the
technical
improvements
he's
come
through
hedera
Improvement
proposals,
hips.hedera.com
has
all
those
hit-air
Improvement
proposals,
I've
written
a
number
of
these
to
to
cover
some
of
the
stuff
that
I'm
talking
about
today.
In
this
talk,
as
far
as
the
HTS
integration
and
swirled's
lab,
is
the
company
I
work
for
they
are
contracted
by
hedera.
A
It's
a
separate
company
from
swirls
lab
to
do
the
technical
implementation
of
these
hips
in
the
hedera
network
and
other
technical
aspects
of
creating
the
software
to
run
the
hedera
network
and
the
network
itself
was
run
by
hedera
on
these
26
governing
councils.
So
so
we
write
the
software
and
they
run
it.
A
So
as
far
as
integrating
the
evm
into
into
hedera
there's
three
main
aspects
I'm
going
to
talk
about
today.
The
first
is
the
base
of
evm
itself.
We
took
the
evm
from
Basu,
the
one
that's
mainnet
compatible
and
one
of
the
one
of
the
growing
major
alternative
clients
to
Geth
in
ethereum
mainnet.
We
took
that
evm
and
we
used
the
exact
same
code
in
hedera,
it's
kind
of
a
process
to
get
there.
A
The
next
thing
we
did
is
we
took
the
native
hedera
token
service
and
through
a
series
of
system
contracts,
which
you
might
be
more
familiar
with,
calling
them
pre-compiled
contracts.
We
expose
the
tokens
through
it,
so
you
can
treat
them
just
like
regular
old
ethereum
tokens
and
finally,
there's
another
project.
We
wrote
called
hashio,
which
is
a
Json
RPC
Bridge
hedera
uses
grpc
for
its
Communications.
A
However,
most
of
the
ethereum
world
uses
Json
RPC
to
talk
to
its
nodes,
and
a
lot
of
the
dapps
depend
on
some
semantics
in
that,
and
that
is
an
important
Last
Mile
that
we
needed
to
fill
in
to
make
things
work.
So
you
could
use
things
like
metamask
and
hard
hat
when
building
your
ethereum
applications
on
hedera.
A
So
first,
let's
talk
about
the
basic
evm
now
hedera.
When
it
launched
a
smart
contract
Service
it
has,
it
had
an
evm
compatible
implementation
and
at
the
time
they
used
the
ethereum
J
implementation.
They
were
about.
You
know:
consensus's
Pantheon
hadn't
quite
been
released.
Yet
so
there
wasn't
much
public
code,
so
the
ethereum
J.
It
was
good
enough.
It
was
compatible
up
until
about
the
constant
and
slopable
hard
Fork,
but
there
were
another
other
issues
that
needed
to
be
improved
to
get
it
working.
A
So
the
decision
was
made
to
bring
in
the
base
of
evm
and
that's
when
I
came
on
board
to
hedera
so
to
bring
in
the
base
of
evm.
First,
we
needed
to
do
some
groundwork
inside
Basu
itself
and
I
call
this
separating
the
monolith,
there's
about
four
major
tasks
that
we
needed
to
do
our
three
major
tasks.
A
But
the
reason
that
these
hadn't
been
split
out
is
because
Basu
was
a
Swiss
army
knife
binary
and
did
everything
at
once
and
there's
only
one
real
use
case
for
it,
and
that
was
to
run
either
private
networks
or
public
networks
using
the
different
components
outside
the
context
of
this
army.
Knife
had
not
been
contemplated
before
so
we
had
to
turn
it
into
a
stack
of
Legos
and
when
you're
building
a
modular
system,
you
need
to
have
a
real
use
case
to
ensure
that
the
module
boundaries
make
sense
and
are
usable.
A
A
I
was
part
of
one
of
the
original
maintainers
brought
in
with
the
with
the
project.
So
that's
why
I
know
a
lot
about
why
we
built
these
things.
The
way
they
did
so
we
took
some
of
this
tight
coupling
out.
There's
also
some
dependency
on
other
code,
where,
when
you
have
the
assumption
that
you're
all
together
and
you
have
a
type-
you
can
just
put
it
everywhere
and
put
all
the
things
that
you
need
into
that
type
that
are
needed
in
the
three
different
components.
A
We
went
ahead
and
re-implemented
that
for
the
standard
tracing
that
was
easy
for
the
full
parity
tracing
from
the
parity,
ethereum
style,
that's
going
to
take
a
bit
more
work,
so
that's
still
sitting
in
there
we
didn't
move
everything
over.
Some
of
the
testing
code
still
depends
on
some
of
the
setup
from
the
monolith
to
set
up
things
because
we
got
to
test
things
like
do
this
to
the
tree,
get
calculated
correctly
with
the
ethereum
reference
tests.
Those
were
a
lot
harder
to
split
out,
so
those
went
ahead
and
stayed
in
the
monolith.
A
The
next
thing
we
needed
to
do
is
we
needed
to
address
some
performance
concerns
ethereum
only
operated
at
1.1,
Mega
gas
per
second
yeah,
there's
15
or
30
million
gas
in
each
block,
but
each
block
only
comes
every
13
and
a
half
seconds.
Hedera
wanted
to
do
something
more
on
the
order
of
50
million
per
second,
and
if
you
figure
it
out,
if
that's
well,
that's
about
400
over
400
erc20
transactions
per
second
that
they
wanted
to
do
to
get
it
like
400
CPS,
just
on
a
smart
contracts
alone.
A
A
Happy
is
the
word
I
use
for
the
hedera
API
hapi,
so
it's
quicker
and
cheaper
to
do
it
that
way.
But
if
you
want
to
do
fancy
things
such
as
support
dexes,
you
would
need
to
use
the
evm
to
do
that.
So
there
was
a
lot
of
you
know.
There's
you
know
four
bullet
points
of
things
that
I
had
to
do
mostly
worrying
around
bit
twiddling
and
moving
bits
around
that
we
were
doing
multiple
times
and
calculating
things
into
to
different
levels.
A
So,
as
a
result
of
this,
the
quote
unquote
floor
performance
of
the
worst
performing
operation.
Right
now
is
about
60
milligas
60
Mega
gas
per
second.
So,
if
all
you
do,
is
you
do
shot
three
hashes
all
day
long
you'll
get
about
60
Mega
gas
per
second,
if
you
run
it
in
our
in
our
tests,
nobody
does
that
really
a
lot
of
the
other
operations
perform
much
better.
So
that
gives
us
the
security
guarantees.
A
We
need
to
put
15
million
gas
per
second
as
the
performance
floor
as
the
performance
ceiling
inside
of
the
hedera
nodes.
We've
got
a
lot
of
safety
margin
coming
in
there,
whereas
before
we
didn't
have
that
safety
margin,
we
also
had
to
update
some
support
to
bring
it
up
to
date.
With
current
evm
standards.
There
was
three
more
op
codes
we
needed
to
implement.
We
gave
a
chain
ID
to
hedera.
0X127
is
the
hexadecimal
code
for
lowercase
H,
with
a
bar.
Through
it,
the
currency
is
called
h-bar.
It's
some
joke
about
Planck's
constant
reduced.
A
That
I
don't
understand,
because
I
was
never
a
physics
major,
but
that's
why
they
picked
the
h-bar,
and
so
we
go
Ox
128.
You
know
x129
for
our
test
net
and
preview
net,
and
if
you
build
a
local
version
of
and
test
it
locally,
you'll
have
one
to
a
as
your
as
your
chain
ID.
We
also
had
to
implement
self-balance.
We
needed
to
do
some
fee
schedule,
changes
to
s,
store
that
were
changed
since
Constantinople
and
we
needed
to
support
an
opcode
that
was
designed
for
EIP
1554.
A
So
we
don't
support
as
the
next
bullet
point.
We
don't
support
the
EIP
1559,
but
we
don't
support
the
EIP
1559
fee
Market.
We
have
our
own
fee
system
set
up.
That
is
indexed
to
the
Fiat
value
that
we
move.
The
H
bar
with
so
I
need
to
put
some
support
in
there
to
you
know,
return
zero
for
the
base
fee
and
do
some
other
exposed
exposing
of
the
exchange
rate
to
make
things
work
properly
in
the
fees
now
looking
forward,
we're
going
to
be
supporting
all
changes
that
are
coming
in
and
Shanghai
there's.
A
Actually
one
small
minor
change,
that's
coming
in
in
Paris
that
we'll
support
a
bit
later,
they're
changing
the
difficulty
operation
to
a
randow
operation
and
we're
going
to
support
that
with
something
slightly
different,
but
still
in
the
same
Spirit
of
taking
a
running
hash
from
the
production
of
the
hedera
network,
whereas
the
randow
is
taking
something
from
the
production
of
the
consensus
layer.
So
we
will
replace
be
replacing
that
with
a
with
a
similar
operation
because
a
lot
of
people
when
they
use
that
difficulty
operation.
A
The
next
thing
we
needed
to
do
is
we
need
to
worry
about
accounts,
and
this
is
kind
of
the
big
thing
we're
still
going
through.
Some
of
the
details
in
hedera
hedera's
accounts.
Don't
work
like
ethereum
accounts.
We
start
at
zero
zero,
one
thousand
when
we
start
issuing
our
accounts
on
mainnet.
We've
got
over
a
million
accounts
right
now,
so
you
would
have
zero
zero
one
million
and
some
digits
behind
it,
but
these
are
assigned
increasing
in
order
from
from
linearly,
so
you
create
a
new
account
or
a
new
contract.
A
You
take
the
next
slot.
This
is
completely
opposite
from
the
way
ethereum
does
it
when
you
deploy
a
contract,
it
takes
some
bits
of
information
like
this
is
the
notes
of
the
account.
This
is
the
account
number
put
a
little
magic
salt
in
there
hash
it
together
and
out
comes
this.
This
20
by
you
take
the
20
bytes
of
the
sha3
hash
of
all
that.
A
So
the
initial
approach
that
we
did
for
it
was
just
to
map
your
hedera
account
address
to
what
I
call
the
long,
zero
notation.
We
would
take
that
number.
We
would
smash
it
down
into
the
hex
equivalence.
We
would
need
24
bytes
to
do
all
three
of
the
bytes
in
Java
long.
So
one
of
these
two
0.0s
we're
going
to
have
to
throw
some
bytes
out.
We
think
it's
going
to
be
the
middle
one,
because
that's
the
future
plans
for
it.
It's
going
to
have
a
smaller
range,
but
from
that
you
get
a
long
address.
A
That
looks
almost
like
a
pre-compiled
contract,
but
it's
not
really
a
pre-compiled
contract
it
does
resolve
to.
When
you
run
it
backwards,
that's
going
to
be
987654
in
decimal.
When
you
run
it
now,
we
decided
to
go
on
to
a
different
approach
where
we
would
allow
accounts
to
take
on
aliases
and
there's
a
couple
of
reasons
why
we
would
want
to
do
that.
One
of
them
is
for
accounts
this.
The
reason
why
aliases
were
invented
or
for
exchanges
that
wanted
to
fund
accounts
where
they
don't
know
the
number.
A
So
you
set
an
alias
to
be
the
public
key,
so
we
use
this
public
key
and
we
went
ahead
and
calculated
the
ethereum
address
that
would
go
with
it
for
accounts.
So
if
you
have
an
ecdsa
key
associated
with
your
hedera
account
and
you
set
it
as
the
Alias,
we
can
give
that
big
long
name
that
you
would
see,
typically
in
metamask,
for
your
account
and
still
access
it
through
metamask.
A
Now,
only
one
of
these
addresses
is
used
in
the
evm,
either
the
long,
zero
or
the
evm
address.
So,
if
you
set
an
evm
address,
you
can't
access
your
account.
You
get
the
long,
zero
notation,
it's
kind
of
a
security
flaw
to
allow
an
account
to
be
accessed
by
different
names.
It
presents
a
number
of
challenges
and
problems.
If
you
allow
someone
to
talk
about
things
in
two
different
ways,
so
that's
the
current
state
of
how
we're
managing
accounts.
A
The
next
thing
that
we
needed
to
do
is
we
needed
to
change
the
way
some
of
the
operations
to
work
within
the
constraints
that
hedera
required
of
it
eight
different
accounts.
When
you
access
a
non-existing
account,
will
throw
it
will
raise
an
exception
within
the
evm.
If
you
try
to
get
the
balance
or
the
code
hash
or
call
an
account
or
contract
that
does
not
exist.
That's
above
the
current
number
that
doesn't
have
an
alias
mapping.
You'll
get
an
invalid
solidity.
A
Address
exception
raised
within
the
VM,
just
as
if
you
try
to
to
access
other
things,
we're
looking
at
changing
that,
but
there's
not
a
guarantee
on
that
right
now.
So
we're
looking
at
rolling
that
back.
So
we
treat
it
like
ethereum
does
where
non-existent
accounts
have
a
zero
balance.
They
have
an
empty
string
for
their
code,
an
empty
byte
string
and
if
you
call
one
of
these
objects,
you'll
just
get
your
data
back.
A
A
We
also
need
a
special
Integrations
for
the
create
and
the
create
two
like
I
said,
a
counter
created
sequentially
from
one
zero
dot,
zero,
a
thousand.
So
when
you
create
an
account,
we
need
to
give
that
that
when
you
create
a
contract,
we
need
to
return
the
new
contract
number
we
needed
to
do
something
different
entirely
with
create
two,
because
the
point
of
create
two
is
you
get
a
deterministic
contract
back
based
on
some
input
data?
A
This
is
used
heavily
by
dexas
like
uniswap
and
Sushi,
swap
where
they
would
take
the
two
addresses
of
the
coins
that
you're
swapping
into
their
into
their
assault
and
they'd
smash
it
together.
So
you'd
always
get
the
same
address
so
for
create
two.
We
extended
the
Alias
concept
to
Smart
contracts
when
you
create
two,
a
smart
contract,
we're
going
to
put
an
alias
on
there
of
the
new
address
and
that
will
be
used.
A
And
the
final
piece
of
integration
we
needed
to
work
on
was
fees
and
gas.
Hedera
has
a
very
rich
and
complex
fee
schedule
and
they
make
sure
to
charge
you
exactly
for
what
you're
using
and
nothing
more.
So
if
you're,
using
long-term
storage
stuff,
you
persist
at
disk,
short-term
storage
stuff.
You
would
keep
in
memory
for
the
next
three
minutes
for
other
nodes
to
access.
A
If
you're
putting
stuff
in
the
block
record,
we
charge
we
charge
for
compute,
we
charge
for
a
number
of
other
things
and
we
index
index
that
very
lowly
I
mean
we
also
charge
for
the
number
of
of
signatures
we
make.
You
asked
to
be
verified.
So
if
you
do
a
507
signature
on
a
transaction,
we're
going
to
charge
you
to
verify
all
five
of
those
signatures
and
those
provide
for
some
really
low
fees.
That's
one
of
the
ways
to
get
to
low
fees.
A
Is
they
only
charge
for
what
you
use,
but
that
had
some
interesting
interactions
with
with
ethereum,
but
when
we
were
able
to
figure
out
is,
for
the
most
part,
the
ethereum
gas
that
is
charged
for
these
operations
already
covers
the
fee.
If,
if
we
do
a
conversion
for
the
gas
price
to
hit
to
h-bar,
it
almost
always
comes
up
greater
than
the
fee,
that's
going
to
be
charged
in
the
cases
where
hedera
would
charge
more
under
the
covers.
A
We
charge
more
and
there's
only
a
few
cases
like
if
you
have
an
account
with
an
expiry.
That's
set
to
you
know
the
23rd
Century,
that's
that's
going
to
be
really
expensive,
and
so
that's
where
the
price
would
come
through,
but
if
you're
using
the
default
setup,
where
your
accounts
need
to
be
Auto
renewed
every
three
months,
it'll
look
just
like
the
exact
same
gas
schedule
that
you're
going
to
see
in
ethereum.
A
Now
one
thing
that
is
changing
with
this
issue,
I
said
about
charging
storage
for
the
23rd
Century
we're
separating
the
charge
for
long-term
rent
from
the
writing
of
the
value
on
the
first
time,
and
that's
because
we're
introducing
the
notion
of
State
rent
into
the
the
hedera
network,
but
we're
going
to
charge
separately
out
of
the
evm
for
it.
This
is
something
probably
going
to
ship
in
2023.
A
So
the
next
point
of
integration
is
we
wanted
to
integrate
the
evm
with
hedera
token
Services.
We
wanted
people
who
are
using
an
evm
type,
smart
contract
to
have
the
same
first
class
interactions
with
a
hedera
token
service.
Token
HTS
token,
as
you
might
have,
if
you
were
to
deploy
your
own
erc20
or
erc721
contract
within
the
evm
one
of
the
advantages.
What
I
want
to
encourage
people
to
use
the
HTS
system?
Is
this
much
more
cost
efficient
and
memory
efficient
and
faster?
A
If
you
give
someone
a
token
and
they
want
to
trade
it,
they
can
do
it
for
much
cheaper
than
within
the
within
the
evm.
So
the
hedera
token
services,
like
I,
said
it's
a
it's
a
ledger
native
token.
That
has
no
interaction
with
evm.
It
exists
as
a
hedera
as
a
hedera
concept.
You
can
do
10
000
transactions
per
second
on
these,
if
you're
using
the
happy
and
there's
low
fees.
A
It's
like
1
100th
of
a
cent
to
transfer
tokens
from
one
person
to
the
next,
and
we
support
nfts
fungible
tokens
and
again
we
access
this
via
the
grpc
service,
we'll
get
to
this
in
the
in
the
next
segment
of
why
this
is
a
problem.
But
if
you
want
to
use
the
native
tokens
and
get
the
high
speed
and
cheap
fees,
you
have
to
use
the
grpc
there's
sdks
that'll
help
you
out
with
that.
It's
really
easy
to
code,
but
you
can't
do
it
with
hard
hat.
So
that's
the
downside
is.
A
It
would
require
developers
to
move
to
a
new
SDK
which
can
be
a
problem
so
as
far
as
the
evm
side
of
encouraging
to
use
that
we
decided
to
expose
the
HTS
services
to
via
what
I'm
calling
a
system
contract.
Ordinarily
call
stuff
like
this:
a
pre-compiled
contract
but
I
want
to
separate
the
notion
of
a
pre-compile
contract
from
a
system
contract.
A
pre-compiled
contract
is
something
that
you
could
express
entirely
within
solidity.
For
example,
a
lot
of
crypto
Primitives.
You
can
actually
do
a
solidity.
A
The
reason
you
wouldn't
do
it
in
solidity
is
because
it's
really
expensive.
It
costs,
like
2
million
gas,
to
verify
a
signature.
That's
just
way
too
much
gas,
so
they
tell
the
clients
to
implement
it,
natively
and
charge
something
closer
to
20,
000
gas
to
verify
a
native
signature.
So
that's
stuff
that
does
that
I
would
properly
call
a
pre-compile
contract.
But
what's
going
on
with
these
system
contracts,
is
it's
actually
breaking
a
layer?
A
It's
leaving
the
evm
and
interacting
with
the
container,
that's
hosting
it
and
and
doing
services
like
you
would
break
out
of
a
container
in
in
a
Docker.
You
would
go
in
and
you
would
access
the
system
and
bring
it
back
in.
So
that's
where
the
system
contract
concept
comes
from,
so
these
services
that
you
can
do
you
can
transfer.
You
can
mince
and
burn
your
tokens.
You
can
create
new
tokens.
You
can
change
the
keys
on
your
tokens
and
you
can
do
this
via
a
solidity
interface.
A
All
these
Services,
you
can
do
all
these
calls
via
a
grpc
happy
service,
but
now
we'll
let
you
do
it
through
a
evm
system
contract.
There
are
some
really
useful
use
cases
for
these
there's
a
company
called
Galaxy.
That
is
letting
people
create
tokenize
themselves
and
their
followers.
So
if
you
have
a
really
popular
YouTube
channel,
you
could
create
a
token
of
high
fives.
A
You
could
give
people
hey
100
high
fives
for
for
liking,
my
stream,
so
you
could
create
that
token
and
in
the
smart
contract
you
can
automate
the
creation
of
it
and
handle
it
and
set
it
up
in
an
automated
fashion,
and
you
could
mint
more
hi-fi's.
If
you
need
it,
you
could
burn
the
high
fives.
If
you
have
too
many,
you
could
create
nfts.
You
could
transfer
nfts
Within
These
smart
contracts,
so
Galaxy
is
one
example
of
where
you
might
want
to
do
some
of
those
things
in
an
automated
fashion.
A
It's
really
ugly,
looking
it's
not
as
easy
as
a
function,
so
we
write
a
function
for
you
that
will
do
that
ugly,
unwrapped
call
for
you
and
it
will
look
just
like
a
solidity
call
and
it's
it's
a
internal
function,
so
it'll,
inline
and
it'll
be
just
the
same
as
if
you
did
it
yourself.
So
those
are
in
the
SDK
and
the
smart
contracts
repository
to
use
these
these
tokens,
as
though
they
were
just
another
smart
contract.
A
Another
thing
we
did
for
the
for
the
tokens
themselves
so,
like
I,
said,
there's
an
account
in
your
smart
contract
as
an
account.
All
of
these
accounts
come
from
the
same
number
space.
So
if
you
post
a
token,
it's
going
to
come
from
that
same
sequence
of
numbers,
which
again
maps
to
a
hedera
address
that
I
call
the
long
zero
address.
A
So
what
we
integrated
was
a
series
of
redirect
contracts
into
the
into
the
HTS
system
contract
that
allows
you
to
treat
these
these
tokens
in
their
evm
addresses,
as
though
they
were
erc20
or
ERC
721
tokens,
and
this
allows
you,
when
you
hook
your
hook,
your
metamask
up
via
hashio.
You
can
see
your
token
balance
as
though
it's
a
so
it's
an
erc20
token.
You
can
trade,
your
ERC
721s,
just
like
it's
a
regular
old
nft
and
let
me
go
through
the
notes.
A
Here
make
sure
I
get
everything
covered
and
it
was
published
by
hip.
218
I
talked
about
the
hip
process.
This
is
how
we
specified
how
I
would
be
interacting
with
it
and
the
contract
redirects
to
167.,
so
your
contracted
oofff.
If
that's
your
ethereum
address
for
your
token,
it
would
then
redirect
it
put
the
token
address
in
there
and
call
a
different
method
in
the
system
contract.
A
Now.
One
interesting
thing
about
this
to
prove
that
it
works
not
only
I've
seen
my
nfts
in
in
metamask
and
my
tokens
in
nfts,
but
one
of
our
partners
in
a
demo
the
other
day
showed
us
how
they
got
the
Xerox
order
book
working
with
our
nfts.
You
could
put
your
nft
in
an
order
book
and
it
could
be
filled
by
a
different,
different
decks.
That's
on
the
system
and
it
just
works
like
magic,
because
we
implemented
all
these
standard
apis
that
are
standard
in
ethereum
and
they
just
work
with
with
you
know.
A
A
It's
a
little
bit
of
developer
anxiety
that
I'm
sharing
there.
Every
developer
feels
like
that.
When
they
ship
a
new
feature
so
quickly,
there's
a
couple
of
other
system
contracts
that
we
exposed
to
expose
system
information
in
there.
The
first
one
is
the
exchange
rate
like
I
mentioned
before
I.
Don't
think
I
mentioned
it
here.
Actually,
hedera's
fees
are
fixed
to
Fiat,
so
we
we
every
so
often
we
go
out
and
figure
out
what
the
what
the
consensus
exchange
rate
is
of
H
bar
to
Dollars.
A
We
feed
that
into
an
exchange
rate
calculator,
so
we
calculate
your
fees
that
we're
going
to
charge.
We
convert
that
to
H
bars,
so
it's
still
going
to
cost
you
100
of
a
Cent
and
H
bars
to
your
transfer.
So
if
you
want
to
inside
of
your
smart
contract
figure
out
what
that
exchange
rate
is
rather
than
doing
math
with
the
gas
cost
and
making
assumptions
about
the
schedule,
you
can
just
ask
it.
A
You
know
what
is
the
current
exchange
rate
in
in
hbars
and
what's
the
current
exchange
rate
of
H
bars
to
to
Tiny
cents
is
what
we
call
it
and
we'll
return
that
information
and
there's
another
smart
contract,
the
prngc.
This
is
the
one
I'm
going
to
be
integrating
to
give
the
same
sort
of
functionality
as
randow
some
of
the
technical
details.
A
A
This
is
like
a
big
brain
dump
and
you're
just
trying
to
absorb
it
cool.
So
the
last
thing
I
want
to
talk
about
is
the
hedera
Json,
RPC,
bridge
and
hashio
project.
The
hashio
is
the
Branded
version
that
we're
hosting,
but
it's
actually
a
Json
RPC
bridge
and
what
we
need
this
for
is
to
solve
The
Last,
Mile
problem.
What
I
call
the
last
mile
problem
of
getting
people
to
use
hedera
from
ethereum
the
developer
tools
that
people
use
depend
on
the
ethereum
way
of
accessing
the
network.
A
They
depend
on
a
Json,
RPC
interface.
The
response
to
certain
Json
RPC
calls,
and
some
very
deep
assumptions
about
the
ethereum
network
are
built
into
that,
for
example,
the
way
that
the
transactions-
it's
just
one
transaction
type,
it's
rlp
encoded.
You
got
to
sign
with
an
ecdsak
and
your
Esa
ecdsa
key
has
to
match
to
the
account
that
you're
working
through
these
are
some
pretty
deep
assumptions.
The
Run
counter
to
some
of
the
things
we've
done
inside
of
hedera,
for
example,
we
have
a
grpc
account.
A
All
of
our
accounts
are
not
tied
to
a
particular
key.
You
can
rotate
your
keys.
You
can
say
that
your
account
is
a
three
of
seven
multi-sig.
You
can
say
that
your
account
is
a
multi-sig
that
requires
signatures
from
three
groups.
You
need
someone
from
admin.
You
need
someone
from
Finance.
You
need
someone
from
the
executive.
You
can
do
these
really
complex,
awesome
trees
that
ESG
people
love
to
see,
go
on
with
it.
A
That
ethereum
can't
do
and
do
it
natively,
but
when
it
comes
to
calling
something
via
metamask
metamask
doesn't
know
or
care
that
you
have
a
rich
and
thorough
key
hierarchy.
All
they
know
is
that
they
got
a
private
key.
That's
going
to
sign
this
transaction
to
do
this
call
and
they're
going
to
send
it
to
you
and
hopefully
you're
ready
to
receive
it.
A
So
so
those
are
some
of
the
things
that
we
needed
to
solve
and
we
need
to
solve
these
problems
because
a
lot
of
these
dapps
out
there
a
lot
of
these
white
label
apps
that
we're
trying
to
bring
in
they
have
to
work
in
the
ethereum
way,
because
that
is
becoming
the
the
IBM
PC
compatible
of
the
smart
contract
world.
It's
not
the
only
game
out
there,
but
it's
the
biggest
game
and
it's
the
game
that
gets
you
the
most
traction
amongst
all
the
chains.
A
So
the
first
thing
that
we
did
to
support
this
one
of
the
deepest
problems
is
sending
transactions.
So
we
created
a
new
hedera
transaction
type,
called
ethereum
transaction.
It's
a
really
simple
transaction.
It
has
the
signed
bytes
of
an
ethereum
transaction
and
then
it's
a
relayer
that
wraps
the
transaction
and
they're
paying
for
bringing
this
transaction
to
consensus
in
the
hashgraph
and
they're
paying
for
nothing
else.
Everything
else
is
paid
for
by
whoever
signed
that
ethereum
transaction
and
the
key
that
signed
the
ethereum
transaction
is
brought
into
the
key
set.
A
So
if
you
have
that
ecdsa
key
in
your
account
key
that
it
maps
to
and
you've
signed
that
transaction,
then
you
don't
need
any
other
signatures
in
the
relayer.
So
this
is
designed
for
simple
cases
where,
if
you
have
an
account,
you
just
want
to
interact
with
ethereum
and
evm
type
stuff.
You
would
create
one
account
that
has
one
key,
that
one
key
is
ecdsa
and
you
set
that
as
the
Alias
and
that's
how
you
would
interact
with
it
and
so
the
the
gas
key,
the
gas
cost.
There's
some
things
in
the
transaction.
A
We
can
pay
attention
to
and
some
things
we
can't
if
you
set
a
gas
cost
on
there,
that
is
lower
than
the
fixed
gas
cost
of
hedera
we're
going
to
reject
it.
If
you're
using
1559
in
your
max
fee
allows
for
it
to
be
covered,
we'll
charge
you
the
actual
fee,
but
if
you're
using
a
type
1
transaction,
you
said
a
ridiculously
high
gas
price.
A
The
the
agreement
you're
making
with
a
type
1
transaction
is
we're
going
to
charge
you
as
much
as
you
ask
for
so.
If
you,
if
you,
if
we
halfway
support
1559
and
that
you'll
set
a
maximum
fee
and
we'll
only
charge
you
the
literal
fees,
we
have
to
charge
you
per
the
standard
fee
schedule,
and
one
other
feature
that
we
have
in
here
is
that
the
sign
era
has
the
opportunity
also
to
pay
for
the
fees
for
you.
A
A
Oh
yeah,
it's
the
second
bullet
on
the
top,
so
the
relayer
can
offer
to
pay
for
a
certain
amount
of
the
transactions
they
can
pay
for
part
of
the
transaction
or
all
of
the
transaction.
So
this
actually
opens
up
the
opportunities
for
for
meta
transactions,
for
example,
for
game
use
cases
they'll
want
to
use,
adapt.
They
need
a
zero
gas
Network.
You
just
need
to
set
up
a
relayer,
that's
going
to
pay
for
all
the
fees
that
come
in
for
all
of
your
game
transactions.
A
You
want
to
work
on
hedera,
and
so
we
support
this
the
public
test
and
then,
of
course,
won't
do
it.
You'll
need
us.
The
public
Casio
instance
you'll
need
to
set
up
your
own
instance
with
your
own
relayer,
and
if
you
do
things
right,
you
could
relay
it
to
a
node
that
you
have
an
agreement
with
that
you'll
get
the
fees
back
from.
So
if
Google
wanted
to
host
a
game,
they
could
just
point
it
at
their
game
and
that
the
gas
fees
would
to
some
extent
become
circular
the
Json
RPC
Bridge.
A
We
also
needed
to
implement
all
of
the
other
queries
that
are
in
Json
RPC
and
it's
a
mix
of
well.
So,
let's
see
we
do
the
happy
The
Raw
transactions.
I.
Don't
think
I
discussed
that
too
much
of
this
so
I'm
going
to
go
off
slide
and
just
talk
about
this
a
little
bit,
but
we
had
to
implement
all
of
the
different
Json
RPC
transactions,
and
sometimes
we
need
to
go
to
the
hedera
node
and
do
a
paid
transaction,
and
sometimes
we
go
to
our
mirror.
A
Node
I
didn't
get
a
slide
in
here
to
show
the
typical
Network
architecture,
but
getting
items
from
the
hit
consensus
nodes
we
always
charge
because
you're
getting
in
the
way
of
consensus.
We
need
to
limit
it
and
incentivize
people
to
use
other
sources.
We
have
another
system
called
the
mirror
node
that
takes
the
takes
the
the
transaction
stream
and
makes
it
available
for
free
that
you
can
read
from
and
stand
up
your
own
instance
to
get
the
data
from.
A
So
some
of
these
calls
we
can
go
to
the
mirror
node
and
where
we
can
go
to
a
mirror
node,
we
do
to
get
them
for
free.
Some
of
them.
We
go
to
the
consensus
nodes
and
the
mirror
node
is
in
the
middle
of
upgrading
to
support
more
and
more
of
these
rich
calls,
because
we
still
have
some.
We
can't
do
debug
get
storage
at
quite
yet
because
we
don't
have
that
available
on
the
mirror.
A
Node,
but
they're
improving
these
and
we'll
be
able
to
support
all
these
eventually
and
the
reason
we
need
some
of
these.
These
strange
calls
like
get
storage
at
and
get
Contract
data
is
because
some
of
the
development
tools,
like
metamask
truffle
and
hard
hat
I'd
like
to
get
out
of
this
information
when
they're
doing
debugging
work.
So
we'll
expose
this
we're
exposing
some
of
these
through
the
developer
tools.
The
developer
tools
won't
perfectly
work,
yet
it's
still
a
beta.
A
The
only
thing
we
targeted
for
this
stage
is
to
get
web
wallets
like
metamask
and
tally
working
correctly,
and
so
those
those
are
the
ones
we
focus
on
right
now.
But
our
our
roadmap
item
is
to
get
this
working
with
a
developer
tool
seamlessly
and
transparently.
So
all
you
have
to
do
is
just
point
your
developer
tool
in
a
different
RPC
endpoint
and
then
suddenly
you're
on
hedera.
A
Now,
when
I
say
that
that
you
know
we
just
want
to
make
it
transparent,
go
to
hedera,
you
need
to
ask
well,
why
would
you
go
to
hedera
there's
some
key
differentiators
that
we
like
to
remind
developers
when
they're
developing
transactions
and
they're
putting
them
on
the
various
evm
compatible
chains?
One
of
the
biggest
things
that
we
like
to
point
out
about
hedera
is
that
there
is
no
transaction
pool.
There's
no
mempool.
Once
you
post
a
transaction
on
hedera,
it's
fixed
in
that
position,
nobody
can
censor
it.
A
It's
going
to
go
through
consensus,
so
there's
no
sandwich
trading.
There's
no
minor
extractable
value!
There's
no
games
with
ordering
things
out
of
the
pool
or
trying
to
keep
your
tornado
tornado
cast
transactions
out
of
it,
we're
going
to
take
them
all
as
they
come
in
the
next
thing,
and
this
is
really
the
secret
to
how
we
get
our
performance
speed.
Is
that
ordering
an
execution
of
these
transactions
are
separate
steps?
We
order
the
transactions
and
then
we
execute
them.
We
don't
play
a
game,
we
say
well.
Is
this
transaction
going
to
succeed?
A
If
it's
not
well,
then
we
can't
put
it
in
every
transaction
that
comes
to
consensus
gets
executed
after
the
order
is
set.
So
there's
no
consideration
for
the
side
effects
and
things
go
fast
enough.
We
really
don't
have
time
to
do
that
and
finally,
there
is
continuous
transaction
execution.
We
don't
wait
10
seconds
and
give
you
report
of.
You
know
5
000
transactions
that
went
through
every
second.
Every
time
we
can
come
to
consensus
and
figure
out
that
a
transaction
is
reached
final
order.
We
will
execute
it
continually
on
each
of
the
nodes.
A
A
And
finally,
we
solve
The
Last
Mile
Problem
by
project
hashio,
where
we
provide
a
Json
RPC
bridge
that
talks
to
hedera
in
the
RPC
mechanism,
sedera
talks
about,
while
at
the
same
time
making
it
open
for
for
developer
tools
to
work
and
interact.
They
were
designed
to
work
with
the
ethereum
ecosystem
and
get
those
working
with
hedera
and
get
your
develop
and
get
your
web
wallets
and
everything
working
with
that.
A
So
here's
some
links,
like
almost
every
company
here
hedera,
is
hiring
swirlslabs.com
careers.
If
you
want
to
see
the
open
list,
but
if
you
want
to
get
a
hold
of
me,
I
am
at
shemnon
on
Twitter
and
GitHub
on
Discord
I,
guess:
I'm
shemnon,
Number
2321.
You
need
those
numbers
because
discord's
Discord
or
if
you
like,
email,
if
you're
part
of
my
generation
and
still
use
email,
you
can
use
dano.fairnessworldslabs.com.
A
A
Brett
did
I
miss
anything,
maybe
if
they're,
you
know,
you
know
about
anybody
who's
starting
to
use
this.
These
new
capabilities
do
I
know
anyone
starting
to
use
these
capabilities.
Do
I
know
anyone
I
can
talk
about
I.
Think
I
can
mention
open
Zeppelin,
because
they're
part
of
the
Australia
ANZ
Bank
stablecoin
currency,
one
of
the
features
that
they
needed
to
support
because
of
their
governance.
They
needed
this
project
that
open
Zeppelin
had
called
Defender
and
it
only
really
worked
well,
the
adjacent
RPC
and
we
talked
to
them.
A
It's
like
hey.
Could
you
convert
to
happy
and
they
said
how
much
money
and
are
you
going
to
give
us
the
engineers
which
is
a
typical
problem
in
in
the
smart
contract
space
right
now,
because
we're
engineering
constrained
almost
everything,
but
when
we
bring
them
a
Json,
RPC
Bridge
they
can
access
hedera
and
get
the
information
they
need
through
Json
RPC,
their
tool
just
magically
works
because
they're
speaking
in
the
language
it's
expecting
and
it
gives
them
all
the
feedback
and
Telemetry
that
they
needed.