►
Description
Connecting Hyperledger Besu to Enterprise Systems - Danno Ferrin, ConsenSys
In this session you will see how Hyperledger Besu can be connected to non-blockchain enterprise systems.Hyperledger Besu can be a source, destination or a fully interactive participant in these systems.You will also see the mechanisms used to connect: form ordinary RPC calls, to websocket connections, to code plugins.There will also be information about the various layers within the blockchain that the enterprise systems may want to interface with.
----
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
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 #HyperledgerGlobalForum2020 #Blockchain
A
All
right,
so
it's
11
o'clock
time
to
start
for
the
first
session
of
the
conference
today,
I'm
gonna
be
talking
about
how
you
can
use
hyper
letters,
but
how
to
connect
hyper
ledger.
Basu
data
to
you,
Enterprise
Systems,
bit
of
a
background.
My
name
is
Dano
Ferran
I
am
a
blockchain
protocol
engineer
at
consensus.
There's
a
business
group
inside
of
it
called
Pegasus,
sometimes
you'll,
see
us
use.
Both
Pegasus
is
the
protocol
engineering
group
and
systems
Pegasus.
Someone
really
wanted
to
spell
Pegasus
and
it's
awesome.
So
we
do
it
that
way.
A
Everyone
here,
familiar
with
hyper
ledger
base
with
etherium,
will
do
some
background
with
it
as
we
go
on,
but
as
I
go
through
this
talk,
if
you
have
any
questions
about
what's
on
the
slide,
feel
free
to
raise
your
hand,
I'll
repeat
the
questions.
I'm
not
big
for
holding
the
questions
to
the
end
unless
they
have
nothing
to
do
with
any
of
my
slides.
That's
the
best
time
to
ask
those,
but
if
you
have
a
question
about
what's
on
the
screen,
feel
free
to
raise
a
question.
A
It's
the
agenda.
First
I'm
going
to
give
a
brief
overview
of
aetherium,
and
that
is
gonna
be
focused
specifically
on
what's
relevant
for
enterprise
integration,
not
going
to
cover
everything
about
aetherium
and
then
we're
gonna
have
a
little
brief
discussion
about
the
hierarchy
of
integrations
kind
of
do
a
Maslow's
hierarchy
of
what
sort
of
integrations
you
want
and
where
you
just
start
from
the
bottom
and
build
towards
the
top.
A
Then
I'm
gonna
talk
about
the
three
different
main,
the
four
different
main
ways:
we're
gonna
do
integration
through
JSON
RPC,
WebSockets,
graph,
QL
and
through
something
we
just
released
in
bassy,
1.4,
Basu,
plugins
and
I'm
gonna
have
a
sidebar
in
there
about
how
you
would
need
to
build
your
smart
contracts
for
integration.
It
really
works
best
if
the
smart
contracts
are
designed
to
be
integrated
into
the
enterprise
systems.
A
In
addition
to
be
able
to
get
the
data
from
the
enterprise
systems,
so
this
lovely
little
hierarchy,
block
diagram
is
a
very
vastly
oversimplified
overview
of
what
aetherium
is.
The
etherium
blockchain
is
a
chain
of
blocks,
as
the
name
describes,
and
each
block
contains
one
or
more
transactions.
Typically,
these
transactions
manipulate
data
in
the
etherion
blockchain.
Each
each
accounts
that
does
a
transaction
has
a
balance
of
ether
or
whatever
the
native
token
currency
is
on
your
enterprise
chain.
A
If
you
have
it,
each
account
also
has
storage
it
stores
data
associated
with
the
code
that
it
executes.
We
call
these
codes
smart
contracts,
some
people
love
the
name.
Some
people
hate
the
names
but
I'm
just
gonna
call
it
a
smart
contracts,
because
that
is
the
industry
standard
for
what
these
things
are.
And
finally,
another
thing
that
happens
while
these
smart
contracts
are
executed
is
a
number
of
event.
Log
has
come
out.
These
are
the
transaction
event
logs.
They
are
emitted.
A
Solidity
has
a
keyword
and
it's
embedded
into
their
language
to
emit
hey
I
did
this.
These
are
associated
with
the
transaction.
They
don't
go
in
the
storage.
When
you
look
at
the
transaction,
you
get
the
data
from
it
now.
The
first
block
shows
a
very
simple
form
of
a
transaction
there's
just
two
plane
transactions
at
the
base
of
the
block.
The
second
block
shows
something
else.
That's
interesting
and
I
think
a
very
powerful
feature
of
aetherium.
You
can
compose
smart
contract
calls.
A
You
can
have
one
smart
contract
call
another
smart
contract
as
though
it's
yourself
or
as
though
it's
them,
and
so
from
one
contract
execution.
You
can
invoke
an
entire
chain
of
contracts
to
do
all
sorts
of
amazing
things.
Ask
fulcrum
how
that
went
a
couple
weeks
ago
with
their
smart
contract
platform.
It
was,
it
was
a
work
of
art
and
sometimes
the
best
artists
deal.
Unfortunately.
A
So
as
far
as
transactions,
a
transaction
is
the
main
thing
that
gets
put
in
all
of
these
blocks
and
transactions
do
one
of
two
things:
they
either
call
code
that
is
in
an
account,
or
they
put
code
into
an
account.
They
they
they
call
the
contracts
or
they
put
the
contracts
on
a
chain
and
that's
one
important
thing
about
aetherium:
all
smart
contracts
live
as
data
on
the
blockchain.
So
you
can
see
every
contract,
that's
being
executed
and
all
nodes
use
that
data
to
verify
that
the
blocks
execute
everything
is
deterministic
and
verifiable.
A
A
The
accounts
also
are
an
important
thing
that
execute
these
and
there's
four
key
pieces
of
data,
sometimes
three
that
are
stored
in
each
account.
If
it's
a,
if
it's
a
public
network,
there
is
going
to
be
a
value
or
a
balance,
the
etherium
a
net
that
value
is
called
aetherium.
There's
a
series
of
tests,
nuts
that
they
call
it.
A
You
know,
go
reap
the
etherium
roxton
aetherium
go
aetherium
for
the
Gourley
chain
and
those
are
the
the
main
anti-abuse
mechanisms
they're
used
to
meaner,
the
use
on
the
public
chains,
private
chains,
you
may
or
may
not
use
these
values
or
balance
it's
up
to
you.
The
next
thing
is
the
notes:
has
this
account
been
executed?
How
many
times
is
the
sequence
to
make
sure
you're
doing
everything
in
order
and
the
storage
of
the
accounts,
these
smart
contracts,
they
will
associate
large
amount
of
storage
if
you're
doing
like
a
bunch
of
crypto
kitties.
A
They
need
to
know
in
that
storage
which
account
owns,
which
crypto
kitties
and
what
the
characteristics
are
and
those
are
stored
in
the
storage
that
associated
with
each
and
every
account.
And
finally,
if
this
transaction
is
smart
contracts
itself,
it
will
have
the
code
for
the
smart
contract.
If
it's
a
regular
old
account
controlled
by
a
public
key,
it
probably
won't
have
the
storage.
A
Now
the
account
addresses
that
you
see
in
the
theorem
are
these
big
long
strings
and
they
correspond
to
one
of
two
things:
either
the
public
key
used
to
validate
that
I
want
this
account
to
do
its
action
or
it
has
the
it's.
It's
an
address,
that's
derived
from
the
creation
of
a
smart
contract
that
is
stored
onto
that
to
the
address,
so
some
accounts
can
be
executed
via
smart
via
public
private
keys,
and
some
can
only
be
executed
via
contract
calls.
A
So
how
do
we
do
it?
What's
the
important
things?
This
is
kind
of
a
Herrick
Maslow's
hierarchy
of
what's
important
for
enterprise
integrations
of
the
sorts
of
things
that
you
might
want
to
do,
and
the
very
lowest
thing
that
you
would
want
to
do
for
any
enterprise
integration
is
you
want
to
be
able
to
read
from
the
chain
that
is
most
of
what
the
integration
is
going
to
talk
about
later,
do?
Does
it
give
you
ways
to
read
data
from
the
chain,
just
read
what
has
been
done?
A
What
have
other
people
done
with
it
and
get
that
into
your
other
system
to
report
it
to
reckon
I'll?
Let
to
share
it
to
to
do
whatever
is
needed
to
be
done
with
it.
The
next
level
is
to
rights
the
chain.
There
are
a
couple
of
methods
that
I'll
point
out
in
here
that
you
can
use
to
write
data
from
the
chain.
This
is
another
level
of
integration.
You
can't
there's
no
point
in
writing.
A
If
you
can't
read
from
it
for
an
enterprise
integration,
sometimes
you
want
to
push
data
back
in
the
next
two
levels:
I'm
not
really
going
to
discuss
in
this.
These
are
kind
of
the
higher
level
things.
Maybe
in
next
year's
talk.
There
are
some
great
opportunities
for
the
roles
of
smart
contact
contracts.
The
next
level
to
I
call
querying
where
the
blockchain
code
itself
knows
about
the
enterprise
system
and
all
the
systems
have
what
is
needed
for
those
enterprise
systems
and
they
go
out
and
they
call
to
those
enterprise
systems.
A
Those
requires
some
precompiled
contract
integrations,
but
it's
kind
of
tricky,
because
when
you
do
the
same
call
with
the
same
value,
it
has
to
come
back
with
the
same
results.
So
that's
a
little
bit
of
a
higher
level
and
then
finally,
there
is
the
highest
level,
the
pinnacle
of
the
pyramid.
Where
you
look
act
and
smell
like
just
another
aetherium
note,
I,
don't
think
we're
there
yet,
but
that
is
where
we
need
to
get
with
integrating
these
systems
but
to
get
to
those
higher
levels.
A
Great,
like
I,
said.
If
you
have
any
questions,
shoot
up
a
hand
and
I
can
answer
it.
So
for
a
lot
of
people
that
are
integrating
with
the
theory
and
blockchains
ninety-five
percent
of
the
time
it
is
done
through
a
protocol
called
JSON
RPC.
This
is
an
RPC
mechanism
that
uses
JSON
objects,
sent
typically
a
via
HTTP
back
and
forth.
There
is
an
actual
aetherium
improvement
protocol
standard
for
this.
This
is
kind
of
the
standard
process,
for
theory,
omits
to
do
something
called
a
IPS,
the
IP
1474
that
defines
for
each
node.
A
At
least
you
have
serious
performance
considerations.
If
you
don't
have
serious
performance
considerations,
there
are
many
great
libraries
that
don't
just
wrap
the
json-rpc
they
wrap
the
api's
into
language
native
integrations.
Web
3j
is
one
that
I've
used
in
Java
it.
It
takes
all
this
JSON
RPC
and
all
this
connection
and
drops
it
in
a
plain
old
java
code.
That's
what
the
demos
that
I've
written
have
been
written
in
another
very
popular
one
is
web
3GS
a
lot
of
those
daps
like
crypto
kitties,
and
a
lot
of
the
decentralized
exchanges
that
are
all
web-based.
A
They
use
the
JavaScript
version
of
the
integrations
of
typically
web
3j
s.
There
is
ether,
j/s,
there's
a
lot
of
different
versions
of
this
I'm.
The
most
common
one
is,
of
course,
web
3j
s
in
a
target
javascript
and
note
on
the
server
side,
so
you
can
use
in
your
web
browser
and
you
can
use
it
on
your
node.js
back
end.
There's
a
couple
more
just
to
show
that
you
know.
I
picked
two
random
languages
that
I
thought
people
might
be
interested
in
and
integrations
exist
for
these
languages.
Eath.
A
Our
PC
is
an
implementation
in
the
go
programming
language
and
it
provides
the
same,
provides
the
same
level
of
integration
of
a
language
native
integration.
It
looks
like
you're
just
calling
another
go
object
once
you
setup
the
connection
to
the
server
it
works.
Just
fine
and
another
one
is
aetherium
RPC
client
in
python.
A
The
URL
is
longer
so
I
had
to
drop
the
font.
Sorry
about
that,
but
this
is
something
that
is
maintained
by
Piper
Miriam,
who
is
you
know
the
very
highly
respected
person
in
the
etherion
Python
community
he's
leading
the
stainless
aetherium
effort,
so
he's
written.
Some
very
good
integrations
if
you
want
to
connect
to
via
Python
Python
is
a
an
important
growing
language
and
a
lot
of
business
backends.
A
So
here's
a
quick
look
of
what
a
JSON
RPC
wire
protocol
request
looks
like
it's
really
simple:
here's
the
method,
here's
the
parameters
and
this
ID
is
used
to
multiplex
in
case
you
want
to
do
multiple
calls
and
not
have
to
wait
for
the
results.
So
we
want
to
know
the
get
balance
of
this
particular
query.
It
comes
back
that
your
balance
is
once
the
Fe
big
long,
18
digit
number
it's
in
hexadecimal,
so
the
language
is
also
deal
with
a
lot
of
the
weird
edge
cases
for
a
lot
of
the
details.
A
A
So
probably
the
top
five
methods
you're
going
to
use
out
of
JSON
RPC
to
get
the
data
off
of
the
blockchain
into
your
enterprise
system.
Are
these?
If
get
balance
is
the
one
that
you're,
probably
not
gonna,
be
using
that
much?
Unless
you
have
your
Enterprise
chain
uses
balance
get
logs
is
a
very
important
one,
because
you're
gonna
get
a
lot
of
the
log
events
that
are
gonna
come
out
for
a
lot
of
the
contracts
you
execute.
A
If
get
storage
at
gives
you
access
into
the
actual
storage
of
the
accounts,
you
can
give
a
slot
number
and
you
can
get
the
data
directly
from
the
smart
contract
storage
without
having
to
interface
with
its
methods.
You
can
just
poke
at
it.
If
you
know
where
to
poke,
you
can
read
the
data,
it's
all
in
the
public.
Now,
as
I
mentioned,
that
you
might,
you
know,
might
not
know
what
the
storage
to
get
at.
There
is
also
something
called
eath
call
that
allows
you
to
execute
view
or
static
methods.
A
A
So
you,
if
you
want
to
be
able
to
do
a
full
enumeration
of
all
the
accounts
in
there
you're
going
to
need
to
integrate
that
into
your
smart
contract
and
have
it
access
via
neat
call
method,
but
it
can
also
provide
other
metadata
that
such
as
what
is
the
name
of
this
token?
What
is
the
trading
symbol
of
this
token?
How
much
of
this
token
is
out
there?
It's
great
metadata,
you
can
do,
and
also
you
can
do
some
small
level
of
data
analysis.
And
finally,
the
last
thing
is:
you
can
query
a
transaction
receipt.
A
So
I'm
gonna
take
a
quick
sidebar
and
talk
briefly
about
building
for
integration.
These
api's
are
great
they're
low
level.
They
get
you
all
the
details,
but
it's
a
lot
of
work.
Sometimes
to
get
this
information
out,
you
need
a
build
your
solidity
contract
with
a
little
bit
of
higher
level
information
to
get
the
information
you
need.
The
first
thing
you
should
do
is
you
guys
use
a
something
called
view
methods
to
simplify
some
of
your
interactions.
A
If
you
have
multiple
maps
that
you
store,
multiple
values
of
the
counts,
people
may
not
know
directly
what
the
hash
values
need
to
put
in
to
get
at
those.
So
if
build
a
view
method,
then
the
solidity
contract
will
be
able
to
get
that
information
for
you.
If
you
have
transient
information
that
you
don't
need
to
store
forever
use
a
log
event,
storage
can
be
expensive
in
aetherium
on
a
private
chain
and
especially
on
the
public
chains.
A
So
if
it's
something
that
you
only
need
to
query
once
put
in
the
transaction
log
event
and
have
your
integration
pull
out
information
from
the
transaction
and
put
on
your
enterprise
system,
finally,
you
can
use
a
solidity
API
to
decode
the
data
that
you
put
on
in
these
data
segments.
There's
a
very
well
defined
format
in
these
languages
that
I
pointed
out
earlier.
I'll
show
you
how
to
bring
that
data
out
and
put
it
in
directly.
One
very
good
example
is
the
ERC
20
tokens.
This
is
the
one
of
the
oldest.
A
If
theorem
standards
out
there,
that's
used
widely,
and
it's
how
you
deal
with
fumble
tokens.
That's
how
I
think
us
tether
the
etherium
version
of
tether
implements
these
ERC
20
interfaces.
If
you
poke
at
the
right
contract
for
4
died
at
maker
at
a
certain
level,
they
are
just
ERC
20
contracts
and
they've
exposed
all
these
events.
They
have
these
view
api's
and
when
you
get
into
some
of
the
log
data,
you
use
the
same
api
city
code
that
you
are
c
20s
or
or
the
poster
child
for
good
integration.
A
A
Websockets
provide
the
same.
Json
RPC
calls
over
a
persistent
connection
that
ID
number
you
saw
in
there.
You
can
sling
a
bunch
of
them
out
and
the
other
end
will
return
them
in
the
order
that
they
complete
in
you
just
need
to
match
up
the
IDs,
so
you
can
just
keep
pipelining
all
this
data
in,
but
it
also
exposes
a
few
more
former
calls
that
are
very
useful.
A
When
you
have
a
persistent
connection,
you
can
ask
it
for
tell
me
when
certain
kinds
of
logs
come
in,
tell
me
when
the
new
pending
transactions
I'll
come
back
to
a
little
bit
later,
logs
and
syncing,
but
mostly
logs,
you
can
say:
I'm
gonna,
listen
for
logs
for
this
contract
for
this
particular
event
and
it'll
just
push
it
into
your
system
as
long
as
you're.
Listening
to
it,
we
get
the
API.
A
The
WebSockets
also
exposes
a
few
different
few
more
streaming
things,
the
syncing
one,
and
actually
there
is
a
JSON
RPC
method
for
that.
But
the
two
other
things
that
are
interesting
to
read
from
the
WebSockets
API
are
the
new
pending
transactions
and
new
heads
I
haven't
really
talked
about
those
in
any
of
the
other
integrations,
but
they
give
you
insight
into
the
state
of
the
blockchain
itself.
A
New,
pending
transactions,
if
theory
am
run,
what's
called
a
memory
pool,
so
all
of
the
transactions
that
come
in
from
the
world
flow
in
and
until
they're
putting
a
block,
they
just
sit
in
each
nodes.
Memories
pools
when
a
new
transaction
comes
in
that
hasn't
been
committed
to
a
block.
You
get
that
via
the
new
pending
transactions
call.
So
if
someone
broadcasted
a
transaction,
you
know
that
it's
coming,
you
can
be
prepared
for
it,
and
sometimes
it's
what's
interesting
is
sometimes
these
transactions
don't
actually
hit
the
blockchain
because
they
get
replaced
or
they
get
dropped.
A
So
this
might
be
interesting
to
know
in
enterprise
integration,
if
someone's
trying
to
do
a
transaction.
It
gets
cancelled
very
interesting
for
the
auditors
they're
interesting
for
the
people
doing
a
lot
of
the
regulation
for
this
and
the
other
one
is
new
heads
and
that's
what
a
new
block
comes
in
so
when
either
when
you're,
when
your
consensus,
algorithm
produces
a
new
block,
will
be
a
committee
or
whether
it's
mined
via
a
proof-of-work
mechanism.
A
This
will
tell
you
when
that
block
comes
in
if
you're,
using
a
non
proof-of-work
mechanism,
you
can
pull
it
a
regular
interval
and
be
pretty
close
to
guessing
when
it's
going
to
come
at,
but
if
you're,
using
a
proof-of-work
or
working
on
a
main
net,
those
blocks
come
in
and
essentially
random
times
they
average
at
a
certain
time,
but
they
can
be
five
seconds.
They
can
be
50
seconds
apart
by
subscribing
to
WebSockets
API.
You
insulate
yourself
from
a
lot
of
those
changes.
A
A
A
So
sometimes
you
might
do
it
to
fix
a
mistake
that
got
your
transaction
stuck
in
the
memory
pool.
Another
time
is,
it
might
be
because
you
haven't
paid
enough
gas
and
it's
not
gonna
get
mined
in
a
reasonable
times.
You
might
post
the
same
transaction
with
a
lot
more
gas
if
you
are
a
bad
actor
and
you
made
a
mistake
and
you
link
to
accounts.
You're
gonna
send
a
replacement
transaction
that
Sep
that
ruins
that
linkage.
A
So
those
don't
get
permitted
committed
to
the
blockchain,
so
there's
good
reasons
to
do
it
and
I've
actually
seen
that
exact
scenario
I
described
where
nefarious
actor
accidentally
connected
themselves
in
the
memory
pool
and
they
cut
it
out
and
they
put
in
a
different
transaction
to
get
them
together.
So
that's
why
I
mentioned
that
regulators
might
be
interested
to
know.
What's
in
the
pending
troop
pool,
it's
it's
just
some
really
crazy
things
that
go
on.
A
Any
other
questions
great
question
and
I
lost
my
here.
We
go
so
the
third
native
protocol
integration
that's
recently
come
into.
Aetherium
is
graph
QL
for
people
who
do
much
web
development.
This
is
going
to
be
exciting
to
a
lot
of
people.
The
big
thing
that
graph
QL
gets
you
over
json-rpc
or
WebSockets.
Is
you
can
do
bulk
queries?
Let's
say
you
need
to
get
a
thousand
log
entries
from
a
thousand
different
transactions
when
you
need
to
get
a
thousand
different
transactions
in
the
memory
of
those
in
in
JSON
RPC.
A
That
would
be
like
a
thousand
different
calls
and
get
the
overhead
of
starting
up
the
HTTP
transaction
about
putting
in
the
JSON
RPC
of
encoding
it
and
decoding
it
a
thousand
different
times
just
to
do
that,
one
call
with
it
with
graph
QL.
You
can
structure.
The
call
to
say
give
me
from
this
range
and
I.
Do
one
HTTP,
transaction
and
I
do
all
thousand
queries
in
there
and
it
comes
back
all
in
one
bulk.
Query
now
does
the
biggest
advantage
of
graph
QL
has.
A
A
It
gets
out
the
same
data
that
you
can
get
at
in
JSON,
RPC,
all
the
same
access.
Hats
are
there
to
help
you
get
at
the
query
data
one
downside
right
now
is:
there
is
no
way
to
do
static
calls
in
graph
QL,
but
that's
something
that
can
easily
be
fixed
in
the
etherium
improvement
protocol
process.
You
know
if
people
found
a
value
for
it
within
ref
UL.
Generally,
though,
you're
not
gonna
be
doing
bulk
calls.
A
Here's
an
example
of
how
a
graph
QL
log
looks
a
graphical
query,
looks
in
this
case
we're
just
querying
one
log,
because
I
don't
want
to
use
tiny
font
on
the
slide,
so
we
could
do
a
logs
call.
You
want
to
go
from
block
2.2
million
to
2.2
million
with
these
specific
topics,
and
this
specific
topic
happens
to
be
the
ERC
20
transfer
topic
name
on
the
API
encoding
tools.
We'll
get
this
into
the
hash
and
I'd
love
to
talk
about
256
it.
It
masks
it
for
you
typically.
A
But
this
is
what
it
looks
like
on
the
wire.
Then
I
want
to
know
the
topics
and
the
data
associated
with
that
law.
I,
don't
need
to
know
the
address.
I,
don't
know
you
who
it's
from
I,
don't
you
block
through
the
tin
I,
don't
need
to
know
all
the
extra
metadata
I
just
want
to
know
what
the
topics
for
this
call
were
and
what
the
data
were.
So
in
this
case,
it's
a
lot
of
the
data
is
lighted
out,
but
this
was
a.
A
A
Here's
another
example
in
this
case
we're
poking
into
the
account
storage
and
we
query
the
storage
twice
for
the
same
account
poking
it
slot
five
and
then
some
random
slot
that
corresponds
to
the
data.
This
corresponds
to
the
previous
transaction.
That
I
showed
you
know
getting
getting
all
the
data
out
of
where
that
particular
transfer
occurred,
and
here
you
see
in
the
query,
results
you
get
the
balance
and
we
use
a
graph
QL
facility
to
rename
the
fields,
so
they
don't
collide.
A
The
final
feature
I
want
to
talk
about,
and
this
is
unique
to
hyper
ledger
Basu.
We
just
released
it
last
week
with
the
release
of
base
at
1.4
is
the
notion
of
Basu
plugins
and
what
plugins
are
is
these
are
Java
programs
or
Java
jars
that
you
put
directly
into
your
node
and,
as
your
node
runs
it's
going
to
interact
with
the
base
you
node,
one
of
the
one
of
the
pillar
features
we
have
of
those
plugins
is
this?
Has
access
to
the
same
data
that
the
JSON
RPC
api's
can
get
at
to
read?
A
A
A
We
had
had
the
plug-in
data
we
hadn't
publicly
announced
it
had
been
coming
in
the
138
and
137
stuff.
These
people
had
found
that
code
and
they
had
actually
written
an
enterprise
integration
plug-in
without
any
help
from
us
without
any
quality,
documentation,
they're
able
to
read
the
api's
and
they
literally
can
extract
things
into
Kafka
and
PostgreSQL
databases
directly
without
us.
Without
you
know,
I
was
just
amazed
when
I
found
that
like
wow,
so
that
was
that
was
a
wonderful
surprise.
A
So
stuff
like
this
is
in
the
wild
and
it's
being
used
to
to
push
data
into
these
systems.
And
if
you
wanna,
learn
how
to
write
your
own
plugins
watch
the
webinar
there's
a
little
toy
plugin
that
I
wrote.
That's
going
to
take
it's
going
to
publish
events
for
the
gas
usage
which
not
not
very
enterprising,
it's
more
main
nettie,
but
it's
going
to
calculate
and
expose
it
as
a
Prometheus
metric.
A
Any
questions
before
I
go
into
the
demos
great
so
in
this
demo,
I'm
going
to
show
how
I
pull
out
the
ERC
twenty
events
and
because
we're
talking
about
how
to
pull
it
out
of
the
end
of
the
blockchain
for
the
enterprise
integration,
I'm
gonna
use
an
incredibly
simple
enterprise:
integration
console
output.
So
if
you
can
get
step
console
output
and
the
data
you
can
get
it
to
your
own
database,
you
can
get
it
to
your
own
Kafka
event
stream.
A
You
can
get
it
anywhere
that
you
need,
so
these
demos
just
show
the
part
of
getting
an
off
of
off
of
base
soup
into
the
data
that
you
could
then
integrate,
and
when
we're
gonna
pull
out,
I
was
going
to
pull
out
ERC.
Twenty
events
there's
two
that
are
worth
noting.
There
is
the
transfer
where
I'm
transferring
from
an
account
to
another
account
and
then
there's
approval
where
you
approve
someone
to
spend
money
on
your
behalf.
A
I'm
gonna
do
pull
as
via
web
3j,
both
web
sockets
and
JSON
RPC,
and
the
push
is
gonna,
be
through
basic
plugins
and
I
have
a
link
here
that
I
just
published
the
code
this
morning
for
my
demos,
so
we're
gonna
see
what
goes
on
with
that.
So,
let's
go
to
the
demo
screen
now,
as
I
mentioned,
this
is
using
web
3j
to
do
the
integration.
This
is
web
3
labs
out
of
Europe,
some
European
country
and
EU
that
they
wrote
all
this.
It's
really
nice
stuff,
I'm
in
volume.
A
I
think
is
one
of
the
authors
of
this
he's
one
of
the
committers
in
Basu,
and
this
is
a
very
simple
integration
showing
how
all
you
need
to
do
is
point
it
at
the
end
point
and
we're
gonna
get
the
block
number
in
the
request
and
it
uses
reactive
rx.
You
know
some
really
fancy
programming
stuff
to
do
flow
bowls,
as
these
data
comes
in,
we
just
log
the
events
so
it
produces.
You
know
we
get
the
the
event
logs.
It
produces.
A
nice
format,
object.
A
Allah,
God
yep,
object
that
wraps
around
all
the
complex
wire
protocol.
Stuff
says
you
don't
have
to
worry
about
it.
You
look
to
see
if
the
protocol
we
get
the
value
of
the
token
assemble
and
address,
and
here
we're
actually
querying
the
ERC
20
contract,
so
create
an
object
representing
the
specific
GRC
20
contract
that
we've
learned
about
from
the
events,
and
we
ask
for
its
name
and
its
symbol.
Let
me
get
the
from
address
and
a
to
address.
Then
we
print
it
out.
So
we
make
sure
that
my
node
is
running.
A
A
So
this
is
gonna
run
against
the
10th
last
ten
blocks,
see
if
it's
yes,
there
is,
we
got
lucky,
there's
actually
some
interesting
stuff
that
happen
in
the
last
ten
blocks
test
token
sent
several
things,
and
so
one
of
the
things
I
integrated
in
here
we
got
Splunk
in
the
room
they
did.
They
did
a
recent
integration
with
aetherium
into
their
their
work
and
one
of
things
they
did
is
they
posted.
They
had
a
list
of
every
single
possible
smart
contract
event
that
they
could
divide
from
the
source
code.
A
A
I
know
that
this
is
a
deposit
going
from
from
one
place
to
the
other,
with
the
value
of
five
five
five
again
Gourley
is
a
test
network
and
there
is
a
conference
going
on
in
Paris
right
now,
so
I'm
sure
they
are
doing
a
lot
of
tests
and
a
lot
of
demonstrations
for
a
lot
of
these
random
test
tokens.
So
we
could
monitor
this.
You
know
there
in
Paris,
where
regulator
we're
just
reading
their
tokens,
seeing
where
they're
going
and
seeing
what
they're
doing
or
I'm
an
auditor
for
my
own
company.
A
So
the
next
demo
is
WebSockets
and
it's
a
lot
of
the
same
stuff
just
done
with
a
different
way
to
run
it.
We
have
a
different
URL,
so
WebSockets
we
connect
a
little
bit
differently
and
the
log
events
is
mostly
the
same.
We
get
the
event
from
the
WebSocket,
we
run
the
same
queries
to
get
at
the
data.
A
And
we
print
out
the
same
results,
the
information,
so
this
WebSockets,
of
course,
because
I've
been
up
and
down
on
the
Wi-Fi
networks,
has
stopped
working
because
it's
a
persistent
connection
but
as
I
turn,
this
on
it's
gonna
start
getting
results
as
the
blocks
roll,
then,
which
is
kind
of
every
15
seconds.
So
we'll
leave
this
here
on
this
screen,
while
I
briefly
talk
about
the
base
you
plug
in
and
the
base
you
plug
in
is
another
format
is,
is
a
file
thing,
and
this
is
copied
from
my
demo
thing.
A
The
start
events
method
will
be
called
on
the
base
of
service.
So
when
we
start
the
events,
we
got
an
event.
Log
listener
we're
gonna,
listen
to
just
the
transfer
API
and
we
get
it.
We
run
our
log
event
method.
So
we
get
that
we
do
the
transfer,
ID
bytes
and
we
do
the
same
sort
of
an
integrate
on
the
backend
here,
and
this
has
been
running
for
a
bit
more
stable
how
to
restart
it
because
of
the
again
the
wireless
network
connections.
This
has
been
running
on
the
back
end.
A
If
I
were
to
stop
this
for
about
10
minutes,
one
of
the
cool
things.
If
I
stop
this
and
I
bring
it
back
up.
As
the
data
comes
in
its
gonna
roll
as
it's
sinking
to
the
blockchain,
it's
gonna
get
all
that
data
as
part
of
the
plug
in
getting
that
startup
window
from
when
you
bring
up
a
node
and
it's
catching
up
to
the
end.
It
can
be
tricky
if
you're
doing
just
querying
trying
to
get
stuff
as
it's
coming
in.
A
A
Are
there
what
are
there
upgrades
other
languages?
Yes,
yes,
there
are
other
languages.
This
demo
was
written
in
Java
because
it
was
the
easiest
one
for
me
to
get
out
of
the
time.
You
can
do
these
exact
same
integrations.
Well,
it
can't
do
the
plug-in
integration.
There
we
go.
A
block.
Just
came
in
the
plug-in.
You
can't
do
the
plug-in
integration
in
Java
right
in
anything
but
Java,
but
the
JSON
RPC
and
the
WebSockets
you
can
use
JavaScript
you
can
use,
go.
You
can
use
C++,
you
can
use
Python.
A
A
A
Sync,
it's
a
technique
that
allows
you
to
validate
nodes
on
the
blockchain
without
needing
to
have
either
the
full
head
of
the
memory
which
is
about
you
need
about
200
gigs
to
do
that,
to
300
gigs,
depending
upon
your
system
or
the
full
history
which
I
think
is
up
to
3
terabytes,
and
it
takes
you
know,
hours
to
sync
up
with
beam.
Sync
you
can
get
synced
in
about
15
seconds.
A
I
think
is
what
their
demo
was
is
what
another
mine
did:
you're,
not
seeking
up
the
whole
blockchain,
but
you're
just
getting
enough
data
to
prove
that
the
block
you
just
received
has
all
the
data
it
needs
and
it's
leaving
a
bigger
effort
in
etherium
called
stateless
etherium,
which
is
how
they're
really
trying
to
address
the
state
load
issue
right
now
to
run
an
aetherium
node.
You
need
to
have
at
least
the
current
head
block
state
of
everything
to
assemble
something
called
the
state
tree.
A
You
need
this
hash
up
all
the
state
values
you
need
to
build
some
patrícia
tree
and
it
takes
a
lot
of
data
to
do
to
produce
that.
So
what
they're
producing
with
that
is
something
called
witnesses.
So
each
block
will
come
with
a
witness
and
it'll
have
all
the
data
that
you
need
to
execute
it
in
all
of
the
sibling
data
that
you
need
to
build
the
tree.
A
The
way
that
the
theorem
builds
its
state
is
a
variation
of
a
Merkel
tree
or
patricia
tree,
where
you
push
things
down
to
a
certain
level,
and
then
you
hash,
two
of
them
together
or
16
of
them
together,
depending
upon
whether
it's
a
Merkel
or
Patricia,
and
then
you
go
up
another
level.
Any
hash.
16
of
them-
and
you
go
up
another
level
and
they
come
up
with
one
number
and
with
that
hashing
along
the
tree,
you
don't
need
to
know
the
entire
depth
of
the
branches
of
all
the
ends.
A
You
just
need
to
know
the
data
where
that
tree
joints
to
produce
that
hash
and
that's
how
they
can
produce
that
really
skinny
stateless
tree
of
about
you
know
kilobytes
to
prove
a
block
instead
of
gigabytes.
So
that's
something
I'm
really
excited
about
and
hope.
We
have
good
news
about
that
by
the
end
of
the
year.
A
Right
one
less
process,
so
it
runs
in
the
node
process.
If
you're
doing
json-rpc,
you
need
to
stand
up
the
node
performance,
you
get
a
performance
gain,
it's
a
lot
closer
to
there
as
well.
It's
push
based
with
a
separate
process.
You
need
a
pull,
you
need
a
query
it
or
you
need
to
set
up
a
stateless,
WebSocket
connection
and
hope
that
you
got
all
the
data,
so
the
real
advantage
of
doing
in
the
plug-in.
Is
you
get
rid
of
another
process?
You
get
rid
of
another
thing.
A
You
have
to
monitor
and
make
sure
it's
connected,
make
sure
it's
set
up
and
brings
it
into
the
process
and
you
can
push
it
out.
So
that's
that's!
It's
only
one
of
the
three
pillars
of
the
plugins
things.
Another
thing
we're
letting
people
do
with
plugins
we've
started
with
the
database.
You
can
replace
the
database
if
you
can
provide
all
the
api's.
We
have
a
product
that
does
that
for
encrypted
databases,
if
you're
really
into
encrypted
data.
At
rest,
we
have
an
example
of
that
actually
working.
A
There
is
other
databases
we're
looking
at
for
performance
reasons
that
have
different
trade-offs.
Yahoo's
got
one
or
both
is
their
name
called
halo
DB
that
keeps
the
index
in
memory
and
if
you
can
get
like,
you
know,
200
gigabytes
of
memory
on
your
system
and
it's
important
to
you
for
trading.
It's
an
incredibly
fast
database,
but
I,
don't
know
many
people
at
home
that
have
200
gigabytes
sitting
on
their
VR
rig.
A
So
that's
some
of
the
things
that
the
plugins
gives
you
is
more
options
to
change
out.
Some
of
these
pieces
parts
looking
way
down
the
horizon.
I
could
totally
see
us
using
the
plug-in
API
to
put
in
different
execution
environments.
If
there's
a
standardized,
wasum
sort
of
execution
environment
we
could
print
and
stuff
for
that.
If
we
need
new
specialized
precompile
contracts,
you
could
use
a
plugin
so
and
put
in
those
precompiled
contracts,
something
like
microing
level
of
hierarchy.
A
If
you
want
to
query
from
a
newsfeed
and
you
have
to
go
to
the
network,
you
could
wrap
that
up
in
a
pre
compile
contract.
Those
are
the
sorts
of
things
that
the
plug-in
enables
is
getting
more
advanced
features
into
the
nodes,
and
that's
we
just
started
with
the
plugins
just
started,
exploring
with
all
the
features,
because
we
don't
really
believe
that
you
know
a
single
node
is
going
to
be
in
there.
One
size
fits
all.
It's
gonna
need
to
have
some
mechanism
for
customization
and
plugins
is
our
vision
for
providing
that
musician.