►
From YouTube: XBOM (eXtensible Blockchain Object Model) on Hyperledger
Description
A virtual meetup hosted by Hyperledger NYC featuring David Beberman, Chief Technology Officer and Architect of XBOM as he walks through how XBOM (eXtensible Blockchain Object Model) can change the scope of projects developed on HyperLedger and how they can be written using our Class Management Infrastructure. This session will cover our newest XBOM update demonstrating XBOM on HLF show how accounts and code will be stored and inherited directly from the Accounts running on Hyperledger.
More about the event is at: https://www.meetup.com/Hyperledger-NYC/events/276383442/
----
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 #HyperledgerMeetups #Blockchain
B
B
A
B
A
C
C
The
overall
project
is
for
an
open,
permissionless
chain
that
we
are
now
doing
a
raise
for
through
a
token
sale.
The
other
side
of
this
started
out
as
a
proof
of
concept
for
one
specific
aspect
of
our
technology
and
that's
what
we're
going
to
talk
about
today,
which
is
the
extensible
blockchain
object
model.
Just
real,
quick
history,
extensible
blockchain
object
model
is
actually
a
first
class
object
model.
C
It's
it's
a
proven
architecture
for
operating
systems
for
five
decades,
now,
almost
six
and
what
it
it's
the
same,
underlying
functional
architecture,
although
they
were
modified
of
both
mac,
os,
10
and
of
windows,
and
what
we've
done
is
created
a
way
to
decentralize
a
first
class
object
model
which
will
allow
us
to
create
a
single
instance
class
tree
on
the
open
chain.
It'll,
be
permission,
it'll,
be
a
single
instance
globally
on
hyper
ledger.
C
We're
looking
at
each
chain,
of
course,
would
have
their
own
global
tree
for
all
of
the
suppliers
and
and
all
those
associated
with
that
those
specific
chains.
So
we'll
jump
right
into
this.
We
call
we
call
it
beyond
smart
contracts,
because
that's
exactly
what
we're
doing
is
going
beyond
smart
contracts.
C
So
let
me
make
sure
I'm
working
here
there
we
go
so
the
first
thing
is
is
chain
code
and
the
issues
that
we
we
discovered
are
the
same
exact
issues
that
are
sitting
in
in
smart
contracts
as
well.
They're,
static,
they're,
not
dynamic
chain
code
and
smart
contracts
are
not
easily
created
or
updated.
They
you
can
create
a
very
simple
transactions.
In
fact,
some
of
the
individual,
in
the
conversations
we've
been
in,
are
specifically
around
the
fact
that
they
haven't
gone
past.
C
Second,
it
can
take
years
to
create
and
deploy
multiple
fte
years,
depending
on
how
many
people
you
have
to
have
on
there
and
what
the
complexity
of
it
is.
The
code
requires
reloading
for
each
new
contract.
You
have
to
turn
up
another
chain
or
you
have
to
take
down
all
nodes
and
then
re
restart
them
with
the
new
contract.
I
know
that
in
two
I
believe
and
dave
can
talk
about
this
a
little
better
in
hlf,
2.0
and
above
there's
supposed
to
be
a
way
to
dynamically.
C
Add
chain
code,
but
I
don't
we
haven't
heard
of
anybody
actually
doing
that
yet
and
then
sec.
The
last
thing
is
code,
has
no
global
repository,
so
you're.
What
you're
doing
is
you're
going
and
copying
you're
finding
a
smart
contractor
chain
code
somewhere
copying
that
putting
it
into
paste
it
into
a
text
editor,
making
your
edits
and
then
uploading
that
chain
code.
Well,
that's
the
same
as
writing.
C
The
word
application
every
time
you
want
to
write
a
word
document
and
we
don't
agree
that
that's
a
efficient
way
to
run
so
x-bomb
the
extensible
blockchain
object
model.
We
came
on
to
hyperledger
for
two
reasons.
For
one
reason,
one
reason
was
to
prove
out
the
underlying
technology
that
we
could
yes
create,
accounts
which
all
blockchains
have
accounts,
but
we
could
actually
instantiate
objects
inside
those
accounts
or
assets
inside
those
accounts.
C
C
The
first
review
we've
had
on
this
was
from
casey
tam
and
he's
a
well-known
instructor
and
hyper
ledger,
and
he
does
he's
done
some
on
x-bomb
he's
done.
Damo
he's
done,
other
types
of
reviews
and
such
and
what
he
came
down
to
was
the
pa.
The
the
fact
that,
theoretically,
the
developer
does
not
care
about
the
blockchain
as
it's
well
handled
by
the
infrastructure
and
the
infrastructure.
C
So
as
the
as
the
the
the
cmi,
the
content,
man,
the
class
manager
infrastructure
advances
in
the
development
cycle
and
we
add
more
integration
pieces
to
it.
It'll
at
some
point.
We
won't
care
what
up?
What
programming
language
you
write
your
classes
in
your
op,
your
applications,
you're
in
it
will
just
run
on
the
black
on
the
on
the
blockchain
and,
in
this
case
hyperledger
right
now.
It
is
all
written
and
go
because
that's
what
it
was
and
we
were
here
to
not
change.
C
Anything
dave
will
have
stories
on
go
okay,
so
why
this?
What
does
it
do?
Well,
first
of
all,
it
makes
go
to
market
10x
faster.
We
actually
expect
it
to
be
much
more
you're,
no
longer
copying
and
and
editing
and
pasting
you're
instantiating
code,
an
object
from
a
class.
That's
resides,
live
on
the
blockchain
you're
instantiating,
that
into
your
account
and
you're,
changing
the
parameters
or
values
of
it.
What
kind
of
asset
is
it
it's
a?
It
could
be
a
spark
plug
and
there's
a
this
bin.
C
Has
you
know
a
500
million
spark
plug
in
it?
You
want
to
fractionalize
those
out
to
your
supply
chain.
You
know
whatever
it
is.
It's
again,
you're
just
instantiating
the
code
that
everybody
else
is
using.
So
what
that
also
does.
Is
it
moves
away
from
a
lot
of
the
issues
or
mitigates
a
lot
of
the
issues
with
bugs
and
malicious
code
being
actually
put
into
into
the
blockchain
and
into
your
systems?
C
It's
real-time
updates
with
no
service
interruptions
and
dave
is
going
to
show
you
actually
how
code
is
good.
Our
accounts
are
going
to
be
loaded,
how
objects
will
be
loaded
into
accounts
and
how
assets
can
be
fractionalized
and
transferred
from
one
account
to
the
other,
without
writing
a
smart
contract,
and
then
it
creates
a
repository
of
reusable
code.
C
C
What
this
allows
is
the
supplier
now
can
have
all
of
the
classes
from
any
of
the
different
hyperledger
fabric
chains
from
any
of
the
different.
You
know
the
ibm
blockchain
platform,
oracle
blockchain
platform,
whichever
it
the
xbox,
doesn't
care
who
owns
it
or
whose
platform
it
is.
It
just
cares
that
it's
hyperledger,
so
it's
a
way
to
now
have
the
down
stream
supplier
have
a
more
efficient
and
cost
effective
way
of
working
with
their
upstream
suppliers
or
vendor
customers.
C
There
are
six
layers
to
it,
of
course,
the
bottom
layers
and
nodes,
the
second
layer,
is
a
blockchain
in
this
instance
that
we're
going
to
be
showing
it's
hyperledger.
Then
you
have
your
class
manager
infrastructure
and
that's
that
integration
between
classes
and
objects
and
and
blockchain.
That's
what
allows
the
two
to
talk
to
each
other
and
xbomb
classes
and
objects.
C
And
then
there
will
be
times
when
developers,
whether
these
core
developers
or
or
other
developers
want
to
expand
within
those
classes
and
such
so.
The
developers
could
integrate
within
that
layer
or
interact
within
that
layer
of
x-bomb
classes
and
objects.
This
then
layer,
two
is
the
application
developers.
This
is
where
most
of
them
will
hang
out
and
again
what
we're
doing
is
opening
up
a
breadth
of
the
breadth
of
the
the
developer
world,
because
it
does,
they
don't
have
to
know
solidity
anymore.
They
don't
have
to
know,
go
lane.
C
They
don't
have
to
know
the
underlying
develop
the
underlying
technology
of
the
blockchain.
They
just
have
to
know
how
to
work
with
classes
and
objects
in
the
first
class
object
model
which
will
just
be
in
education
and,
of
course
the
applications
is
a
top
layer,
so
the
users
and
application
developers
don't
know
anything
or
don't
have
to
know
anything
from
layer.
Three
down
we
and
we've
created
that
ease
of
development
and
use.
C
Go
into
the
on
the
the
first
presentation
we
did
for
hyperledger
india,
which
talks
about
and
shows
the
functionality
of
the
actual
class
manager
infrastructure,
how
that
loads
into
hyperledger
and
loads.
All
the
p
on
all
the
nodes
and
such
what
dave
is
going
to
go
into
is
actually
more
on
these
lines.
C
Where
we're
going
to
the
blockchain
will
be
up,
the
hyperledger
will
be
up,
the
nodes
will
be
up
and
we'll
show
how
classes
are
created
and
instantiated
in
accounts
and
then
making
transfers
you
can
go
to
xbomb.io,
and
at
that
point
we
have
three
videos
at
the
bottom
of
the
overview
link
that
go
deep
into
the
actual.
The
first
part
of
this.
What
is
a
class
mod?
C
What
is
a
first
class
object
model,
how
do
objects
and
classes
the
concept
work
within
a
blockchain
and
and
then,
of
course,
the
the
inspector
so
that
you
can
get
all
class
information
object,
information
from
the
tree,
and
I
will
go
ahead
and
pass
this
over
to
dave
now.
If
anybody
has
any
questions,
please
ask
real
quickly:
it
is
a
for
the
developers.
All
class
build
code
is
open
source.
C
C
Ours
is
just
on
the
cmi
and
then
just
corky
and
I'll
leave
this
up
for
a
second,
because
you
can
reach
out
to
corki
absolutely
on
any
information
going
on
he's
our
our
cro
chief
relationship
officer,
chief
chief
revenue
officer,
but
we're
not
for
profit.
So
we
call
them
relationships
right
and
all
the
information
is
there
and
we'll
put
this
screen
up
again
at
the
end,
so
I'll
end
it
there
and
if
there's
any
questions
before
dave
starts,
please
do
ask.
B
Okay,
so
come
up
all
right,
so
what
mike
just
said,
the
one
of
the
core
pieces
here
is
that
a
lot
of
this
will
make
sense
if
you've
seen
the
earlier
videos.
I've
done
a
voice
over
talking
through
just
basically
how
the
system
comes
up.
The
class
major
infrastructure
is
loaded
that
type
of
thing
for
background.
Since
everybody's
used
to
the
term
chain
code,
the
class
manager
infrastructure
is
the
chain
code
it
loads
as
chain
code.
B
Everything
else
is
then
dynamically
loaded
as
shared
objects
into
that
environment
on
demand,
and
this
is
a
big
difference
from
just
running
chain
code.
If
anybody
wants
to
really
get
into
goaling
to
figure
out
how
to
do
that,
that's
an
interesting
problem
that
we
worked
out,
but
it
does
work
now
I
mean
it's
pretty
stable.
B
B
B
B
Then
these
are
actual
shared
objects
that
have
been
loaded
into
the
environment
on
top
of
their
class.
Major
infrastructure
as
part
of
the
init,
which
is
kind
of
you
have
to
bootstrap
somewhere
before
we
go
into
further
class
object,
is
the
root
of
all
objects
right
now.
This
is
a
single
inheritance
where
you
can
do
abstract
classes
and
interfaces.
B
We
haven't
implemented
a
multiple
inheritance,
but
we
will
eventually
class
x
bomb
is
the
root
for
all
x
bomb
classes.
Class
x,
bump
container
is
the
it's
like
a
think
of
it.
Like
a
window
container,
you
put
object,
you
know
you
put
a
window
layer,
windowed
environment,
so
each
window
contains
child
windows
so
on.
So
this
is
the
object
that
you
inherit
from
that
could
contain
other
objects,
classic
count
inherits
directly
from
class
xbox
container
to
actually
implement
that
containment
model.
B
So
what
we're
going
to
do
is
we're
going
to
create
we're
going
to
load
a
new
class
called
class
fungible
asset,
oh
by
one
once
they're
loaded
into
the
environment,
everybody
can
use
them.
It's
set
up
that
the
classes
are
now
part
of
the
blockchain
they're,
not
and
they're
loaded
dynamically.
At
each
node
for
any
transaction
use,
it
might
say,
use
inheritance
from
up
some
classes.
It
will
go
pull
them
into
the
environment,
so
it
can
run.
So
that's
that's.
B
A
key
point
here
is
that
you
think
of
these
each
one
of
these
each
one
of
these
shared
objects
is
completely
separate
on
the
blockchain
and
maintains
inheritance
through
them.
So
we're
going
to
create
we're
going
to
load
a
class,
I'm
going
to
create
an
instance
of
that
which
is
a
first
one
called
asset
1,
because
it
doesn't
have
a
name,
I'm
going
to
create
a
I'm
going
to
take
that
asset
and
I'm
going
to
create
another
object
where
it
takes
something
from
this
assets
started
with
20
20
count
and
now
there's
15
in
five.
B
B
So
what
happens
if
this
is
literally
the
concept
of
moving
assets
back
and
forth
and
adding
and
subtracting
the
way
we've
set
this
up
right
now
for
class
fungible
asset.
Is
that
once
it's
instantiated,
once
you
instantiate
an
object,
the
total
account
is
fixed.
So,
no
matter
how
many
times
you
transfer
assets
around
the
total
number
of
assets
will
always
stay
the
same.
That's
kind
of
like
a
tge
on
a
smart
contract
type
thing
then
going
to
do
something
a
bit
more.
We
subclassed
class
fungible
asset,
that's
actually
written
wrong.
B
B
In
this
case,
we
can
also,
then,
give
them
an
internal
name,
that's
hidden
from
everybody
that
makes
sure
that
they're
unique
so
that
when
I
do
this
and
create
another
acid
of
it,
so
then
I've
taken,
you
know
seven
and
put
them
in
here.
These
are
completely
separate
from
anything
from
say
another
acid
name.
Okay,
that's
basically
it
now.
What
I'll
do
is
walk
to
show
you
a
bunch
of
scripts,
to
do
that
now
we
are
doing
all
of
this
from
the
command
line
using
the
pure
node.
B
This
is
all
json,
though,
there's
nothing
wrong
with
running
this
to
a
you
know,
you
could
use
a
json
interface
for
it.
The
existing
libraries
for
for
hyperledger
would
work
with
it.
The
other
important
thing
which
I'm
not
going
to
demo
here,
because
it's
in
one
of
the
other
videos,
is
that,
as
you
load,
new
classes,
you're
actually
creating
new
api.
B
So
it's
similar
to
the
open
api
capability.
You
can
inspect
a
class
an
object
rather
it'll
give
you
all
its
class
ancestry
in
all
of
the
input
and
output
arguments
and
methods,
so
you
can
send
on
them
now
the
the
only
the
dot
it's
it's
a
gives
you
full
scheme.
In
other
words,
the
only
downside
to
that
schema
is
that
we
it's
not
conforming
to
the
open
api
right
now,
but
we'll
make
it
do
that
in
the
future.
B
B
You
can't
run
it
internally
because
the
way
that
the
at
least
the
one
point
x
version
built
the
chain
code
is
that
it
would
force
a
vendor
operation
and
it
was
doing
it
by
hand,
and
you
can't
do
that
and
make
the
shared
objects
work
correctly
with
the
goling,
because
there's
conflicts
with
the
package
names
and
that's
just
it's
nothing
to
do
with
hyperledger
at
all.
It's
just
a
go
laying
limitation,
so
we
use
the
external
builder
approach
and
we
launch
it
that
way
with
a
handful
of
scripts.
B
B
B
Or
object
id
sitting
over
here
is
actually
the
other.
This
is
saying
what
object
to
send
it
to
the
way
the
pro
the
way
the
transactions
work.
Is
you
always
specify
the
account
that
you're
sending
a
transaction
to
and
the
object
in
the
account
that
you
wanted
to
do
and
then
you're
sending
it
the
method
that
you
wanted
to
call
and
the
parameters
the
parameters
are
done
explicitly
as
json,
because
I'm
doing
internally
is
using
json
decode
to
take
these
strings
out.
Decode
them.
B
So
it
does
a
straight
call:
returns
output
and
it
now
says
I've
created
a
new
I've
loaded,
a
new
class
when
you
load
the
class
library
there's
a
function
that
it
calls
called,
create
objects
where
it'll
create
new
classes,
it's
all
in
the
source
code,
and
you
can
see
examples
of
that
in
the
gitlab
sources.
Although
these
classes
have
not
been
up
there
yet
I
will
be
uploading
them
and
adding
to
the
readme
there,
but
all
the
basic
functionality
is
the
same.
It's
just
implementation
pieces
and
so
I've
now
created
a
the
fungible
assets.
B
So
in
this
slide
we
are
here.
I
haven't
created
the
asset.
Yet
I'm
about
to
do
that,
and
that
is
you'll
notice,
that
it
says
new
object,
acid
count
over
here
and
it
actually
wraps
around,
but
I'm
going
to
create
20
of
them.
So
it's
as
though
you
know
that
could
be.
You
know,
you
know
a
million
count
of
whatever
you
wanted
it
to
be.
It
could
represent
anything
from
you
know:
screws
from
a
screw
factory
to
financial
assets.
B
And
it
just
says:
I
created
a
new
object:
here's
the
new
object.
So
now
that's
an
object
instance.
So
I've
instantiated
an
object
from
a
class.
Remember
it's
a
first
class
object
model,
so
the
classes
are
actually
objects
as
well,
so
we
actually
did.
Is
they
sent
a
message
to
the
class
to
create
an
object?
B
So
that's
how
that
works?
There's
a
meta
class
actually
in
this
environment
called
class
class,
which
is
also
subclassical.
So
you
can
create
your
own
classes
that
create
classes.
If
you
really
want
to
there's
reasons
to
do
that,
I'm
going
to
prove
that
the
numbers
are
currently
in
here.
So
I'm
going
to
ask
it
I'll.
Do
it
this
way?
First,
I'm
going
to
ask
it
what
its
current
count
is,
calling
that
method.
B
Turn
going
to
put
this
windowed
a
little
higher
and
you'll
notice
that
it
returned
and
here's
what's
returning
the
json
syntax
in
the
parameter
was
asset
count.
It's
actually
what
is
in
the
output
argument,
data
structure,
if
you
dumped
out
the
schema
and,
of
course,
equals
20.
So
this
now
works
so
now.
The
next
thing
is,
I
want
to
take
that
asset
and
I
want
to
create.
B
I
want
to
take
some
of
it
away
and
put
it
in
another
object,
so
I
can
take
that
object
and
put
in
another
account
so
that
I
have
a
you
know,
so
we
have
a
way
to
move
assets
around.
So
the
first
thing
you
need
to
do
is
be
able
to
make
a
copy
of
it
with
a
new
asset
count
and
that's
when,
with
a
subtracting
out
the
accounts
from
the
previous
one
and
adding
to
it,
and
that's
this
call
whoops.
B
I
think
this
sorry,
you
know
that's
here's
the
new
acid
method
right
there
it's
going
to
make
it
one
from
five
and
I'm
giving
it
the
object,
I'm
sending
it
now
to
the
object.
They
just
created
the
acid
they
just
created.
Rather,
you
can
see
this
number
if
you
appears
a
piece
of
it
here.
Here's
the
same
number
here.
B
And
it
made
a
new
object,
so
we
now
have
this
so
so
far.
I've
loaded
class
code,
I'm
just
using
it
dynamically
loaded
else,
it's
currently
being
loaded
by
the
way
from
a
path
to
a
file
system,
but
there's
no
reason
why
that
can't
be
set
up
as
a
url
or
a
search
of
a
url.
You
could
have
you
know
multiple
locations
for
backup
for
prototype
purposes.
B
B
B
B
B
Okay,
so
now
what
I'm
going
to
do
is
create
the
account
that
it's
in
so,
as
I
said,
the
first
account
already
exists.
I
just
didn't
put
in
the
diagram,
but
I'm
now
going
to
create
this.
I
need
an
account
to
put
the
objects
in,
so
I'm
going
to
create
one.
Obviously
you
would
have
one,
but
for
demo,
I'm
just
running
it
through,
and
you
know
the
yeah.
B
B
B
B
And
it's
going
to
return
back
here.
It
is
what
I'm
going
to
do
later
is
show
you
actually
ends
up
with.
I
had
more
than
one
type
of
asset
into
the
same
account.
The
nice
part
about
that
is,
there's
nothing
in
the
containment
relationship.
That
says
I
can
only
have
one
asset
or
one
type
of
object
that
I
can
put
anything
I
want,
so
you
can
create
all
sorts
of
protocols.
B
B
Go
shared
objects,
then
the
so
that
they're,
not
it's
not
part
of
the
tar
dot,
zip
for
doing
the
doing
the
external
build.
It's
not
built
internally,
they're
literally
just
externally
available
at
the
moment.
I
don't
do
anything
that
verifies
hash.
You
know
to
verify
that
it's
valid
code
or
anything
it's
not
been
tampered
with,
but
it's
easy
enough
to
do.
B
B
Those
so
here
I'm
going
to
create
one
called
dgt,
here's
the
asset
type,
which
is
part
of
the
class
smart
asset,
but
it
also
inherits
from
class
asset.
So
I
have
another
parameter
here
for
setting
it
to
the
count
to
20
on
this
one.
If
you'll
notice,
these
numbers
are
saying
here's
the
class
that
I
want
to
in
the
initializer
in
the
parameters
for
it,
the
ancestors
and
here's
another
class
that
inherits
from
and
the
parameters.
B
B
As
you,
if
you
watch
through
the
videos,
the
other
things
will
explain
that
this
is
actually
being
written
out
to
the
database
and
it's
using
these
numbers.
The
ledger
object
ids
as
the
keys
to
the
database,
so
I
just
created
a
new
object:
that's
of
class
smart
asset
with
dgt
of
20,
and
that's
right
here,
the
screen
guy,
and
where
are
we
and
let's
create
the
other
one?
B
You
know
I
made
up
a
name
called
wrap
teeth.
The
these
these
string
names.
That's
that
field.
For
this
you
know
this
is
a
demo,
but
that's
just
a
a
string
field
could
be
anything
you
want
in
there.
I
didn't
I
didn't
it's.
It's
an
unformatted
string.
Of
course
you
could
subclass
this
and
put
any
sort
of
format
you
want
in
there
as
well.
B
B
B
So
I'm
going
to
go
show
that
I
just
created
the
acid
types
so
that
you
can
now
ask
the
smart
asset.
What
are
you
it's
going
to
tell
you
that
this
one
is
a
dgt,
okay
and
we're
going
to
do
the
other
one
which
is
going
to
tell
you
that
it's
wrapped,
but
these
are
arbitrary
strings
and
somebody
could
try
to
you
know
make
more
than
one
of
these
and
then
you
get
into
all
sorts
of
funky
behaviors
and
lying
coins
and
all
that
type
of
thing.
So
internally
they
have
a
ledger.
B
Object
ledger
object,
id
that
I'm
calling
a
uid
for
unique
identifier,
and
so
let's
ask
it
for
that,
and
here
it
is
here's
its
number,
and
this
is
an
internal
number.
It's
not
an
object.
It's
just
a
number,
that's
unique
among
all
objects
in
every
other
id,
because
I'm
comparing
it
against
everything
else
to
guarantee
it's
unique.
B
A
A
B
In
a
network
of
native
hybrid
cloud,
server,
network
of
nodes,
native,
hybrid
or
those
free
global
infrastructure,
if
we
have
cloud
foundry
replacing
network,
obviously
what
may
be
cloud
foundry
as
in
the
company,
is
pivotal
interesting,
so
you're
talking
about
containers
and
you're
running
docker
images
and
containers
that
works.
Fine,
the
I'm
not
sure.
If
you're
asking
for
the
architectural
change
to
hyper
ledger
because
there's
none.
This
is
strictly
a
configuration
in
your
loading
chain
code.
B
Everything
else
works,
as
is
until
you
start,
of
course
doing
these
types
of
messaging,
so
literally
you're
just
running
hyperledger.
It
does
have
to
be
2.0
and
above
and
there's
a
couple
of
configuration
issues.
One
of
them
is
that
your
underlying
operating
system,
the
default
for
hyperledger,
at
least
in
the
open
source,
is
using
a
a
very,
very
limited
linux
version
that
doesn't
have
shared
object.
Loading
you
have
to
replace
that
in
the
docker
image,
with
an
actual
one
that
will
do
shared
object
loading,
otherwise
it
can't
do
it.
B
The
other
thing
you
have
to
do
is
set
the
config.yml
to
use
external
chaincode,
the
there's
a
model
for
that
other
than
that
you
can
see
the
rest
of
it
in
my
in
the
get
lab
for
it.
That's
basically
about
it.
If
you're
running
your
hyper
ledger,
construct
with
cloud
foundry
and
rolling
out
containers
that
way,
you'll
whatever
consensus,
are
we
going
to
be
using
as
long
as
it
works?
We'll
work?
Fine,
because
we're
sitting
on
top
of
that?
B
B
One
of
them
wasn't
actually
ready,
yet
they
were
running
a
one
point
x
and
unfortunately
you
can't
do
external
chain
code,
one
point
x,
so
it
couldn't
get
around
it
and
as
you
go
to
2.0
you
two
point
x
and
beyond,
you
can.
Oh
somebody
else
responded
and
real
quickly.
I'm
just
showing
that
these
before
I
get
through
that
the
two
uids
are
completely
different
from
each
other,
here's
the
other
one.
B
B
To
hell
with
that,
in
any
case,
they're
different,
I'm
not
going
to
waste
the
time
with
that.
Okay
did
somebody
else.
Somebody
think
asked
a
question
and
then
it
yeah
there.
It
is
I'm
a
rot.
I'm
a
rookie
headphones.
What
are
the
numbers,
and
the
arguments
mean?
Oh,
so
these
are
not
specific
to
hyperledger
they're
specific
to
the
class
major
infrastructure
chain
code.
We
create
a
unique
identifier.
B
We
like
we
call
it
a
ledger,
object
id
your
first
reach
for
each
object,
whether
it's
a
class
or
an
object,
an
instance
of
a
class
which
is
an
object.
You
need
some
way
to
reference
it.
So
the
database
model
for
hyperledger
uses
a
key.
You
know
keyword
and
key
value
capability.
Leveldb.
Does
that
couchdb?
Does
that
as
well?
Custody
does
a
few
other
things
we're
not
using
what
we
did
is
we
set
the
key
to
be
this
value?
B
Okay
and
it's
being
printed
out
in
json
syntax
as
an
array,
but
each
one
of
these
is
byte,
I'm
sorry,
it's
256,
so
it's
yeah,
32
bytes.
So
it's
a
32
byte,
now
32
byte
number
using
the
secure
hash
sha-256,
which
is
the
standard
way
to
do
a
low
collision
hash
capability,
and
so
I'm
just
chaining
for
everyone.
What
happens
is
given
the
previous
hash
number.
You
use
that
to
generate
the
next
hash
number
that's
going
on
internally
and
then
it's
guaranteeing
it's
unique.
B
B
B
That's
one
of
the
that's
actually
one
of
the
core
pieces
that
make
this
possible.
Without
that
you
can't
you.
Without
that
you
don't
you
can't
guarantee
uniqueness
and
therefore
you
don't
know
what
you're
sending
messages
to
okay,
I'm
going
to
then
prove
that
the
assets
are
there.
This
is
the
get
asset
count
and
the
new
the
newer
smart
assets.
B
The
thing
about
this
is
once
you,
the
nice
part,
is
once
you
create
the
code
and
load
it
anybody
loads.
It
everybody
uses
it.
So
you
don't
you
only
in
general,
you
assume
that
we'll
have
a
large
enough
environment
of
classes
already
on
the
blockchain,
so
your
job
really
is
to
create
objects
and
instantiate
them.
If
you
need
to
configure
things
together,
so
you
don't
spend
a
lot
of
time.
Well,
you
don't
spend
any
time
with
the
code,
and
that
gives
you
a
nice
way
to
avoid.
B
Run
so
the
answer
to
this
question
on
an
already
running
network,
or
would
it
be
separate
so
somewhat?
Yes
somewhat?
No,
so
as
long
as
you
can
load
the
well,
if
your
hyper
ledger
nodes
are
configured
correctly
to
be
able
to
dynamically
load,
shared
objects
which
a
lot
of
them
may
not
be,
but
if
they
were-
and
you
can
create,
say
a
new
channel,
you
could
certainly
load
this
cmi
into
it
class
major
infrastructure.
B
The
other
problem,
though,
is
you
tend
to
have
databases
already
been
set
up
with
some
sort
of
configuration.
Whatever
your
records
look
like
what
you
could
do
is
front
end,
those
with
objects
that
represent
them
and
then
use
methods
to
them.
So
you'd
write
a
class
knowing
what
your
objects
already
look
like
and
be
able
to
load
and
interact
with
them.
We've
already
thought
through
that,
that's
possible
the
one
that
I
don't
know.
B
B
But
theoretically,
as
long
as
the
configuration
pieces
are
there
as
long
as
you
can
put
the
external
chain
code
model
in
sure,
maybe
because
a
lot
of
these
can
be
bring
the
notes
down,
change
the
conf.
These
are
config
flags
in
the
config.yml
and
bring
it
back
up.
You
probably
do
it.
That
way,
also
take
a
little
bit
of
work,
but
not
not
impossible.
B
B
B
B
B
I
mean
obviously
one
of
the
tricks
for
these
unique
ids
is
that
the
seed
that
I
use
at
the
beginning
is
fixed
when
I
start
this
up
for
a
demo
in
a
real
world.
Every
time
you,
if
you're,
going
to
start
a
new
hyper
ledger
chain
up,
you
wouldn't
do
that.
You
would
pick
a
random
value
and
there's
a
there's
a
function
to
pick
to.
Let
it
pick
a
random
value,
you
can
give
it
a
random
value
and
then
it'll
always
that'll,
be
the
seed
forever.
B
B
B
B
A
B
And
paste
and
what
you'll
see
is
two
objects
now
this
is
the
original
one.
This
is
remember,
I
put
the
I
just
put
this
asset
in
here
and
now.
Here's
the
second
acid,
because
I
return
the
an
array
of
all
the
object,
ids
that
are
children
of
the
main
object.
So
this
is
the
account
object,
and
this
one
is
this:
guy
is
in
there.
D
D
B
D
Hyperledger,
though,
I'm
not
worried
about
hyperledger
leave,
that
alone
just
say:
it's
a
run
time
assume
it's
a
runtime.
What
you're
doing
basically
is
saying:
here's
a
quote:
a
free,
open
source
stack,
if
you
will
that
you
can
add
to
hyperledger
and
within
that
environment.
If
I
have
this
right,
you
can
in
a
sense,
create
your
own
classes
and
objects
that
will
be
dynamically
defined
and
invoked
where.
D
B
D
All
right,
so
in
fact
right
so
it's
your
point.
I
need
to
license
the
cmi
runtime
for
development
for
run,
for
free
to
run
it
in
a
I'll
put
a
business
application
number
one.
But
what's
really
strange,
is
using
go,
which
is
a
language
that
has
no
classes
for
to
define
a
class-based
network
which
is
really
strange
because
there's
a
lot
of
great
what
I
call
more
dynamic
languages
than
go
far
more
yes,
you're
to
develop
those
kind
of
things
for.
B
Sure
the
reason
why
is
that
when
I
started
out
in
this
hyperledger
had
go,
I
started
with
the
language
because
that's
what
it
was
and
okay
I'll
deal
with
that,
it's
not
really
meant
for
it.
I
jump
through
hoops
to
work
through
its
type
system.
I
use
unsafe
types
and
things
like
that,
but
they're
all
heavily
wrapped,
so
you
don't
really
have
to
touch
them.
D
I
understand
that,
like
I
say
that
normally,
if,
because
I
built
languages
like
this
in
the
past
and
that
in
doing
those,
it
made
sense
to
start
with
a
higher
level
object-oriented
language.
By
far
it
made
it
not
only
productive
for
me
to
build
the
framework,
but
also
far
easier
for
the
what
I
call
consumer
the
developer,
I
was
targeting
to
in
a
sense,
describe
his
own
dynamic
classes
and
objects
at
runtime
kind
of
a
thing.
Yes,.
B
D
B
It
basically,
you
have
to
modify
the
language
slightly
to
support.
Yes,
the
the
short
answer
to
this
is:
I
started
with
goaling,
because
hyperledger
at
the
time
that
was
what
they
set
up.
They
have
since
added
javascript
and
java.
I
think
into
it,
and
I
don't
know
what
else
they
have,
because
I
haven't
looked
at
the
site
in
a
little
while
they
have.
D
B
Yes,
you
could,
I
could
have
taken
javascript,
probably
to
do
it.
That
way.
I
know
java
very,
very
well
I'd,
be
writing
some
java
native
interface
to
make
that
one
work
literally
at
the
time.
I
started
this
though
neither
of
them
were
stable
or
available.
So
go
was
there
said,
aha,
so
the
rest
of
hyper
ledger's
written
in
go
so
I'm
going.
B
If
anybody's
interested
you
can
go
to
gitlab,
you
can
go
to
our
x-bonded
io
register.
It'll,
give
you
the
link
to
the
git
lab,
and
you
can
see
all
the
sources
for
a
good
number
of
these
they're,
not
all
up
there.
Yet
some
of
these
are,
I
haven't
uploaded.
The
latest
version.
You'll
only
see
the
part
that
brings
it
up
to
the
classic
count
and
basic
objects.
The
rest
of
this
will
show
up
shortly,
and
then
there
was
one
other
comment.
B
Oh
the
other
thing
is
that
in
this
type
of
environment,
using
golang
for
this,
the
actual
shared
object,
the
actual
classes
are
compiled.
You
were
mentioning
about
a
dynamic
environment,
so,
yes,
we
made
it.
We
made
golang,
actually
look
like
a
inherited
and
model
class
environment
and
with
dynamic
class
capability.
B
It's
a
little
funky
demonstrate
the
concept.
What
we
were
by
the
way.
What
we
were
after
is
demonstrating
the
concept
of
putting
using
the
blockchain
as
a
means
for
doing
inheritance
on
classes.
So
you
can
create
an
environment
where
you,
every
time
you
bring
up
a
new
capability,
you
don't
have
to
write
an
entire
smart,
smart
contract
and
hope
that
you're
getting
all
the
right
code.
This
is
it's
already
on
the
blockchain
you're
only
using
it
now
that
was
the
fundamental
reason
for
it.
B
B
B
A
B
A
You
both
dave
and
michael
and
the
rest
of
prasad
I've
seen
great
presentation,
and
you
know
you
can
ask
everyone
else
to
feel
free
to
follow
up
with
you
guys
if
they
have
any
questions
or
want
to
learn
more
and
again,
everyone
on
the
call
you
know
feel
free
to
reach
out
to
myself.
You
want
to
present
at
a
future
meetup
and
we
look
forward
to
the
one
next
month
thanks
and
have
a
great
rest.
Your
day,
yeah
thanks
for
inviting.