►
From YouTube: April 14, 2022 - Ortelius Architecture Meeting
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
In
in
artelias,
we
have,
you
know
like
an
application
version
which
is
made
up
of
component
versions,
and
those
component
versions
are
then
made
up
of
like
the
packages
that
were
installed
into
the
container
things
along
those
lines
so
that
whole
hierarchy,
when
we
create
a
version,
is
going
to
be
exported
out
of
our
database
and
added
to
the
blockchain
as
a.
I
think
I
can't
remember
if
it's
called
a
block
or
a
transaction,
that's
in
a
block
either
way.
We
end
up
persisting
that
transaction.
A
When
we
create
the
new
version
into
the
ledger
and
because
of
the
way
the
ledgers
work,
they
don't
want.
You
storing.
You
know
a
gigabyte
of
data
in
the
ledger
itself,
because
it'll
just
slow
down
the
the
computation
of
the
chain.
So
instead,
what
you
do
is
you
do
a
pointer
over
to
the
data?
In
our
case,
it
will
be
the
json
data
that
we
will
persist
somewhere
else,
so
the
concept
is
a
nft
is
where
we'll
actually
store
the
data
in
another
storage
mechanism.
A
Right
now
for,
like
the
proof
of
concept,
we're
going
to
install
the
nft
into
ipfs,
which
is
the
it's
like,
I
think
it
stands
for
interplanetary
file
system.
Basically,
it's
a
distributed
file
system
and
when
we
do
that
it
becomes
an
immutable
file
in
the
file
system.
So,
as
part
of
this
process,
we
need
to
make
sure
that
we
maintain
immutability,
so
the
blockchain.
A
A
So
this
hash
is
how
we
would
reference
that
json
payload
that
payload,
then
it
lives
in
the
ipfs
and
at
the
blockchain
level.
What
we
do
is
we
make
an
association
to
the
token
in
in
the
blockchain,
so
it's
basically
a
pointer
to
the
nft
that
happens
on
the
on
the
blockchain
side.
So
joseph
has
been
working
on
the
process
of
creating
the
nft
and
in
our
github
repo.
If
I
can
find
it.
A
You'll
see
where
he
did
an
example
in
node
as
part
of
the
process,
so
here
in
in
node
he's
taking
just
the
example
json
file
that
just
has
some
of
our
s-bom
data
in
it
and
he
is
storing
it
into
the
ipfs
as
part
of
that
process.
A
So
we
can
see
where
he's
connecting
up
to
the
ipfs,
so
the
the
nft
that
we're
using
is
nft.storage.
It
gives
us
a
free
basically
place
to
store
data
in
the
ipfs
world,
so
we
don't
have
to
create
anything.
A
We
just
get
to
reuse
that
public
storage
as
per
that
process,
so
we
can
see
where
he's
connecting
up
through
the
token
and
he's
actually
loading
in
the
metadata
here
into
the
ipfs,
giving
it
a
description
and
that
ends
up
returning
us
a
basically
that
hash
that
we
need
to
utilize
and
then
on
the
reverse.
A
You
take
that
that
hash
and
that
allows
us
to
go
ahead
and
pull
out
of
the
ipfs
and
retrieve
our
immutable
data.
So
this
is
going
to
be
part
of
it
right
now.
A
I
foresee
that
we'll
use
the
ipfs
as
a
as
a
easy
storage
mechanism
for
our
proof
of
concept
down
the
road.
I
think,
instead
of
in
storing
it
into
ipfs,
that
will
need
to
store
the
token
into
like
the
orango
db
in
some
sort
of
mutable
fashion
and
the
reason
being
is
we
want
to
be
able
to
to
query
the
json
file
that
we
store
over
there.
The
way
the
ipfs
works
and
the
nfts
is
you
just
have
these
hash
ids
that
we
get
to
deal
with
and
that's
not.
A
We
can't
really
go
and
query
the
hash
id
and
we
don't
want
to
loop
through
every
single
transaction
in
the
blockchain
and
then
go
over
to
take
the
token
off
of
the
blockchain.
Go
look
up
the
data
in
retrieve
the
data.
The
json
out
of
ipfs.
Then,
do
our
query:
it's
just
going
to
be
too
slow,
so
we're
going
to
down
the
road
change
the
search
mechanism
of
our
data.
That's
gonna
be
immutable.
A
So,
as
part
of
this,
the
creating
the
the
token
over
in
in
the
nft
storage
was
pretty
simple.
A
B
A
Okay,
so
it
is,
I
think,
mixing
in
node
will
be
fine
if
it
makes
our
our
coding
easier.
Let's
go
ahead
and
use
the
node.js
for
our
our
implementation.
If
we
need
to
change
it
down
the
road
we
can,
hopefully
the
process
isn't
going
to
be
overly
complicated.
A
I
think
when
we
get
into
replacing
the
back
end
ipfs
with
the
durango
db,
that
we
may
need
to
flip
out
the
libraries
at
that
point,
but
I
think
for
us,
during
the
proof
of
concept
that
that
using
node
or
python
or
mix
works
perfectly
fine,
so
that's
kind
of
where
what
what's
happening
on
the
nft
side
now
the
next
part
is
getting
the
nft
and
the
python
I
mean
the
blockchain
linked
together
is
the
next
step
and
I
believe
cars.
B
A
Yeah,
and
are
you
using
testnet
or
devnet.
A
Devnet
yeah,
so
ripple
xrpl
has
provided
a
couple.
Blockchain
serv
server
networks
distributed
networks
that
we
can
work
with
one's
called
test
net,
the
other
one
is
called
devnet
and
then
they
have
the
production
one.
A
So
the
high
level
is
to
connect
to
the
ledger
and
from
there
we
actually
go
ahead
and
create
a
wallet.
A
A
So
when
we
get
into
this
wallet
concept,
we
may
be
generating
a
wallet
with
unlimited
like
dollars,
or
you
know
tokens
or
you
know,
or
we
may
just
generate
it
with
zero,
and
I
don't
know
if
we
can
generate
a
a
wallet
with
zero
and
keep
on
doing
the
transactions,
but
we'll
we'll
cross
that
bridge
down
the
road.
A
So
you
get
your
you
connect
up
to
the
ledger,
generate
your
wallet
or
pick
the
wallet
that
you
already
have
out
there,
and
then
you
start
signing
and
and
sending
transactions
into
the
ledger.
And
then
you
query
the
ledger
for
your
information:
that's
out
there.
So
this
is
where,
when
we
put
it
all
together,
we'll
we
connect
up
to
it.
We
get
our
wallet,
we
do
our
our
transactions
and
then
we
go
and
look
things
up
at
that
level.
A
Now,
when
we
look
things
up,
it's
all
going
to
be
these
tokens,
these
hash
tokens
so,
like
I
said
it's
going
to
be
harder
for
us
to
find
information.
So
when
we
make
our
bridge
between
artillious
and
the
ledger,
when
we
get
the
ledger
token
back
on
that
transaction,
we'll
record
that
back
over
on
the
in
the
artillius
database
side,
so
we'll
make
the
link
between
the
two
in
the
artillious
database.
A
So
that
way,
when
we
know
that
we
created
version
15
of
our
shopping
cart
application
that
that
version
15
is
located
here.
This
is
the
transaction
that
occurred
in
the
in
the
ledger.
So
we
can
then
go
query
more
information
about
that
down
the
road.
I
foresee
that
the
what
we
have
going
on
in
the
postgres
database
will
be
migrated
over
to
the
graph
database
orango
at
that
level.
A
We
have
to
build
up
like
a
transaction
list
and
have
you
gotten
to
that
point:
ukrs,
where
you're
building
a
transaction
and.
B
A
And
this
may
be
the
one
that
we
need
to
kind
of
put
together
where
so
kind
of
like
where
we're
at
right
now
is
we
have
the
the
wallet
working,
we
have
the
nft
working
and
we
need
to
bring
bring
the
two
of
them
together
and
that's
right.
So
we
need
to
do
the
mint
transaction
which
is
going
to
allow
us
to
take
the
nf
t,
that's
in
the
ipfs
and
mint
it
together
with
the
blockchain.
So
this
is
kind
of
like
pulling
the
the
tokens
together.
A
So
this
may
be
where
our
next
step
that
we
need
to
look
at
is
minting
the
tokens
and
bringing
the
the
two
together.
B
A
And
it
looks
like
this
one
is
in
node.js
as
well.
So
if
you
want
to
flip
everything
from
python
over
node.js
that
works,
it
may
just
be
easier
to
get
some
better
examples
instead
of
trying
to
to
translate
from
node
over
to
python
and
write
stuff.
So
let's
see
what
they
got
going
on
here,
so
we're
going
to
connect
up
to
the
devnet
server,
we're
going
to
get
our
account
with
our
wallet.
A
Oh
okay,
so
that's
like
pre-creating
the
token.
So
what
ends
up
happening
is
in
the
the
blockchain,
because
the
blockchain
is
a
distributed
network
they
and
they
want
to
ensure
immutability.
A
So
a
series
of
distributed
servers
are
going
to
come
to
a
consensus
about
the
transaction
and
say
they
all
agree
that
that's
a
valid
transaction
and
nobody
messed
with
it.
So
when
that
happens,
you
go
through
this.
This
kind
of
staging
of
you
go
and
submit
your
transaction,
and
then
you
have
to
wait
a
period
of
time
for
the
consensus
to
occur
before
the
transaction
can
be
added
into
the
blockchain
itself.
So
it's
a
multi-step
process,
that's
happening,
so
I
believe
this
burn
token
is
creating
the
initial
connection.
A
We
get
our
transaction,
which
will
be
our
information
about
our
our
nft.
We
get
that
going
out
there
and
then
from
there.
A
A
Buy
create
a
buy,
so
this
is
this
is
where
the
the
sell
and
buy
is,
if
we're
transferring
the
token
the
nft
to
another
or
person.
That's
on
the
network-
and
I
don't
think
at
the
beginning
we're
going
to
need
to
do
that.
A
A
So
let's
say
give
example:
at
a
company
we
have
we've
created
our
application
version
and
we're
going
to
deploy
it
to
the
dev
environment
and
then
we're
going
to
deploy
it
to
qa
and
then
we're
going
to
deploy
it
to
prod
each
one
of
those
deployments
is
going
to
be
another
transaction
that
we
can
associate
into
the
blockchain
itself.
A
So
we
have
this,
this
ledger
of
where
this
thing
ended
up
going,
so
we
could
have
a
a
dev
buyer,
a
qa
buyer
and
a
prod
buyer
and
they're
all
going
to
buy
the
same
nft
and
that's
where
we'll
start
recording
those
transactions
into
the
ledger
as
well,
so
we
can
see
who's
using
it
and
where
and
that
scope
would
be
not
only
at
the
the
that
local
development
I
mean
at
that
local
company,
but
we
can
go
globally
with
this
as
well.
A
So,
for
example,
if
we
have
wordpress
and
wordpress,
we
have
a
version
of
wordpress,
that's
been
defined
into
artillius
and
we
have
that
stored
in
the
in
the
blockchain
into
the
ledger.
We
can,
then
anybody
that's
going
to
consume,
that
version
of
wordpress
and
then
install
it.
We
can
have
them,
be
buyers
and
associate
them
to
that.
So
we
can
go
not
only
internal
with
the
company
but
higher
level
globally
and
that's
going
to
be
the
the
the
power
of
this.
A
So
let's
say:
there's
a
a
php
module
inside
a
wordpress
that
has
a
security
vulnerability.
We
can
then
see
because
of
we're
watching.
We
have
a
list
of
all
the
transactions
of
everybody
that
consumed
that
version
of
wordpress.
We
can
then
notify
or
associate
and
find
those
people
to.
Let
them
know
that
they
need
to
do
an
update
of
that
version
of
wordpress
a
new
version
of
wordpress
because
of
php
vulnerability.
A
So
that's
the
concept
I'm
trying
to
get
to
at
that
level,
so
initially
the
the
buy
and
sell.
We
won't
worry
about
that.
We'll
just
get
stuff
onto
the
blockchain
as
nfts.
A
So
this
is
all
around
the
transactions
steve.
Have
you
guys
started
building
this
already
yeah?
We
have
an
example
that
joseph
started
working
on
so
in
in
our
repo.
Here
we
have
the
the
nft
piece
where
we're
placing
the
our
json
snapshot
of
an
application
version
into
the
into
the
ipfs
storage,
so
that
is
done
and
utkersh
has
the
wallet
side
in
place.
A
So
let
me
see,
and
the
nice
thing
about
the
xrpl
they
do.
I
believe
they
have
a
like
a
a
website
that
you
can
go
and
query
like
devnet
and
testnet
automatically.
You
know
without
having
to
write
a
bunch
of
code.
A
A
Yeah,
so
this
one
may
be
one
for
you
to
work
with.
Oh
karsh,
it
looks
like
they
are,
have
a
if
I'm
reading
a
code
right
here,
real
quick.
A
Yeah,
so
this
will
be
where
we
would
kind
of
associate
together
the
information.
C
A
A
Trying
to
figure
out
where
it's
putting
together
the
information.
So
if
we
go
back
over
to.
A
A
A
So
yeah
once
it's
once
the
file
is
placed
in
the
ipfs,
it
will
return
the
hash
and
then
that
hash
is
what
we
associate
back
into
the
transaction
layer.
So
if
we
go
back
over
to
here.
A
B
A
Okay,
so
this
is
so
the
this.
The
sids
is
the
ipfs
hash
number
that
we
will
we'll
get
back.
A
B
A
A
A
So
I
think
this
is
going
to
be
a
good
example
to
try
to
give
it
a
go.
I
I
don't
think
we'll
need
like
the
pinata
and
we'll
be
able
to
strip
a
lot
of
this
back.
A
A
A
So
what
we
have
is
we
have
our
our
uri,
so
this
is
going
to
be
that
sid
number.
This
is
that
sid
that
that
kershaw's
talking
about
the
ipfs
returns
so
the
way
that
the
whole
process
works
is
we
take
our
json
payload.
We
send
that
off
to
ipfs.
A
Ipfs
creates
that
persists
that
in
the
distributed
network-
and
it
returns
a
sid
that
sid
gives
us
this
immutable
reference
to
our
json
payload.
So
that's
that's!
Storing
our
our
json
payload
into
the
in
persisting
it
on
disk.
A
Basically
now
the
next
thing
is:
we
need
to
record
on
the
blockchain
where
that
file
lives
in
ipfs
and
that's
where,
when
we
create
our
our
token,
our
nft
token,
on
the
blockchain
side,
we
give
it
that
sid
as
one
of
the
parameters
and
then
we
give
it
the
token
id
for
where
we're
gonna
find
that
information
in
the
blockchain.
A
So
it's,
if
you
think,
of
the
blockchain
as
a
giant
linked
list
and
as
you
go
through,
do
these
transactions
we're
going
to
create
a
new
transaction.
In
the
blockchain
saying
I
just
created
a
new
application
version
and
here's
all
the
json
data
about
that
the
json
data
gets
pushed
over
to
the
ipfs
storage.
A
We
get
the
sid
back
now
on
the
blockchain,
we're
going
to
record
that
transaction
that
we
created
a
new
application
version,
and
here
is
the
sid
to
go,
find
the
the
metadata
that
that
json
payload
from
that.
So
what
what
they're
trying
to
avoid
is
storing
large
amounts
of
data
on
the
blockchain
itself,
because
it
just
makes
it
slower.
A
So
you
just
store
pointers
to
external
storage
for
those
the
things
on
the
blockchain.
So
that's
why,
back
at
at
this
level,
they
were,
they
were
storing
data
in
ipfs
and
also
an
s3
bucket,
so
ipfs
isn't
required.
You
just
need
to
persist
somewhere
and
then,
if
you're
worried
about
immutability,
you
have
to
make
it
a
mutable.
A
Reference
to
the
file
and
that's
called
a
they're
called
distributed
hash
tables
at
that
level.
So
when
you
persist
the
file,
you
end
up
with
the
the
a
a
hash
of
it
that
when
we
link
things
together,
we
can
do
the
verification.
So
let's
say
we
pull
the
token
we're
looking
for
our
application
version
that
we
just
created.
A
We
can
look
at
the
blockchain
and
we
can
then
get
our
token
and
then
we
can
get
our
sha
here,
which
is
the
immutable
hash
of
our
json,
and
then
we
can
go
into
the
json
file
and
calculate
and
see
if
we
come
up
with
the
same
thing.
A
So
we
can
do
a
verification
to
make
sure
that
nobody
messed
with
the
data
that
was
on
disk,
and
that
gives
us
this
immutable
ledger,
even
though
things
are
are
broken
apart
on
the
storage
side,
so
we
have
the
blocked,
blockchain
storage,
and
then
we
have
the
data
storage
that
happens
in
on
a
separate
type
of
system,
but
because
we
were
able
to
create
create
these
hash
tables
and
they
end
up
being
immutable.
We
can
do
verification,
make
sure
nobody
monkeyed
with
anything
that
does
that
help.
B
B
A
A
A
Okay,
so
yeah,
so
this
is
where
they're
doing
it
they're
building
up
the
the
domain
pointer.
So
you
can
see
our
our
sid
there.
Some
of
the
other
tokens
where,
where
it's
being
stored,.
A
Let
me
see
if
I
can
find
it
so
when
they
talk
about
this
token
id
you
can
see
how
that
token
id
is
broken
out
into
different
pieces,
and
I
think
that's
what
they're
doing
in
that
in
that
domain
field
is
creating
one
of
these
ids
with
the
different
pieces
kind
of
smashed
together.
A
Right
yeah,
so
you
have
to
build
so
this
is
kind
of
building
up
the
the
transaction,
and
this
is
where
I
was
saying
they
have
a
restriction
on
the
number
of
bytes
that
you
get
to
put
into
that
dumb.
That
domain
information.
A
B
A
So
this
is
an
excellent
example
that
you
found
kirsch.
I
I
would
see
if
we
can
get
this
to
kind
of
work.
A
D
B
A
Yeah
and
the
the
xrpl
documentation
is
actually
pretty
good.
B
A
A
We'll
let
you
do
the
translation,
with
sasha
between.
E
E
I
don't
mind
getting
my
hands
dirty
here,
but
I
will
be
phoning
you
one.
D
A
A
B
A
A
B
A
Yeah
there
you
can
like
we're
talking,
the
the
ipfs
is
just
at
this
point,
for
us
is
an
easy
way
to
just
store
our
json
in
a
mutable
format,
the
ipfs
interface
and
their
apis.
Allow
us
to
do
that
really
easy.
It's
just
a
couple
calls
to
make
that
happen,
and
that
gets.
It
gets
us
an
immutable
file
that
we
can
then
work
with
on
the
blockchain
side
down
the
road.
A
I
think,
instead
of
using
ipfs
we'll
be
using
the
graph
database
or
something
else,
because
we
want
to
be
able
to
query
it.
So
the
weird
and
I'm
not
it's
weird
that
nobody's
come
up
with
this,
yet
that
you
need
to
be
able
to
query
the
nft.
A
A
To
put
it
back
the
way
it's
supposed
to
be
on
disk
from
from
one
of
the
other
servers.
So
there's
this
whole
concept
of
distributed
hash
tables,
and
these
servers
communicating
with
each
other
to
make
sure
that
things
haven't
been
messed
with
when
we
look
at
what
we're
doing
with
ortilius
and
bringing
that
into
the
orango
database.
So
we
can
query
those
things
we
may
need
some
different
implementations.
Now
brian
dawson
told
me
that
he
has
one
of
the
folks
from
ripple.
A
They
are.
The
xrpl
developers
have,
instead
of
ipfs
for
storing
the
nfts
and
that's
going
to
be
very
similar
to
what
we're
we're
talking
about
is
just
going
to
be
another.
E
Document
there
yeah
I've
set
up
clusters
for
those
before
okay.
Why
did
they
choose
that
over
rpf?
Well,
the
other
yeah,
our
systems?
Why
did
they
have
someone
go
over
ipfs?
Is
it?
Is
it
just
because
it's
I
don't
know
more,
it's
so
new,
it's
more
known
or
well.
Iffs
is
and
how
do
you
run
ipfs?
Does
it
run
like
a
like
a
similar
idea.
D
A
E
A
I
have
control
because
it's
a
it's
a
consensus-based
network
as
well,
so
there's
consensus
built
in
across
all
the
nodes
in
the
peer-to-peer
network
to
make
sure
and
that's
where
the
distributed
hash
tables
come
into
play,
where
they
all
confirm
that
they
have
the
same
thing
before
they
actually
write
it
to
desk.
A
That's
actually
on
the
ipfs
side
and
then
on
the
blockchain.
It
does
it
again.
A
Well,
the
blockchain
is
going
to
be
your
transactions,
so
in
our
world
creating
an
application
version
would
be
a
transaction.
Creating
a
new
component
version
would.
A
A
That
would
say
that
you
know
site
ground
just
deployed
into
this
server.
This
production
server,
this
version
of
wordpress
that
transaction
that
buy
sell
transaction,
would
end
up
in
the
blockchain,
and
if
we
have
everybody
doing
that,
if
we
have
you
know
some
other
rackspace
doing
a
wordpress
install
the
same
version.
What
ends
up
happening
is
we
have
these
transactions
that
are
all
pointing
back
to
the
same
nft
that
we
created.
Now
we
can
see
across
the
whole
world,
everybody
that's
using
that
version
of
wordpress
and
where
it's
been
deployed
into
what
environments.
A
A
We're
that's
what
we're
trying
to
untangle
with
that
code
from
that
that
sample
code
that
that
person
put
together.
E
A
That
that's
the
part
we
need
to
to
figure
out.
So,
instead
of
so
one
of
the
possibilities,
is
you
mirror
the
data
that
is
in
ipfs,
and
you
mirror
that
into
the
document?
Storage
for
querying
capabilities.
B
There
is
this:
the
graph
product
which
is
used
for
querying
on
ipfs.
B
A
A
Let
me
add
it
in
to
our
issue
real
quick,
so
that's
kind
of
where
we're
headed
and
what's
what's
going
on
so
kind
of
the
next
step
will
be
to
pull
the
nft
side
and
the
blockchain
transaction
side
together.
E
Okay,
that
was
the
part
that
I
was
struggling
to
to
put
together,
was
there's
a
nft
side
and
there's
a
blockchain
side,
and
both
of
them
are
having
both
have
the
data
that
you
are
that
are
required.
Is
it
both
recording
transactions
or
the
blockchain,
only
records
transactions,
and
what
is
the
nfd?
What
is
the
nfd.
A
It's
it's
immutable,
immutable
storage,
okay,.
E
Okay,
cool
that
makes
sense.
Nice
thanks.
A
A
Yeah
in
in
everything
that
that
that
happens
is
going
to
be
because
it's
an
immutable
ledger,
you
can't
go
in
and
change
something.
So
let's
say
we
want
to
in
our
component
ver
in
our
application
version.
We
want
to
go
ahead
and
swap
out
a
component.
A
We
want
to
bump
the
component
version
in
that
application
version
we've.
Instead
of
that,
allowing
an
update
to
happen
at
that
level,
we
you
can
only
create
you
can
never
update
an
application
version.
You
only
create
new
ones
at
that
level.
So
you
can.
You
can
take
a
previous
version,
create
a
new
one
and
in
that
creations
process
you
you
can
do
the
update
then,
but
it
actually
ends
up
being
a
new
version,
so
everything
you
do
is
versioned
and
saved
in
the
basically
the
transaction
ledger.
A
And
that
will
allow
us
to
maintain
history
forever.
Basically,.
A
So
you're
gonna
tackle
the
the
next
step
of
pulling
together.
B
A
A
A
Yeah
exactly
and
I
just
we
will-
we
don't
have
to
worry
about
like
a
s3
bucket
or
anything
else,
just
just
ipfs.
So
our
at
this
point,
our
storage
will
be
ipfs
and
we'll
be
doing
the
xrpl
ledger
and
hooking
the
two
together
we
don't
have
we
don't
worry
about
like
s3,
bucket
or
pinata
or
any
other.
A
Yeah
and
reach
out
to
joseph,
if
you
needed,
help
on
that,
because
I
know
he
did
the
the
nft
side
in
node.
So
we
have
that
code
to
work
from
as
well.
E
E
A
And
then
I
got
to
look
at
this
link
that
cursor
sent
about
the
graph
for
searching
ipfs.
A
It's
it's
basically,
what
we're
thinking
of
doing
as
well,
basically
mirroring
the
data
into
a
searchable
format.
E
A
E
But
okay!
Well,
sorry!
So
can
I
just
stop
here
quickly?
Is
that
data
included?
Is
that
like,
if
we're
talking
money,
what
the
actual
transaction
took
place,
how
much
you
bought
and
how
much
you
saw
or
whatever
something
like
that,
how
much
you
bought
and
sold
or
and
the
value
around
that
and
who
did
it,
is
that
kind
of
information
in
there.
A
Yeah
yeah,
so
in
in
the
blockchain
you'll,
have
there
there's
a
couple
different
transaction
types,
one
of
the
transactions,
the
main
transaction,
that
we're
going
to
be
focusing
on
first
is
going
to
be
the
nf,
creating
the
nft
on
the
blockchain,
and
then
another
transaction
would
be
like
buying
or
selling
the
nft.
A
So
those
are
the
buying
selling
are
more
like
money
based
transactions.
Where
just
saying
that
this
is
available,
this
this
nft
is
available
on
the
blockchain
for
purchase,
but
that
is
what
utkarsh
and
joseph
are
going
to
tackle.
Next,
okay,
and
like
I
said
so,
you
could
you
could
theoretically
find
all
of
your
nfts
from
your
from
your
wallet.
So
you
can
say
I
own.
A
I
created
these
nfts.
I
haven't
sold
them
yet,
but
I
created
them
and
those
transactions
will
be
associated
to
your
wallet
in
the
blockchain,
so
you
can
loop
through
because
the
block
changes
the
big
giant,
linked
list.
You
can
think
of
it.
That
way,
you
can
then
loop
through
all
your
your
transactions
that
are
in
your
wallet
and
find
the
cid
that
will
get
you
to
where
the
actual
data
is
stored.
In
ipfs
and
retrieve
that
data,
then
thanks,
but.
A
If,
if
you
want
a
query
to
say
who's
using
log
for
j,
you
know
which
application
versions
are
using
log
for
j.
You
have
to
go
into
your
wallet
loop
through
every
single
transaction.
A
Go
pull
the
payload
the
json
and
then
go
query
that
json
to
see,
if
that
contains
the
log
for
jdata
that
we're
looking
for
now.
If
we
have
a
million
transactions,
a
million
versions
of
our
in
our
wallet,
it's
going
to
take
a
long
time
to
loop
through
and
go
fetch
everything.
A
Yeah,
so
that's
where
this
the
offloading
or
mirroring
the
data
or
moving
it
outside
of
or
somehow
indexing
ipfs
will
allow
you
to
search
and
you
kind
of
go
backwards
you.
So
you
find
the
data
that
you're
looking
for
and
then
you
can
work
your
way
backward
to
the
cid
and
then
from
the
cid.
You
can
calculate
to
see
if
it's
actually
been
corrupted
or
not.
If
it
hasn't
been
corrupted,
you
can
then
go
back
to
see
which
transactions
are
in
your
blockchain
to
do
the
cross-referencing.
E
She's,
fascinating
man,
and
that's
probably,
why
is
that
why
brian
and
them
have
a
mongodb
to
make
to
make
finding
that
information
faster,
exactly
makes
sense?
Okay,
it's
like
a
cache.
D
A
Yeah
now,
when
we're
talking
about
like
the
the
wordpress
example,
if
you
have
wordpress
being
used
by
you
know,
if
it's
being
deployed
to
you,
know
100
000,
servers
and
or
you
know,
10
million
servers
and
because
wordpress
is
pretty
popular,
I
can
imagine,
there's
10
million
copies
of
wordpress
out
there
that
the
scale
that
we're
going
to
need
to
do
to
do
the
queries
is
going
to
have
to
be
pretty
quick
and
that's
where
the
graph
databases
come
into
play
because
they
manage
relationships
and
do
indexing
to
find
things
really
quick.
A
You
know
a
10
million
row
search
in
like
orango
db,
is
going
to
come
back
sub.
Second.
A
Yep
db.
A
E
E
Wow
so
steve,
just
okay-
I
don't
know,
there's
probably
time
for
this,
but
just
quickly
erango.
Is
it
a
no
sequel
type
of
technology?
Okay,.
A
D
A
Is
a
restful
api
query
language
that
github
created-
and
it
has
that's
all
about
at
the
api
level
of
the
restful
api
level,
and
it's
not,
it
doesn't
have
anything
to
do
with
a
graph
database.
E
Okay,
cool:
this
is
fascinating
man.
This
is
so
cool
wow.
A
So,
who
cares
if
you
could
reach
out
to
joseph
and
let
him
know
what
the
plan
is
and
if
he
just
the
the
two
of
you
kind
of
and
wherever
else
wants
to
work
on
this
kind
of
pair
up
and
if
you
could,
when
you
got
anything
close,
even
if
it's
not
a
non-working
sample,
add
it
to
that
blockchain
repo,
because
that's
one
of
the
things
for
that
grant
we're
working
on.
They
want
to
check
out
our
repo
and
the
coding
that
we
got
going
on.
A
A
We
have
stuff
moving
forward
around
that
grant,
that
that
would
be
a
big
help.