►
Description
Follow the latest from NEAR Protocol on:
Website: https://near.org/
Discord: https://near.chat/
Blog: https://near.org/blog/
Twitter: https://twitter.com/NEARProtocol
GitHub: https://github.com/near https://github.com/nearprotocol
#Blockchain #FutureIsNEAR #NEAR #nearprotocol
A
And
without
further
ado,
josh
welcome
to
the
stage.
B
Nice,
hello,
hello,
hello,
hello.
There
we
go
good
morning,
everyone
after
this
last
year
of
isolation
and
dealing
with
covid,
it's
so
wonderful
to
be
here
with
everyone
in
person
and
really
feeling
the
energy
of
this
growing
near
community.
B
So,
let's
just
jump
right
into
it.
Today,
I'm
going
to
talk
about
what's
new
in
developer
tooling,
and
I'm
going
to
give
you
a
little
sneak
peek
of
something
we
started
working
on,
that
we
for
now
call
developer
console,
but
first,
who
am
I
to
be
giving
you
this
information?
Well,
as
michael
so
nicely
introduced
me,
I
am
josh
quintel,
I'm
the
product
manager
of
developer
platform
at
near,
like
you
said,
I
started
pretty
recently
and
have
you
been
in
the
space
for
a
while
about
five
years?
B
Did
consensus
and
truffle
previously,
I'm
also
going
to
be
exporting
these
slides
after
this,
so
you'll
be
able
to
click
on
a
lot
of
these
links
that
you'll
see
so
developer
platform.
What
does
that
mean?
So
we
can
really
sum
it
up
with
this
one
sentence
right
here
so
developer
platform.
We
aim
to
empower
all
developers
to
build
complex
applications
with
simple
tools
across
the
entire
software
development
life
cycle
or
put
another
way.
We
want
to
get
those
ideas
out
of
your
head
into
the
near
verse
without
getting
in
your
way.
B
What's
this
software
development
life
cycle
all
about
well,
probably
already
doing
this
if
you've
doing
or
have
done
any
kind
of
development.
This
is
a
really
nicely
condensed
version
of
it
that
we
have
here
focuses
on
this
core
loop
of
coding.
So
this
is
developing
your
smart
contracts.
Developing
your
front,
end
testing,
of
course,
testing
those
things
deploying
them
to
a
live
network
or
to
your
hosting
provider,
which
is
hopefully
decentralized,
storage
and
then
finally,
monitoring
the
usage
of
the
application
to
then
analyze
that
and
plan
your
next
iteration.
B
So
we're
going
to
kind
of
use
this
to
anchor
the
presentation
and
I'll
go
through,
like
all
the
tooling
updates
and
talk
about
that
dev
console,
so
first
up
is
near
cli,
so
near
cli
is
having
some
big
changes
coming
to
it.
It's
a
ground-up
rewrite,
and
so
first
off
interactive
props
are
going
to
be
part
of
this.
So
let's
say
you're
new
to
development
or
you
just
don't
want
to
have
to
google
all
of
the
options
that
might
be
necessary
for
a
particular
method.
B
We're
just
going
to
prompt
you
for
those
if
they're
not
filled
in
so
really
nice
upgrade
to
the
development
experience
there.
Next
up
structured
logs.
These
are
really
important
if
you're
scripting.
This
is
going
to
let
you
digest
the
output
of
your
logs
much
more
easily,
no
more
having
to
parse
strings
or
do
any
weird
juggling
like
that
of
those
results.
B
Next
up
key
management,
so
this
is
going
to
be
very
much
improved,
managing
multiple
keys,
managing
api
keys
for
our
pc
providers,
things
of
that
nature
so
also
much
more
flexible
experience
and
then
kind
of
dovetailing
off
of
that
configuration
files.
So
these
are
things
like
setting
the
network
you're
going
to
deploy
to
setting
of
things
like
your
contract
output
directory,
really
just
giving
you
that
customization
that
is
really
important
and
then
finally,
it's
actually
going
to
be
written
in
rust.
B
The
current
cli
in
javascript
so
running
it
in
rust
will
give
us
some
nice
security
guarantees
and
also
you
know,
kind
of
help
prevent
a
supply
chain
attacks.
Things
like
that,
but
I
didn't
even
mention
the
most
exciting
part
of
the
new
cli
changes,
and
that
is
that
the
new
cli
is
going
to
be
extendable.
B
So
you
can
write
your
own
extensions.
You
can
actually
write
them
in
any
language
and
we
at
near
actually
first
party
going
to
work
on
two
extensions
right
out
of
the
gate,
so
the
first
one
is
a
validator
extension.
So
this
is
really
nice.
If
you're
a
validator
you're,
you
know
it's
not
going
to
be
any
like
interruption
in
the
way
you
currently
work.
B
But
if
you
are
not,
this
will
give
you
a
bit
of
a
lighter
weight
cli,
since
you
won't
be
needing
that
functionality
and
then
secondly,
there's
going
to
be
a
project
extension
which
I'm
going
to
talk
about
here
in
a
second
but
essentially
allowing
you
to
manage
your
local
near
development
environment
in
a
bit
of
a
better
way
than
we
currently
handle
it.
B
So
speaking
of
that
the
project
extension
just
a
couple
of
examples
here
so
there's
you
can
initialize
a
new
project.
You
may
have
currently
done
this
through.
Something
like
create
react,
create
near
app
or
something
like
that,
but
this
will
now
initialize
a
new
empty
project.
We're
going
to
go
over
the
structure
here
in
a
second,
so
really
nice
very
easy
way
to
get
started,
and
then
second
here
I
demonstrate
there's
this
compile
command
and
currently
the
way
the
workflow
for
development
works.
B
Is
it's
really
just
the
language
native
tools,
so,
if
you're
building
your
smart
contracts
in
rust,
you're
using
cargo,
for
example-
and
so
this
is
going
to
allow
us
to
kind
of
abstract
over
these
languages
and
deal
with
multi-language
projects
a
little
bit
better.
But
very
importantly,
it's
going
to
allow
us
to
do
additional
things
besides
compiling
to
webassembly-
and
in
this
case
it's
going
to
generate
what
we're
calling
an
aci
or
an
abstract
contract
interface.
This
is
really
helpful
for
front-end
development
so
that
you
can
more
easily
interact
with
your
contracts.
B
So
speaking
of
that
project
structure,
here's
an
example
right
here
within
our
project,
folder
we've
got
that
configuration
file
I
mentioned
so
you
know,
networks
build
folders
things
of
that
nature,
and
then
you
have
your
contracts
folder.
So
a
little
bit
more
of
an
organized
structure
here
in
this
example,
this
is
a
rust
project,
so
we've
got
our
greeter
contract
and
then
we
have
that
extra
cargo
dot
toml
for
the
workspace
there.
B
So
speaking
of
additional
languages,
as
you
may
or
may
not
know,
we
currently
support
rust
and
assembly
script.
But
the
great
thing
about
nir
right
is
that
our
virtual
machine
is
runs
web
assembly.
So
any
language
that
can
target
web
assembly
for
compilation
can
potentially
have
a
near
sdk
and
to
that
end
the
teams
at
grain
and
zig
languages
are
working
on
near
sdks.
Currently,
so
I
want
to
check
those
out
if
you
are
interested
in
new
languages.
B
So
now
that
we've
done
our
coding,
we've
built
our
smart
contracts.
We've
worked
on
our
front
end,
it's
time
to
start
testing,
but
you
know,
of
course,
you've
been
writing
tests.
The
whole
time
you've
been
coding
like
a
good
developer,
but
in
this
case
we'll
call
it
a
separate
thing.
So
there's
been
some
really
big
changes
and
actually
like
a
massive
leap
here,
an
improvement
of
the
experience
of
testing
and
also
just
what
you
can
test
and
kind
of
how
the
environment
works.
B
So
we've
just
released
or
sorry.
These
tests
actually
now
use
something
called
near
sandbox.
So
previously
there
was
these
things
called
simulation
tests,
but
the
advantage
of
near
sandbox
is
it's
actually
just
a
near
core
node
with
some
additional
functionality.
That's
really
helpful
for
development,
so
this
gets
you
a
lot
closer
to
like
what
the
live
network
is
actually
going
to
be
doing
with
the
addition
of
things
like
patching
state.
So
this
is
really
helpful
for
seed
data
in
tests.
B
This
allows
you
to
massively
update
state
without
even
having
to
send
a
transaction
and
then
secondly,
there
spooning,
which
we
are
definitely
going
to
highlight.
That
is
a
very
important
feature
that
allows
you
to
actually
take
a
contract
from
a
live
network,
pull
it
down
into
your
local
environment
and
then,
of
course,
you'll
be
able
to
integrate
with
that
test
against
it
without
spending
real
near
for
talking
about
mainnet,
for
example.
B
More
importantly,
you
can
write
once
and
run
on
any
network,
so
these
tests
they'll
run
in
the
sandbox
by
default.
It's
just
one
configuration
option
away
to
get
them
to
run
on
test
net
they're,
going
to
be
able
to
run
concurrently
so
really
great
for
speed,
of
course,
having
them
run
in
parallel,
rather
than
one
after
the
other
and
speaking
of
flexibility,
you'll
be
able
to
write
these
in
rust
or
javascript.
B
So
if
you
want
that
full
stack,
rust
experience,
it's
there
for
you,
if
you
prefer
to
write
them
in
javascript,
because
that's
how
your
frontend's
going
to
interact
with
your
tests,
we've
got
you
covered
there
too,
so
that
sandbox,
let's
take
a
little
bit
more
of
a
actual
look
here
and
how
this
works.
So
you
can
see
here
in
this
first
example.
This
is
a
very
basic
example:
we're
actually
just
patching
the
state
of
the
greeter
contract.
B
The
variable
status
message
there
and
you
can
see
we're
updating
it
to
say
state,
but
you
can
imagine
that
for
something
let's
say:
you're
like
an
nft
ticket
master
type
thing
right,
you'd
be
able
to
seed.
You
know:
50
tickets
into
the
system
right
away
as
part
of
setting
up
your
testing
environment
without
having
to
fire
off
50
transactions,
so
both
a
lot
faster
and
a
lot
more
readable
right,
because
you're
just
going
to
be
able
to
see
this
in
one
command.
B
Secondly,
here
this
one
is
incredibly
important.
This
is
an
example
of
spooning
here,
so
you
can
see,
we've
got
ref
finance
and
we're
grabbing
it
from
mainnet.
There's
the
account
address
there
block
id
50
million
and
we
do
want
the
state
data.
So
this
is
hugely
important.
This
is
going
to
enable
or
make
it
much
easier
to
make
an
entirely
important
class
of
dapps
on
there,
which
is
actually
being
able
to
integrate
a
lot
of
these
protocols,
especially
in
d5
just
right
refs,
the
example
here.
B
So
let's
say
you
wanted
to
make
like
a
yield
farm
aggregator
you'd
be
able
to
pull
in
ref
finance
you'd
be
able
to
pull
in
whichever
other
defy
apps.
You
wanted
to
include
and
you'd
be
able
to
have
this
all
running
in
your
local
environment
without,
as
I
had
said,
having
to
spend
any
real
near
so
hugely
powerful
there.
I
cannot
state
that
enough
and
then,
in
the
future,
we're
actually
working
on
time
travel
for
this
as
well
so
you'll
be
able
to
fast
forward,
and
you
know
manipulate
time
that
way.
B
B
So
here's
an
example:
yep
of
testing
anywhere
here
you
can
see
there's
a
couple
different
ways
to
change
the
network.
We've
got.
You
know
you
can
pass
it
in
as
variable
set
it
in
the
environment
or
finally,
here,
if
you're,
using
ava
you
and
we'll
be
able
to
actually
generate
a
config
file,
so
these
workspaces
come
in
a
couple.
Different
flavors
we've
got
the
rust
workspaces.
B
As
I
mentioned,
we've
got
a
base,
js
version
which
is
compatible
with
any
testing
framework,
and
we
also
have
this
version,
which
is
already
configured
for
ava,
so
you'll
be
able
to
get
started
as
quickly
as
possible.
If
you
don't
mind
using
ava
as
your
assertion
library-
and
I
should
also
it's
also
worth
mentioning-
that
this
is
a
huge
improvement
on
integration
tests,
but
your
unit
tests
can
be
written
totally
the
same
way
as
before.
There's
no
disruption
to
that.
B
B
So
you
can
see
a
couple
different
features
here:
it's
going
to
include
infrastructure
management.
This
is
including
an
rpc
service
and
also
an
indexer
service.
You
know
many
people
don't
want
to
have
to
many
people,
don't
want
to
have
to
deal
with
the
time
and
expense
right
of
maintaining
or
writing
your
own
indexer,
and
so
this
is
just
going
to
allow
you
to
stand
it
up
and
get
going
next.
B
So
I'm
going
to
go
through
two
scenarios
here.
I've
got
some
wireframes
to
show
you
like.
I
said
it's
very
early,
but
I
want
to
at
least
give
you
a
taste
of
the
final
vision
of
this
so
first
scenario.
Here
our
d5
smart
contracts
been
hacked.
How
could
the
developer
console
have
prevented
this
scenario?
B
So,
in
this
case,
this
goes
back
to
the
alerts
and
actions
that
I
talked
about
earlier.
So
in
this
example,
we're
on
the
monitoring
screen,
we're
looking
at
our
alerts
here
and
just
going
left
to
right.
It's
really
readable
how
this
is
configured,
so
you
can
see.
Our
account
here
is
just
in
this
example.
It's
like
a
vault
contract
for
this,
and
the
conditions
of
this
alert
are
if
the
balance
drops
20
percent-
and
this
is
also
if
that
is
caused
by
addresses
not
from
our
allowed
list.
B
So
obviously,
we
want
to
be
able
to
lower
the
balance
of
the
contract,
so
those
the
allowed
list
would
include
like
addresses
of
anyone
that
you
trust
and
then
finally,
those
are
the
actions
that
would
be
triggered
if
those
conditions
are
met.
In
addition
to
actually
alerting
you,
so
in
this
case,
we're
actually
going
to
call
the
pause
method
on
this
contract.
B
Briefly,
if
you're
not
familiar
with
the
possible
pattern,
this
would
just
allow
you
to
flip
a
boolean
and
essentially
stop
all
functionality
from
the
contract
temporarily
and
then
finally,
there
how
you
want
to
be
notified,
so
email
text,
things
of
that
nature,
so
here's
an
example
actually
of
what
one
of
those
email
reports
might
look
like.
So
you
can
see
here
we're
telling
you
like,
which
actual
alert
was
triggered
when
it
happened.
We
got
some
helpful
links
there
that
can
go
to
the
explorer
or
in
that
case
help.
B
B
So
second
scenario,
this
one's
an
nft
marketplace
that
wants
to
see
their
best
performing
collections
and
artists.
So
how
can
we
do
that?
Dare
I
say
it's
almost
trivial
actually
compared
to
the
last
task.
We've
already
got
the
indexer
service
running,
so
this
is
just
a
matter
of
displaying
this
data
in
a
way
that's
useful
for
us,
so
you
can
see
our
app
nft
horrific
here.
B
The
analytics
screen
is
composed
of
a
series
of
tiles
for
visualization
and
so
in
this
example
we're
creating
a
new
one.
We
want
to
visualize
our
top
10
artists
by
revenue
here
in
this
example.
This
is
written
in
a
sql
query,
but
this
is
still
very
early,
so
you
know
that.
May
that
may
change
and
I'd
love
to
hear
other
ways.
You
might
want
to
write
this
and
then
finally,
we
choose
our
visualization
here,
which
in
this
case
is
a
bar
chart
and
so
here's
a
nice
example
of
what
that
could
look
like
now.
B
You've
got
your
various
tiles
here,
and
these
are
all
charts
and
graphs
that
you've
configured
we've
got
our
top
five
artists
by
revenue
in
the
lower
left
there
in
the
bar
graph
that
we
specified,
but
we
could
also,
you
know,
show
a
proportion
of
artist
sales
and
then,
at
the
top,
just
an
example
of
some
transactions
right
there
so
phase
one
of
this.
What's
going
to
actually
be
coming
out
soon
is
going
to
include
project
management
portions,
so
this
includes
adding
your
project
uploading
the
contracts,
the
rpc
service.
B
B
B
So
to
summarize,
this
is
near's
tooling,
as
it
exists
today.
I
won't
spend
too
much
time
on
that,
and
this
is
what
it's
going
to
look
like.
So
we've
got
that
new
cli
written
in
rust.
With
that
awesome
extension
system,
I'm
really
excited
about
that.
I
really
hope
that
could
even
power,
potentially
even
like
micro
startups,
around
writing
extensions
for
near
cli,
eventually
and
then
additional
language
support
there.
We
got
the
grain
and
zig
teams
working
really
hard.
B
Next
up
scaffolding
there
starting
a
new
project,
mentioned
that
near
project
extension.
It's
going
to
kind
of
be
supplanting,
create
new
app.
There
we've
got
dev
console
on
the
operations
side
and
as
far
as
our
api
libraries,
we
didn't
really
touch
on
this
much,
but
it's
definitely
worth
mentioning
in
addition
to
near
api
js
we're
also
working
on
api
libraries
for
rust
and
for
python,
so
you'll
be
able
to
interact
with
near
in
those
languages
more
easily
and
then
testing.
That
was
the
big
overhaul.
B
So
sim
tests
don't
need
to
worry
about
those
anymore.
You
got
in
your
sandbox
and
you've
got
your
various
workspace.
Libraries
just
choose
your
flavor
there,
based
on
what
you
prefer
and
oh
and
that
unicode
character
didn't
work,
but
we
want
to
hear
from
you
and
in
lieu
of
head
shots
because
we
didn't
have
them
all.
I'm
going
to
have
everyone
here
on
developer
platform,
raise
your
hand
in
the
audience
and
so
so
find
one
of
us
talk
about
your
developer.
Experience
complain
to
us.
Please.
B
Actually
I'd
really
love
to
hear
negative
feedback,
so
we
know
where
to
improve
so
yeah
find
anyone
who
had
a
raised
hand
there,
and
so,
as
I
mentioned
at
the
beginning,
I'm
gonna
be
uploading.
These
slides,
actually
shortly
after
this
and
so
you'll,
be
able
to
click
any
of
these
links
here
that
I've
provided
I'll
highlight
a
couple
of
them
actually
because
I've
got
a
little
extra
time.
B
So,
in
addition
to
all
the
things
we
talked
about,
which
is
mostly
on
that
left
hand
side
there,
you
can
see
the
near
cli
proposal
actually
is
an
important
one
to
highlight
there.
That's
the
original
governance
forum
post
that
led
to
the
near
cli
that
I
spoke
about,
so
you'll
definitely
want
to
check
that
out
and
then,
on
the
right
hand,
side
some
really
helpful
resources
as
far
as
education,
so
we've
got
a
new
zero
to
hero
tutorial.
It's
building
a
crossword,
our
very
own,
mike
purvis,
has
used
this
internally.
B
It's
a
really
cool
project
so
definitely
check
that
out.
If
you
want
to
learn
more
about
developing
and
rust,
that's
part
of
our
newly
revamped
rust,
sdk,
docs,
also
really
nice,
and
then
under
that
we've
got
near
university.
So
your
university's
got
a
couple
different
options
there,
depending
on
how
you
want
to
learn.
B
If
you
we've
got
live
certified
courses,
which
are
you
know
in
person
or
you
know,
live
in
the
sense
that
you're
with
an
instructor
the
whole
time
we've
got
courses
offered
by
our
partners,
and
we
also
have
self-paced
courses
if
you
prefer
to
learn
that
way
as
well
and
then
finally
other
ways
to
get
involved.
We've
got
the
near
governance
forum
there.
B
That's
where
you'll
find
that
cli
proposal
as
long
as
any
other
like
big,
like
ecosystem
shaping
discussions,
we
always
make
everything
like
as
external
and
transparent
as
possible,
so
you'll
definitely
want
to
follow
that
for
any
updates
and
then
finally
earn
your
discord
as
well,
so
great
place
for
general
chat,
talk
to
devrel
just
get
involved
really
with
the
community,
and
with
that,
that's
everything.
So
thank
you.