►
From YouTube: TokenScript Weekly Meeting 20200806
Description
00:02:31 weiwu: https://community.tokenscript.org/t/tokenscript-43/412
A
B
No,
I
was
also
here
last
week
I
was
also
at
the
meeting
last
week
was
you
were
in
the
last
meeting
last
week
right,
oh
yes,
and
last
week
we
wanted
to
arrange
you
a
meeting
with
you
and
james
brown
on
how
to
insert
a
data
station
related
code
into
james
brown's
code
base
and
james
brown
said
that
he
was
too
busy.
B
So
I
took
it
on
myself
to
study
the
code
structure
in
this
part
and
ask
for
james
brown
to
permission
that
that
this
is
the
part
that
I
want
to
change
and
he's.
He
says
he
kind
of
said.
Okay,
so
I'm
going
to
point
out
where
the
code
is
and
how
we
are
going
to
change
it
so
that
we
can
connect
to
attestations
okay
and
then
we
let's
wait
for
james
brown
for
a
while
and
if
he
doesn't
show
up.
B
I
will
point
you
to
the
code
that
he
said
yes
to
me
and
hope
he
didn't
deny
it
later.
C
Hey
everyone,
hello,
yep,
let's
wait
for
him
and
also
james
sangali
was
mentioning
about
something
about
the
agenda
right.
So
it
would
be
great
when
you
know
if
we
can
start
with
the
agenda,
then
james
brown
jones
did
you
say
that
jim
sangan
has
agenda?
C
Yes,
james
was
asking
what
would
be
the
agenda
today
in
the
group
channel.
So
if
you
can.
B
Able
to
follow
that
agenda.
That
agenda
was
the
items
that
we
didn't
fail
to
do
in
the
previous
meeting
stacking
up,
but
today
we
might
also
talk
about
implementation,
not
only
the
design
and
in
terms
of
implementation.
B
We
will
touch
how
james
brown
is
going
to
work
with
paul
and
me
getting
a
test
station
working
for
android.
B
B
Okay,
so
when
do
you
think
james
bro.
B
D
D
So,
what's
on
the
on
the
list
today,.
B
Okay,
so
I
want
to
talk
touch
about
implement
touch
a
little
bit
about
implementation
too.
So
the
design
agenda
is
on
the
messaging
you
can
see
in
the
chat
group,
but
I
think
we
will
only
choose
a
few
design
items
in
it,
because
I
really
want
to
make
some
time
to
talk
about
implementation.
D
B
Yeah,
okay,
so
let's,
let's
start
with
the,
I
hope
I
can
eliminate
a
few
shortest
agenda
on
the
gender
list,
so
we
can
make
progress
on
some
design
agenda.
Then
we
go
to
implementation
as
quickly
as
possible,
specific,
specifically
implementation
of
attestation.
So
I
think
we
probably
would
we
will
we
will?
We
will
not
talk
about
deck
today.
The
first
item:
are
you
seeing
the
same
page
as
I'm
saying.
B
B
Okay,
so
the
first
agenda
item
is
a
little
bit
too
big.
I
think
we
should
fit
another
special
specific
token
script
meeting
for
it,
but
to
put
briefly,
there
are
a
few
candidate
methods
of
implementing
a
deck,
and
my
favorite
method
is
to
use,
expect
so
expect
work
in
that
such
a
way
that,
if
you
have
token
card
you
can
write
expect,
which
is
the
condition
for
this
token,
to
work
and
then
any
card
that
can
satisfy
that.
That
expectation
is,
is
able
to
form
a
deck
with
you.
B
So,
for
example,
if
you
want
to
deposit
your
dye
into
into
a
compound,
then
one
of
the
condition
is
that
the
compound
code
token
is
approved
as
to
operate,
die
contract
on
behalf
of
the
user.
Then
you
can
write
that
expectation
into
the
card.
That's
that
is
a
deposit
deposit
die
into
seed
eye
requires
expect.
That
is
which
was
authorized
already
approved
already,
and
a
approved
card
can
serve
the
proven
function
and
if
it,
if
it's
right,
it's
an
anticipated
the
effect.
B
So
every
card
has
the
effect
and
hybrid
card,
as
you
expect,
and
as
does
they
connect,
they
are,
they
are
used
in
the
deck.
B
B
Sounds
good,
yeah.
Okay.
The
second
item
is
by
default.
We
have
this
ordering
in
token
card
and
in
cards
which
was
ordered
and
simply
because
the
default
options
they
are
ordered,
but
I
feel
that,
and
it
doesn't
make
sense
to
enforce
the
order,
and
I
couldn't
think
about
about
a
good
good
reason
why
we
should
enforce
order.
So
I'm
proposing
a
lot
random
orders
in
elements
in
tokens
and
cards
so
in
the
card.
B
Output,
all
all
even
even
card
attributes
and
views
in
any
random
order.
What
what
do
you
think
and
how
much
random
randomness
we
should
allow.
D
I
agree
that
we
shouldn't
specify
an
order
to
put
things
in
it
makes
it
it
makes
it
less
susceptible
to
people
getting
it
wrong.
B
B
Okay,
so
so
you
prefer
to
have
the
order,
but
you
prefer
to
have
to
have
a
current
order
or
change
a
little
bit.
The
current.
A
One
well,
the
one
one
reason
is
well
one
reason
that
it's
not
necessary
to
support
random
order
is
when
you
build
the
file,
it
should
tell
you
that
it's
wrong.
B
B
A
B
Okay,
so
this
is
the
easy
item
we
consumed.
One
item
just
just
now:
framework
for
defining
multiple
tokens
described
in
one
contract.
This
is
this
is
a
topic
of
30
minutes,
so
we
cannot
do
this
actually
token.
Script
should
use
either
token
or
cards,
and
it
should
not
use
a
card
as
root
element.
B
I
think
this
is
easy
decision
like
when
we
want
to
make
an
action
only
token
script.
We
use
the
card
as
a
lieutenant,
which
means
there
can
only
be
one
action,
and
so
so
cars
is
more
reasonable.
I
guess
if
you
want
an
action,
not
only
token
script
and
we
only
have
one
which
is
the
the
so
far
the
exercise,
it's
easy
to
change.
B
Oh,
we
only
have
one
action,
only
token
script,
which
is
convert
diet,
convert
extra
to
that
okay,
write
down.
A
So,
given
that,
for
as
part
of
activities,
we
want
to
be
able
to
support
a
base
based
template
like
erc20
and
then
be
able
to
override
it,
does
it
mean
that
we
can
use
yeah,
but
does
it
mean
that
we
can
use
the
same
same
mechanism
and
do
away
with
action-oriented
token
scripts?
Okay,
so.
B
B
B
Okay,
so
so
we
we
talked
about
this
very
briefly,
the
last
token
script
meeting,
that
is
how
to
access
the
the
inputs
right.
B
So
we
say
that
so
we
see
that
we
say
that
in
a
card,
usually
there
are
two
name
spaces.
One
is
the
card
attribute.
The
other
is
the
token
attribute
right,
that
is
for
for
a
simple
token
script.
But
if
you
have
input,
then
the
input
is
provided
in
the
in
its
own
namespace.
So
we
have
that
so
so.
Just
think
that
previously
we
have
a
token
attribute
supplied
by
update
function
as
a
single
chunk
of
data,
but
now
you
might
be
able
to
provide
more
than
one
parameter.
B
B
B
And,
and
if
you
with
the
actual
only
token
script,
you
won't,
you
only
get
action
cards,
so
you
need
to
associate
it
with
the
token
through
input
which
is
which,
which
gets
you
something
like
this?
A
B
Yeah
yeah
that
will
do
javascript,
yeah
okay,
we
can
do
that
so
so
that's
the
actual,
only
token
script.
So
what
I
would
have
proposed
is
simply
that
allows
cards
to
be
the
to
be
root,
element
and
change
the
example
so
that
they
can
be
more
than
one
cards
in
one
action.
Only
talking
script,
that's
a
small
one.
I
thought
they
can
finish
the
conversation
about
it
and
the
the
the
other
one
about
using
erc20
as
an
as
a
as
a
as
a
template
as
a
library.
B
That's
that's
related
to
this
one,
because
it
also
concerns.
How
do
you
get
the
token
some
kind
of
token
definition
like
connectivity
stuff
right?
So
I
think
we
cannot
finish
this
this
one
today,
but
I
can
write
it
here,
okay,
so
this
is
something
I
propose.
That
is
first,
and
we
already
know
that
we
already
said
that
we
want
to
use
distinct.
B
B
Yes,
yeah,
it
has
a
few
benefits,
and
so
we
were
discussing
that
times.
I
won't
repeat
this
this
time
that
one
is
necessarily
going
to
retire
origins
for
tokens,
because
now
the
tokens,
the
number
of
tokens
and
existence
of
token
is
not
no
longer
decided
by
origins
and
my
proposal
is,
we
use
origins
for
introducing
a
lot
of
token
attributes
in
one
go
so
right
now,
if
we
have
a
token
attribute
I'll,
do
this.
B
B
Oh
yes,
this
is,
this
is
the
code
that
should
be
if
we
didn't
use
a
fallback.
So
here
look
at
these
lines.
B
Okay,
so
in
the
maker
a
smart
contract
function,
call
is
specified
and
then
there's
a
select
which
selects
and
there
is
a
a
type
which
is
called
user
reserve
data.
B
B
B
That
is,
you
have
token,
and
you
have
origins
and
inside
of
which
there
is
a
a
contract,
or
there
is
a
test
station
saying
then
you
get
you
get
data
from
the
smart
contract
function
call
and
instead
of
using
select,
the
entire
data
set
provided
by
the
type
are
taken
in
as
token
attributes.
B
A
B
Well,
I
think
we
don't
it's
either
a
call
followed
by
a
test
station
or
a
call
just
a
call,
or
if
it's
a
virtual
token,
then
it's
a
call
to
the
website,
because
we
expect
the
type
to
be
custom
defined
and
they
probably
will
grow
it's
already
growing
in
in
terms
of
attestation,
because
you
can
add
another
field
to
it
and
just
change
the
schema
in
a
smart
contract,
maybe
maybe
not
solely
only
the
upgrade.
B
B
Case
because,
with
this
original
call,
every
every
data,
every
member
of
the
type
user
reserve
data
will
register
as
a
new
token
attribute.
If
you
have
two,
you
can
call
it.
B
B
Okay,
so
let's
step
back
one
step,
so
data
module
was
designed
so
that
you
can
have
them.
B
It's
good
it's
getting
it's
getting
past
time.
I
want
to
implement
this.
Can
we
do
this
next
time
this?
Actually
I
thought
this
is
a
short
topic.
None,
but
now
we
cannot
finish
this
anymore
and
it's
reasonable,
because
this
is
delicate
topic.
Can
we
can
we
move
this
next
one,
so
we
can
at
least
talk
a
little
bit
about
the
implementation.
B
B
Yeah,
the
original
business
distinct.
We
will
not
have
time
to
use
this
address
this
and
this
list,
the
tokenization
guide
project,
is
going
on
as
part
of
the
document
stream.
B
I
feel
this
work
is
interesting
for
the
for
us
here,
because
if
you
have
use
cases,
it's
easier
to
make
your
to
think
of
design
in
the
context
of
use
cases,
and
so
this
is
a
welcome
letter
for
it's
a
suggestion
for
any
team
member
to
join
the
document
workshop,
which
happens
every
week
right
after
this
meeting,
and
it
has
been
been
going
on
for
five
to
ten
times
and
some
works
are
created
for
it
from
it.
I
know
this
one
is
really
old.
B
The
first
one
is
actually
created
in
2018,
but
this
one
is
new
like
the
door
token-
and
I
think
james
brown
is
especially
interested
in
that
one
too.
B
So,
if
you
want,
if
you
want
to
the
meeting,
starts
at
eight
o'clock
every
thursday
and
ends
in
nine
o'clock,
every
thursday,
typically
christoph
and
lucas
will
be
active
in
the
meeting
where
they
they
go
and
look
at
use
cases
of
organization
with
defy,
as
well
as
outside
of.
E
B
As
long
as
there
is
a
business
case
to
be
made
out
of
it
and
and
then
and
then
create
token
tokenization
scenarios
from
there,
so
this
is
an
announcement.
Would
anyone
of
you
be
interested
in
this.
B
Yeah,
okay,
good!
So
back
to
the
the
last
point
of
the
integration
of
implementation,
and
so
this
is.
I
think
this
is
what
we
decided
last
time,
but
I
want
to
reiterate
it
so
everybody's
on
the
same
page:
first,
that
there
is
a
javascript
api
for
creating
data
objects
as
well
as
reading
that
object.
B
Right,
yeah,
yeah,
okay
and
the
writing.
One
is
actually
discussed
a
few
meetings
back,
but
documentation
was
not
very
well
written
yet,
but
it's
already
on
forum
post
and
the
documents
will
be
following
really
soon.
The
writing
interface
is
the
discussion
of.
B
Yeah
yeah
yeah,
so
this
is
a
thread
where,
where
the
the
the
right,
the
creation
of
of
an
that
object,
is
here
so
so
we
agreed
previously
was
number
one
that
the
data
objects
are
available
for
the
web
as
well
as
token
script
to
read
and
second
data
objects
are
created
based
on
a
type
in
the
module.
B
Module
is
likely
done
in
javascript
too,
so
when
that,
when,
when
the
data
object
is
passed
to
android
or
ios,
it's
already
encoded
and
waiting
to
be
signed.
According
to
the
attestation
format
that
we
standardized,
we
have
draft
standard
standard
from
tor
based
on
x509,
so
javascript
reads:
we
have
javascript
api
for
ts
to
read
data
data
object.
We
have
javascript
api
for
token
script,
cards
to
construct
that
object
and
the
android
and
ios
does
not
care
about
how
object
is
made.
B
A
B
At
the
the
first
prototype
and
I'm
asking
bara
to
create
after
our
previous
discussion
that
pushes
the
responsibility
of
creating
data
object
to
javascript
was
done
in
the
web
view,
but
I
envision
this
code
will
be
needed
to
be
run
outside
of
webview
too,
for
example,
in
order
to
display
the
data
object
in
the
action
sheet.
A
Yes,
I
ask
because
if,
if
we
generate.
A
E
Is
so
yes
yeah
exactly?
I
was
thinking
exactly
the
same
yeah
yeah.
The
issue
is
it's
like,
of
course,
there's
not
an
issue
if
it's
already
running
within
the
app
online
or
so
android,
because
then
we
know
that
javascript
itself
is
trusted
and
we
can
trust
the
the
object
that
results
from
this.
But
if
it
comes
from
an
arbitrary
web
page
of
that
view,
that's
just
simply
sent
to
to
the
app
to
be
signed
where
the
ad
doesn't
care.
What's
in
it,
that's
that's
a
problem.
B
Yeah,
of
course,
that's
right,
so
we
implement
it
in
webview
because
we
don't
know
how
to
implement
it.
Otherwise,
I
don't
want
to
to
to
think
too
much
about
it
until
a
webview
implementation
is
available
and
then
port
it
to
somewhere
outside.
E
Yeah,
it
makes
sense.
That's
a
good
first.
B
Step
yeah:
well,
I
want
byron
to
create
something
without
getting
him
his
hands
dirty
with
the
mobile
phone.
So
his
work
is
only
purely
on
the
web.
He
doesn't
touch
mobile
phone
until
he
created
something
and
then
we
we
we
ask
him
to
put
into
mobile
phone.
Then
then
we
right
now
by
writing
already
and
like
are
doing
quite
well.
But
if
I
think,
if
I
load
more
information
to
him,
it
will
not
work
as
well,
so
it
takes
take.
B
Take
steps
yeah,
that's
my
answer
sounds
good
yeah
and
then
apparently,
there
will
be
javascript
interface
for
for
for
for
token
script,
engine
alpha
wallet
and
android
and
ios
to
obtain
some
key
data
in
the
in
the
that.
C
B
And
this
this
is
the
first
thing:
implementation
wise
for
this
to
work.
I'm
doing
part
of
the
refactoring
here,
which
is
called
signable,
and
so
this
isn't
done
on
android,
so
go
is
previously
a
message
to
be
signed
in
alpha
wallet.
Android
is
just
a
message
which
is
just
a
string.
B
With
a
few
few
formatting
related,
I'm
creating
an
interface
called
signable
and
then
try
to
re
make
alphabet.
Android
use
designable.
B
And
later,
when
we
do
a
test
station,
we
can
use
the
sendable
interface
to
create
a
test
station
and
hope
the
android
code
will
handle
the
signing
accordingly,
and
this
is
a
this
is
how
I
think
how
a
testation
related
code,
the
implementation.
B
Of
course,
draft
standard
is
going
to
be
done
through
implementing
assignable
interface
and
it's
still
working
progress
because
thunderbolt
only
first,
I
only
replace
the
bit
of
it
and
replace
the
code
that,
with
the
message
with
assignable
interface,
I
still
have
to
reach
it
so
that
later
it
can
handle
the
things
related
to
to
a
test
station.
For
example,
in
the
test
station,
the
the
the
signing
algorithm
is
inside
inside
the
the
the
to
be
signed.
E
B
And
that
necessarily
will
mean
that
we
need
to
extend
this.
So
what
I
did
is
I
moved
assignable
interface
and
all
of
the
classes
that
implements
this
interface
into
the
lib
folder
from
the
app
folder
into
the
lib
folder
library,
so
that
I
can
later
share
this
and
make
it
possible
for
tor
to
work
on
accepting
an
attestation
signing
verifying
the
test
station
by
purely
working,
the
library
and
test
cases.
B
Instead
of
doing
the
debugging
on
android
phone
and
later
connect
it
back
to
the
android
when
barrett's
work
of
javascript
api
is
done.
B
B
He
does
do
all
the
work
on
the
web
without
touching
the
ios
and
android
code
and
then
tor
works
on
what
android
needs
to
do
by
test
cases
and
by
the
source
code
in
lab
folder
everything
works
on
goes
into
the
leave
folder
not
into
the
alpha
wallet
android,
and
when
both
streams
of
work
is
done.
B
Okay,
yeah,
okay,
so
so
I
will
write
a
separate
email
to
to
to
once
once
I've
done
this
part
of
the
refactoring,
so
that
soundable
is
used
in
what
is
android
and
I
will
pass
you
the
location
of
the
files
and
then
then
we
can.
We
should
be
able
to
do
that.
B
Also
barrett
needs
needs
probably
will
need
some
that
object.
That
is
already
encoded
to
check
if
his
code
is
correct,
this
will
happen
three-way
between
me
and
tor
and
barrett
in
a
separate
email
discussion,
or
maybe
the
forum
discussion,
you
know
just
to
build
test
cases
that
works
for
both
sides,
which
can
allow
later.
E
Right
yeah,
so
I
think
we
already
have.
I
already
have
some
cisco
from
like
the
reference
implementation.
I
did
for
the
the
czech
protocol,
which
I
also
verified,
like
against
passing,
basically
passing
it
at
the
station
as
an
smx
x,
509
that,
like
an
x519,
passes,
still
excess
the
attestation
and,
like
the
implementation,
produced
the
specific
information
of
the
attestation
as
well.
So
I
think
that
that
was
very
easy
to
together.
B
Okay,
okay,
all
right.
Let's
plug
that
to
the
signal
interface
once
I
tweaked
it
yeah
and
I
think
that's
the
implementation
detail.
Actually
we
still
have
five
minutes.
So
maybe
we
come
back
to
the
agenda.
B
So
how
do
I
put
this
boon?
Can
we
go
back
to
the
topic
where
I
I
post,
which
is
about
who
owns
the
data
module?
So
let's
say
there
is
a
car
token,
and
what
can
happen
is
that
the
module,
the
car
that
car
data
module
can
be
provided
by,
let's
say,
a
standard
organization
which
contains
necessary
information
like
the
car
vehicle
number,
for
example,
and
that
can
be
imported
into
any
contracts
who
wants
to
produce
a
token
related
to
car
use.
B
Designed
to
be
a
pluggable
module
with
important
stuff,
but
we
never
managed
to
to
practice
the
import
syntax
in
our
token
script
and
yeah.
So
so
I'm
thinking
that
maybe
we
only
allow
one
if
we,
if
we
actually
do,
allow
it,
but
it
can,
if
which
one,
then
it's
still
a
problem.
B
B
B
A
B
Yeah,
okay,
let's
let's,
let's
hold
down
to
this
and
the
next
week-
look
at
this
again
and
if
we
still
think
it's
feasible
and
not,
and
all
the
other
use
cases
that
comes
to
my
mind
can
use
this.
We
will
fix
it
next
time
and
the
way
we
look
at
whether
or
not
the
design
fits
use
case
is
to
also
work
with
document
group
and
tokenization
use
case
study.
B
Victor
has
produced
a
tokenization
what
he
calls
tokenization
framework
and
how
to
tokenize
anything.
That
was
a,
I
think,
that's
pretty
good
document,
but
it's
not
publicly
shared
and,
and
it's
it's,
the
way
it
is
written,
is
not
suitable
for
public
sharing
either.
B
But
victor
already
had
a
meeting
with
us
and
and
showed
his
framework
of
thinking
on
how
to
tokenize
it.
And
how
would
you
know
from
the
aspect
of
how
that
business
benefit
from
tokenizing
anything?
How
would
individual
benefit
from
organizing
anything
and
what's
that
obstacles
and
what
are
the
needed,
the
dependencies
for
for
technical
dependencies
as
well
as
organizational
dependencies,
so
that
if,
if
there
is
a
tokenization
idea,
it
can
be
fit
into
this
and
quickly
figured
out
what
has
to
be
done
that
is
implemented
and
what
the
benefits
that
is.
B
That
is
done
through
the
last
documentation
session.
I
think,
or
some
some
kind
of
documentation
and
discussion
session,
which
I
hope
later
expands
to
this
group
as
well,
but
so
far,
if
you're
interested,
we
have
15
minutes
of
rest
and
the
document
workshop
will
start
in
by
by
by
apn.
D
Is
it
the
same
link.
B
C
Yeah
previously
it
was
on
tuesdays,
then
you
know
just
for
this
week.
We
moved
it
to
wednesday
and
then
our
thursday.