►
From YouTube: TokenScript Weekly Meeting 20200903
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
Hello,
bull
hi,
you
hi,
so
I
think
you
didn't
read
the
email.
But
if
you
are
here,
you
are
welcome
to
stay.
So
I
propose
that
we
have
a
meeting
about
james
taurus
code
on
attack,
station
check
and
zero
knowledge,
proof
passing
israel,
knowledge,
proof,
verification
and
then,
because
that
is
going
to
be
attestation.
A
To
work
on
the
contract
side
with
it,
I
I
think
we
should
move
to
the
normal
token
script
meeting
to
friday.
Instead,
so
today
is
actually
about
an
implementation,
not
about
design,
and
I
wrote
an
email
wanting
to
protect
you
so
so
that
you
can.
You
only
need
to
show
up
in
the
design
meetings,
but
if
you
want
to,
you
can
stay
here
and
observe
the
implementation
part.
A
A
I
just
proposed
an
email,
nobody
said
anything,
so
I
think
yeah,
but
is
it
okay
for
you?
Try
that?
Yes,
okay,
nice,
nice,
okay,
that's
also
easier
for
me
and
I
think
it
will
be
more
productive
because,
generally
in
the
weekdays
you
and
james
brown
are
both
very
heavy
in
the
in
the
middle
of
something
so
on
friday
might
be,
might
be
easier
to
switch
your
mind
into
designs
from
from
the
implementation
side.
A
Development
tasks
related
to
the
the
testation
use
case
from
the
from
where
paul
have
have
have
produced
so
a
little
bit
of
the
backdrop,
so
her
tall
has
produced
first
por
tor
has
produced
a
test
data
for
all
of
the
cases
that
that
means
testing
the
three
pieces
of
test
data.
Wait
a
moment.
Let
me
close
the
door.
A
So
the
first
piece
is
the
identifier
attestation
for
bob,
and
it's
the
same
as
san
diego
bob
case
and
second
is
alice's
check
that
allows
bob's
the
test
attestation
owner
to
and
the
third
piece
that
a
piece
of
test
data
is
the
zero-knowledge
proof
produced
by
bob
and
to
in
the
for
the
redeeming
transaction.
A
So,
given
that
these
three
datas
there,
if
we
program
the
part
that
passes
the
test
station,
passes
the
check
and
verify
the
zero
knowledge
proof,
all
three
pieces
of
task
needs
to
be
done
in
smart
contract.
Once
if
we
focus
on
smart
contract
part
first,
then
we
have
all
the
test
data
needed.
The
next
thing
is
how
much
code
should
we
port
from
the
existing
implementation?
A
Yeah,
that's
correct
yeah,
so
he
has
java
code
for
all
of
the
three,
so
that
that
boils
down
is
quite
problem
to
how
much
how
much
work
there
will
be
to
convert
this
into
a
smart
contract
as
smart
contract
is
needed
to
do
all
three.
A
So
that's
that's
today's
topic.
Basically,
so
maybe
talk
and
walk
us
through,
what's
happened,
what's
happening
in
java
code
regarding
to
these
three
pieces
of
data
and
james
and
james
brown,
me
will
observe
and
see
like
find
a
way
to
find
a
tech
plan
to
make
this
work
in
smart
contract.
A
D
So,
first
of
all,
oh
sorry,
I
have
a
bit
of
an
echo.
I
think
it's
okay.
Now
it's
gone,
that's
great,
okay!
D
So
like
first,
when
we're
still
looking
at
all
the
different
ways
of
passing
asn
asn1
and
all
of
this
I
wrote
a
flow
of
the
czech
protocol
and
a
proof
of
concept
and
asm
files,
both
sn1
and
asnx
files
in
in
java,
based
on
the
compiler
from
the
objective
objective
systems
like
when
we
look
further
into
that
it
turned
out
that
they
were
extremely
expensive
in
regards
to
deployment.
D
That
is
that
they
wanted.
They
wanted
specific
money
for
each
device
that
this
was
deployed
deployed
to.
So
this
is
clearly
not
another
usable
scenario.
It
also
turned
out
that,
even
so,
even
though
you
use
the
compiler
to
basically
make
java
objects
from
there
from
an
asn
1
file
from
an
asn
module.
D
They
still
require-
which
I
guess
in
some
way
make
sense,
but
they
still
require
a
license
even
to
run
that.
So
even
like
the
example
code,
I
made
you
need,
like
an
evaluation
license
or
something
like
that,
to
even
run
that.
So
I've
been
like
porting
that
and
writing
manual
modules
for
for
the
objects
needed
and
I've
ported
that
into
into
the
the
lip
hold
on
into
the.
D
Into
the
edges
into
the
lip
at
the
station
folder
in
the
in
the
android
project,
and
thus
have
also
ensured
that
I'm
not
using
any,
there
was
also
some
issues
with
api
uses
and
stuff
like
that
so
insured
like
now,
also
that
these
things
are
based
on
the
api
used
in
the
android
app,
I
still
need
to
port
a
little
bit
of
this
into
into
the
android
into
the
android
repo.
Let's.
A
B
D
Yes,
exactly,
I
think,
like
for
a
thing
like
this,
like
a
complex
protocol
like
this
with
a
bunch
of
different
object
files
and
a
bunch
of
cryptography,
I
think
it
really
makes
sense
to
just
have
in
one
platform,
write
the
first
version
and
then
part
it
directly
from
there,
because
then
we
already
like
now,
we
know
how
it
works.
Now
we
know
what
things
are
supposed
to
look
like
to
be
okay
and
then
translate
that
into
the
into
into
the
solidity.
B
A
Okay,
can
you
share
the
screen
yeah
yeah,
I'm
doing
that.
B
Does
you
don't
have
this
in
a
github
repo
in
your
engine?
Sorry,
do
you
have
the
code
that
you're
going
to
be
talking
about
in
the
github
repo
or
is.
D
D
D
C
D
Yeah,
that's
it
okay,
so
this
is
like.
So
this
is
the
stuff
based
on
the
comp.
Sorry,
on
the
objective
systems,
compiler,
where,
basically,
I
wrote
some
tests
and
I
wrote
basically
a
main
method
here
that
sort
of
does
the
entire
the
entire
flow,
the
entire
flow
needed,
so
just
to
give
an
oval.
E
D
Basically,
you
have
a
method,
that's
basically
making
that's
making
a
check
object
and
the
check
is
based
on
an
identifier,
an
a
type,
an
amount
and
now
also
some
some
validity
time
for
how
long
it's
supposed
to
be
valid,
and
basically
the
code
here
is
then
using
bouncy
castle,
elliptic,
elliptical
arithmetic
to
construct
a
to
construct
a
riddle
and
then
afterwards
to
basically
construct
an
as
an
asn
asn1
object,
so
which
can
then
be
returned
back
so
this
so
I'm
showing
you
here
like.
D
Basically,
I
want
to
show
the
whole
flow,
and
this
I
haven't.
This
is
the
the
old
code.
That's
basically
based
on
well
this
proprietary
library.
So
so
so
I've
changed
some
of
this
and
what
I
will
show
you
in
a
second,
but
just
to
give
you
an
idea
of
the
whole
flow.
B
D
D
D
The
receiver
may
or
may
not
need
to
make
to
get
and
get
an
attestation
first.
So
this
is
what
is
actually
going
on
here
like
assuming
the
receiver
doesn't
have
an
attestation.
He
needs
to
make
an
attestation
based
on
his
his
identity
and
his
identifier,
which
can
then
be
signed
by
a
a
ca
or
identity
provider
of
whatever
we
want
to
call
it,
and
as
we'll
talk
about
this
is
basically
just
assigned
at
a
station
which
is
somewhat
compliant
with
x509
b3.
D
And
I've
actually
like
in
my
code
and
in
my
test
code,
like
ensured
compatibility
by
both
by
by
the
object
type
by
basically
encoding
it
also
as
an
x509
and
verifying
this
using
x509
libraries
to
make
sure
that
things
actually
work
like
they're
supposed
to
and
that
they're
compliant
with
the
standards.
D
But
I
think
in
like
the
actual
case,
where
we
want
to
use
this,
it
will
most
likely
not
be
compliant
because
it
will
not
be
compliant
because
of
two
things.
First
of
all
we
need
to.
We
would
ideally
want
to
use
a
different
version
number,
since
we
are,
since
what
we're
doing
is
actually
not
an
x
509
certificate,
so
verification
libraries
will
already
fail
there.
D
And
secondly,
I
assume
that
we
actually
want
to
sign
this
based
on
cad
check
as
the
hash
function,
rather
than
shout
256,
which
is
also
generally
not
supported
for
an
x509.
So
those
are
the
main
reasons
that
they
cannot
directly.
If,
if
we
do
something
that
we
actually
want
to
do,
that's
compliant
with
the
the
blockchain,
it
cannot
directly
be
verified
by
a
standard,
x509
verifier.
D
Okay,
I
mean
there's
also
no
there's
also
no
issue
using
a
ketchup.
I
mean
I
don't
because
I
mean
using
like
having
it
as
a
as
an
x509
I
mean
is,
is
I
don't
know?
I
find
it?
Yes,
yeah,
I'm
not
sure
it's
it's
it's
necessary,
given
that
any
kind
of
interpretation
of
an
x509
will
not
contain
you
know
the
specific
knowledge
needed
to
interpret
like
the
values
of
the
the
common
name
and
things
like
that
which
is
yeah
yeah.
B
C
A
B
I
I've
been
using
that
word
for
four
years
and
I
had
no
idea.
That's
how
you
pronounced
it
key
cake.
I
I
thought
it
was
cute.
D
Sorry,
that's
just
how
I
like
like
when
I
see
that
word,
that's
how
I
thought
it
would
be
pronounced,
but
I'm
not.
I
don't
remember.
Actually
I
I
I
don't
know
you
hear
everyone
pronouncing
it
differently.
I'm
not
sure
what
the.
B
D
D
B
B
So
earlier
you
were
talking
about
using
a
proprietary,
compiler
yeah.
I
didn't
quite
understand
how
that
fits
in
is
that
to
assemble
the
ddr
code
or.
D
What
so
it's
a
way
when
I
talked
a
lot
about
like
how
to
do
all
this
asn
1
passing-
and
I
mean
I
mean
we-
we've
had
there's
been
a
lot
of
like
like
things
with
with
all
this,
a
translation
and
and
passing,
and
all
of
this
with
asm1,
and
one
of
the
things
we
looked
at
at
some
point
was
libraries
for
basically
compiling
into
java.
D
Well,
we
found
one
that
that
seemed
seemed
pretty
good
until
it
came
like
down
to
to
pricing
and
basically
also
the
fact
that
we
just
couldn't
so
what
I'd
hoped
was
that
we
could
at
least
like
just
compile
those
a
couple
of
files
we
needed,
and
then
you
know,
buy
a
license
if
we
needed
to
compile
more.
But
then
it
turns.
F
B
B
D
D
So
I
I
didn't
think
people
use
that
anymore.
I
thought
that
was
sort
of
a
90s
90s
way
of
handling
traffic.
A
Back,
I'm
back
so
I'm
seeing
that
there
are
utility
print,
er
and
utility
print
their
print
check,
and
this
guy
has
a
bunch
of
data
that
we
can
test
against
test
smart
contract
against.
D
Yeah
I
already
uploaded
I
already
added
some
of
those
to
the
android
rebro
in
the
test
in
the
test.
Folder.
Oh.
B
Awesome
so
they
should.
B
Okay,
let
me
just
have
another
look
at
this,
so
that
would
be
under
lib.
D
Yeah,
so
I
made
a
new
branch
after
some
editions
after
talking
with
weibo,
so
it's
called
so
the
branch
is
called
at
the
station
editions.
D
C
A
So
so
let
me
let
me
check,
I
just
want
to
make
sure
it's
in
my
note:
yeah
yeah
attestation
editions
yeah,
so
I
know
this
branch.
So
this
piece
of
code,
you
are
showing
me
that
goes.
D
So
actually,
this
is
so
because
I
I
didn't
manage
to
get
all
of
this
ported,
yet
that
it's
in
into
working
to
android
and
without
using
the
proprietary
compiler.
This
is
what
I'm
showing
you
right
now
is,
so
I'm
not
sure
this
is
the
right
way
of
explaining
it,
but
but
but
what
I'm
showing
now
is
is
the
old
code.
It's
the
original
proof
of
concept
code.
I
I
did
that
uses
this,
that
that
uses
this
asn
as
in
the
compiler.
D
D
But
anyway
yeah
you
can
then
get
you
know
an
attestation
and
then
then,
at
some
point
you
want
to
redeem
redeem.
You
you
check
you
basically
based
on
your
attestation
and
your
knowledge
of
the
of
the
of
the
secrets.
D
You
you
decode
the
check,
you
construct
a
a
proof
and
then
you
sign
it
all
and
you
make
it
into
an
asn
asn
1
object,
which
you
can
then
post
to
the
blockchain
and
then
then
the
blockchain
will
verify
all
of
this,
which
is
basically,
as
you
can
see,
here's
a
bunch
of
different
checks
to
ensure
everything
is
in
order
in
order
to
to
pay
out.
D
D
All
right,
okay,
so
so
here's
where
I've
actually
ported
so
so
here
now
we're
on.
D
App
in
the
app
code,
I've
also
tried
to
improve
the
code
quality
and
make
everything
all
nice
and
pretty,
and
all
of
that.
So
basically,
this
is
all
just
based.
I
made
an
attestation
at
the
station
object,
as
you
can
see
here
now
on
the
right
side
of
the
screen,
we're
in
the
attestation
object,
which
basically,
which
has
all
the
what
says
field
for
all
the
different
information
we
want
and
includes,
like
both
a
parser,
both
an
encoder
and
a
decoder.
D
You
create
a
a
new
as
a
station
object
and
you
can
set
all
the
fields
it
has
getter
and
setters
for
all
the
different
fields,
like
version
serial
number
signature
is
your
validity,
smart
contracts
and
all
of
this
it
has
some
check
methods
to
ensure
whether
it's
actually
well
not
complete,
doesn't
check
everything
but
like
it
does
a
rough
check
to
ensure
that
it's
compliant
with
with
x509
and
that
it's
actually
that
the
values
have
been
set
that
needs
to
be
set
and
it
implements
designable
interface
to
to
to
basically
construct
what
needs
to
be
designed
like
this
prehash
thing.
D
Just
what
happens
here
and-
and
I
made
several
constructors
like
a
blank
one,
where
you
then
have
to
set
everything
or
decoding
one
way.
Basically,
you
can
give
it
a
for
convenience
of
usage,
so
you
basically
give
it
an
encoding
of
an
attestation,
and
then
it
passes
this
into
an
object
where
you
can
access
the
things
that
you
would
normally
want
to
access.
D
No
actually
like
in
the
in
in
the
constructor,
it's
it's
here,
it's
it's
the
whole
thing.
It's
it's
not
just
it's
not
just
the
custom.
Theta
object,
it's
the
whole
letter
station,
it's
the
whole
unsigned
x509,
basically,
and
then
there's
for
the
data
objects.
There's
a
getter
and
a
setup.
D
So
this
is
very
general
to
make
it
even
more
easy.
I
made
one
that
basically
just
does
exactly
what
what
we
want,
which
is
yeah.
I
also
made
like
I
made
one,
that's
basically
then
assigned
at
the
station,
which
basically
just
takes
a
key,
and
then
it
constructs
the
signing.
It
takes
an
association
and
a
key,
and
then
it
constructs
assigned
as
a
station,
which
is
then
I
guess,
which
is
then
the
x
509.
D
Basically
and
again,
this
also
supports
both
passing
and
construction
and
passing
and
then
to
make
everything
easier
made
just
like
the
standard
version,
which
is
what
we
actually
want
in
the
check
protocol
in
another
setting.
So
this
you
basically
just
give
it
an
identity,
an
identity
type,
your
your
your
public
key
and
whatever
secret.
You
want
to
get
embedded
in
this
and
then
it
it
sets
everything
on
the
attestation
and
constructs
a
riddle
and
a
proof
of
knowledge
of.
D
D
D
Oh
right
and
then
there's
the
check
object
so
in
the
similar
way
as
an
atta
station
again,
a
check
is
supports
both
passing
and
depressing
into
the
in
into
a
ddr
encoding.
D
And
yeah
also
involves
I
I
for
this.
I
actually
made
three
constructors.
I
made
one
that
basically
constructs
the
check
directly
from
an
identifier
and
a
type
and
an
amount
and
a
validity,
and
the
keys
in
the
secret
then
basically
constructs
the
thing,
along
with
a
proof
of
knowledge,
which
you
can
also
check
out
and
again
one.
You
know
here
to
to
d
pass
it
and
that's
all
like
the
checks
and
encoding
and
decoding
and
and
all
of
it,
this
yeah.
D
A
So
I
hope
to
do
it
in
this
way
that
the
existing
test
code
is
sufficient
to
produce
the
test
test
stations
and
test
the
check
for
smart
contracts
to
work
with
from
the
command
line
of
just
griddle,
and
the
integration
of
that
into
android
goes
a
separate
stream
of
work.
So
both
can
work
and
can
start
at
the
same
time.
D
Yeah,
so
I
I
just
made
some
ports
of
basically
like
dr
dumps
of
the
the
the
stations
in
you
know
a
standard,
bm
format.
A
This
is
generated
from
the
test
code.
Let's
go
yeah,
okay,.
D
So
that's
I'm
just
adding
those
as
well,
so
basically
just
adding
a
dot
from
from
the
says
code,
but
I
mean
whenever
you
run
the
test.
This
will
be
different
because
there's
some
like
randomization
aspects
of
this,
I
don't
have
control
over
my
handset
static.
A
A
C
A
So
so,
if
you,
if
you,
if
you
want
to
deport
it
because
you
think
it's
the
right
way
to
do
it,
then
you
can
go
on.
Otherwise,
you
can
simply
send
the
code
in
zip
file
to
us
with
the
instruction
of
how
to
run
it
and
how
to
compile
it
then,
just
just
start
from
there
to
work
on
a
smart
contract.
D
Yeah,
so
the
issue
with
this
is:
is
that
it's
it's
it's
based
on
the
asn
asn,
the
objective
systems
asm
compiler,
which
means
that
you
need
to
install
a
license
file
even
just
to
run
the
code,
which
is
really
annoying.
A
30
days,
let's
say
30
days,
we
have
done
the
the
porting
to
the
smart
contract
already
so
yeah
so
can
we
can
use
that
and
then
we
just
just
aim
to
get
have
it
done
in
30
days
then,
30
days
later,
this
is
just
a
you
know
the
kind
of
thing
that
people
use
in
the
buildings
building
construction
project
that
they
set
it
up
and
after
the
building
complete
completely
completed
they
just
they
take
them
away.
You
know
yeah.
D
A
A
So
so
I
see
that
the
the
the
reported
code
include
a
test
station,
but
does
it
include
parsing
of
attestation?
Yes,
yes
or
good?
What
else.
A
B
A
Here,
which
is
okay-
maybe
maybe
james
brown-
how
about
we
take
a
closer
look
at
the
dummy
contract
and
figure
out
how
many
things
are
there?
So
we
can
get
timeless
image
of
how
much
effort
it
is
to
put
that
into
smart
contract.
B
D
So
I
mean
basically
that's
a
lot
of
like
like
checking
checking
validity,
so
the
one
thing
I
still
I
still
need
support,
but
it's
basically
based
on
most
of
all
of
the
same
quotas
for
the
proof
and
the
check,
and
all
of
this
is
like
the
encoded
redeem
request
by
the
user
yeah
and.
A
D
Open
basically
yeah,
first
of
all,
like
the
signature,
the
signature
on
the
association
must
be
must
be
verified.
The
signature
on
the
redeem
request
must
also
be
verified.
D
Yeah
verify
the
signature
of
the
check
against
the
senate
that
it's
like
they
sent
us
public
key
like
it's.
Actually,
the
right
person
that
signature
match
is
the
one
who
sent
the
cheque.
D
Then
verify
the
proof,
so
that's
like
quite
a
bit
of
math.
D
Yeah
well
yeah
that
they
that
they're,
both
consistent
like
in
regards
to
the
same.
D
Identifier,
yeah
and
the
riddle,
and
also,
of
course,
verify
that
the
the
proof
value
itself
is
valid
and
then
check
the
check
that
the
check
is
still
valid.
D
So
I
I
don't
so
I'm
not
that
familiar
with
the
with
the
solidity
api,
so
it
depends
a
lot
on
what
you
have
access
to
like
a
lot
of
what
is
what
is
needed
here
is
like
the
verification,
like
the
proof,
verification
and
signature
verification,
and
things
like
that.
A
By
the
way,
yes,
you
said,
you
already
said
that
the
signature
scc
1566
k1,
that's
good
and
the
hashtag
256.
That's
that's
good
for
the
for
now.
D
It
can
also
be
I
also
like
in
what
I
ported
when
I
parted
it.
I
I
looked
up
how
to
actually
do
catch
accents.
I
assumed
this
was
what
you,
since
this
is
what
I
assumed
you
you
would
want
to
want
to
use,
since
it's
all
blockchain
based,
so
it
also
supports
cad
check.
A
B
D
I
made
a
crypto,
I
made
a
class
for
like
the
crypto,
the
crypto
aspects,
so
so
this
is
actually
in
the
android
code,
like
I
already
ported
this,
so
so
here's
the
code
for
constructing
the
proof
constructing
well
constructing
the
proof.
It's
basically
three
methods
like
you
need
to
make
the
riddle
out
from
the
identifier,
which
is
basically
a
hashing,
a
hashing
algorithm
and
then
multiplying
it
with
a
point
curve
multiplication
with
a
secret
and
then
the
proof
itself
is
constructed
is
pretty
simple.
D
If
you
have
the
library,
it's
basically
just
it's
just
these
lines,
I
mean
pick
a
random
value.
Do
a
point,
multiplication,
take
a
bunch
and
take
take
all
the
all
the
challenge,
aspects
and
hash
them
and
then
compute
the
simple
arithmetic
operation,
which
is
like
an
addition
and
a
point
multiplication
and
then
just
return
that
and
then
like
for
the
proof.
Verification
is
what
we
see
here.
It's
also
just
a
bit
of
the
arithmetic.
D
So
if
you
have
the,
if
you
have
this
library
for
like
doing
the
standard
lifting
curve
operations,
then
as
you
can
see
it's
very
easy,
then
it's
just
these
lines
here.
That's
all
of
the
all
it
takes
for
proof,
construction
and
verification,
there's
a
bit
of
like
boilerplate,
hashing
and
stuff
like
that.
But
that's
pretty
that
looks
simple
to
me.
I
mean
basically,
this
whole
class
is,
is
everything
so
it's
180
lines
assuming
you
have
the
right
api
and
you
can
disregard
this.
D
This
is
just
mapping
to
mapping
a
public
key
to
an
ethereum.
So
it's
basically
it's
just
the
actual.
What
actually
needs
to
be
done
is
this
part
here.
A
So
james.
A
The
work
is
to
to
pass
a
check
and
attestation
which
are
similar
to
each
other,
to
verify
signature
and
to
do
this
proof
check,
which
is
just
the
multiplication
and
the
addition
on
the
elliptic
curve,
and
that,
if
we
put
that
three
parts
together,
it
should
be
there.
That's
my
feeling.
B
Yeah,
I
think
the
the
crypto
part
isn't
really
much
of
an
issue
because,
like
tor
said
you
know,
you
have
access
to
all
of
that
in
solidity.
I
think
the
biggest
part
of
it
is
going
to
be
the
parsing,
which
is
probably
what
you
would
agree
with
as
well.
There
were.
B
There
are
a
few
points
in
the
source
code
that
I
was
looking
at
to
see
if
I
don't
understand
how
they
would
work,
but
I
think
the
best
thing
for
those
would
be
to
when
we
hit
those
to
get
clarification
on
those.
That's
right.
B
Yeah
the
electric
curve
stuff
I
get,
but
the
there's
a
lot
of
other
stuff.
Like
the
asn
one
vector
you
had
some
math,
you
had
some
math
there,
which
I
don't
really
know
what
that
does.
D
Okay,
so
I'm
actually
not
sure
this
is.
Is
it
this
part
here.
B
D
Yeah,
okay,
so
basically
I
was
looking
online
of
how
to
officially
like
of
how
was
the
correct
way
of
passing
of
passing
an
elliptical
signature
from
from
bouncy
castle
into
a
signature
object
in
asn1
and
at
least
from
what
I
could
find
on
the
answers.
It
might
not
be
necessary.
It
might
be
able
to
accept
without
this,
but
this
is
just
a
it's.
It's
just
a
way
of
normalizing
one
of
the
automatic
values
that
comes
out
from
from
the
signature.
D
D
So
I
think
I
think
the
only
reason
of
this
is
is
otherwise
there's
a
risk
that
the
number
might
be
larger
than
expected.
I
mean
because
there's
like
some
extra
stuff
added
on
top
of
it,
that
that
doesn't
make
a
mistake,
but
it's
not
needed.
So
I,
okay.
D
Yeah,
so
I
think
you
could
could
I
think
things
would
verify
without
it,
I'm
not
sure
if
standards
would
be
happy
about
it.
That's
that's
the
point.
E
D
D
Yeah,
it
still
works,
so
it's
just
yeah,
that's
it
it's
not
it's
not
essential.
So,
even
if
you
don't
do
it,
you
can
see
it
still
works.
So
yeah.
D
The
math
works.
The
question
is
the
encoding.
C
A
A
And
as
it
produced
the
output
I
can,
I
can.
I
can
write
an
email
of
the
command
to
run
to
dump
the
tree
tree
structure
of
the
vr
object.
A
A
B
Well,
it
looks
like
it
looks
like
a
lot
of
the
work's
been
done
like
the
the
the
der
pausing,
I
think,
needs
to
be
expanded,
a
lot
and
also
converted
into
a
into
into
a
spike
stream,
rather
than
rather
than
array
which
it
is
at
the
moment.
But
that's
that's.
That's
some
fairly
standard
work.
I
think
we
should.
A
Yeah,
that's
reasonable,
too.
I
think
I
need
to
work
with
you
together
on
this.
I
will
I
will
go
through
the
code
and
then
and
have
a
good
understanding
of
myself
just
in
case
we
we
didn't
anticipate
something,
and
yes
do
you
think
you
are
afraid
to
do
this.
I
think,
as
you
do
this,
we
might
need
a
frequent
meeting
with
paul.
B
For
sure
yes
well,
I
think
like
basically
what
I'll
do
the
same
as
you
get
familiar
with
it
over
the
weekend,
and
then
we
can
start
in
earnest
during
the
week.
D
So
I
I
would
like
to
get
the
rest
espec
rest
of
the
the
code
ported
just
to
have
the
full
flow
here,
because
I
think
it's
gonna
be
more
confusing
than
not
looking
at
two
different
different
implementations
where
one
actually
runs
and
the
other
might
might
not,
depending
on
the
licenses
in
particular.
Since
I
already
got
like
the
essential
aspects
ported,
which
is
which
is,
of
course,
the
the
attestation,
the
check
and
or
the
the
proof
verification
stuff.
D
A
Yeah
so
so
I
think
the
most
part
has
value
if
you
put
it
over,
but
the
dummy
part
yeah.
C
A
Yeah,
so
if
you,
if
you
send
us
hot
weather,
dummy
we'll
be
happy
to
do
that,
but
I
know
that
eventually
we
need
to
generate
hesitation.
We
generally
check.
We
need
to
generate
proof,
knowledge
proof.
So
so
we
need
them
ported
in
a
certain
way,
but
the
dummy
we
will
we're
happy
to
just
run
it.
So
so,
if
you
send
it
us,
we
will
use
it.
D
Yeah
I
mean
you
can
use
the
other
like
what
I
made
previously,
if
you
just
install
like
the
license
file,
if
you
ask
the
objective
systems
for
a
trial
and
basically
just
install
that
you
can
just
check
out
the
project
from
from
the
github
repo,
it's
basically,
you
know
in
the
blockchain
at
the
station
and
just
run
the
main.
The
main
method
does
everything
and
it
prints
all
the
asn
1
objects,
as
well
as
part
of
the
process.
A
Okay,
good,
that's
that's
good!
So
that's
the
utility
print
stuff
actually
part
of
their
library.
D
But
I
also
that
that
that's
all
supported
super
simple
stuff
I
also
hold
on.
Let
me
show
you.
I
also
have
this
in.
A
A
A
Okay:
okay,
fine,
fair,
fair,
that's
reasonable,
so
everything
that
is
supposed
to
be
integrated
finally
into
android
is
in
android,
and
the
the
whole
process,
as
well
as
the
dummy
smart
contract
is
infestation
shouldn't
that
I
would.
C
A
A
D
But
I
think
that
it
shouldn't
take
long
to
just
get
this
get
this
in
android.
So
we
have
the
whole
thing
running
in
the
same
same
library
without
any
license
issues.
D
A
I
guess
thank
you
and
we
are
we're,
starting
at
the
three
quarters
mark
right
right
on
time.
We
do
work
on
this
and
we
keep
busy
communication.
Okay,.
D
Yeah,
so
I'm
still
up
there
I'll
I'll
try
to
get
get
some
of
the
last
things
fixed
in
this
today
in
the
android.
D
A
Okay,
yeah,
okay,
okay,
so
so
far,
so
good.
Thank
you
very
much.
D
Oh
one
more
thing
I
need
to
mention
so
simon,
basically
just
quit
his
job,
so
so
I'm
gonna
have
to
find
another
another
guy
yeah.
He
is
going
back
to
work
for
the
bank
where
he
used
to
work
yeah.
I
guess
he
didn't.
Okay,
he
didn't
like
more
varied
and
exciting
tasks.
I
guess.
D
D
A
Yeah:
okay,
thank
you.
Yeah,
okay,.