►
Description
Axelar - Getting Started with Axelar presented by Stehen Fluin at the FVM Dataverse Hackathon 2023.
A
A
B
A
B
B
If
anyone
has
an
invite,
I
would
love
to
get
one
of
those,
but
I
really
like
to
start
these
sort
of
presentations
understanding
a
little
bit
about
why
XR
exists
and
to
understand
that
you
really
have
to
understand
that
there's
been
a
shift
going
on
over
the
past
few
years.
If
you
were
a
developer
coming
into
web
developer
into
web3
development
or
crypto,
like
let's
say
four
or
five
years
ago,
things
were
simple,
things
were
easy.
B
You
basically
had
you
with
ethereum
you'd,
learn
solidity
and
you
deploy
smart
contracts
there,
and
so
there
was
very
few
choices,
but
rightly
so,
more
and
more
chains
have
been
coming
out
because
every
chain
is
able
to
take
a
different
approach
on
this.
This
kind
of
world
that
we
live
in,
whether
that
is
a
chains
that
are
more
privacy,
focused
chains
that
are
more
scalability,
focused
chains
that
I
have
like
the
the
storage
Network.
B
That
filecoin
has
all
these
different
chains
bring
their
own
value
proposition
to
the
story
of
web3,
but
we've
we've
kind
of
also
entered
this
world
where
we're
seeing
more
and
more
app
chains,
and
so
for
you
as
a
developer.
Now
you
have
to
be
it's
much
harder
to
enter
the
space
because
of
this
Paradox
of
choice.
Where
now
you
have
to
figure
out
how
do
I
connect
to
all
these
different
blockchains?
B
How
do
I
figure
out
what
to
do
for
all
these
different
users
and
axelr
basically
wants
to
come
in
and
make
that
story
a
little
bit
simpler?
We
want
to
make
that
easier
for
developers
and
the
vision
is
at
some
point.
You
might
not
even
have
to
think
about
this
as
a
user
like
what
chain
you're
on
what
capabilities
you're
accessing.
So
what?
If
you
didn't
care
what
chain
you're
on
what?
B
If
you
were
able
to
take
advantage
of
these
differences
between
blockchains
right,
like
the
the
fvm,
is
so
powerful
in
terms
of
being
able
to
manage
the
and
connect
to
this
storage
network
programmatically
from
other
blockchains
and
then
what
if
you
could
be
where
your
users
are
right?
So
obviously
the
fevm
is
relatively
new,
so
there's
not
as
many
assets
there's
not
not
as
many
daps
there.
B
What,
if
you
could
actually
take
advantage
of
adapts
that
exist
on
other
chains
and
connect
them
into
the
things
you're
doing
on
fpvm
like
that
to
me,
is
what's
really
really
exciting
and
that's
what
Axel
is
trying
to
make
possible.
Axelr
is
connected
to
I
think
like
38
different
blockchains
right
now,
so
we
ourselves
are.
B
We
are
built
on
a
tech
stack
based
on
the
cosmos
SDK,
so
we're
in
the
the
cosmos
ecosystem,
but
we're
really
trying
to
be
this
interoperability
layer
and
there's
two
main
things
that
we
actually
do
actually
come
back
to
that.
So
if
you
think
about
Explorer
when,
because
there's
a
bunch
of
different
options
in
a
bunch
of
different
ways,
you
can
send
messages
across
blockchains
send
tokens
those
sorts
of
things
for
us.
We're
really
focused
on
security
and
decentralization.
B
I
mentioned
wanted
to
integrate
into
38
chains
as
of
today,
and
we
really
really
focus
on
developer
experience
so
making
it
easy
to
send
messages,
send
tokens
all
those
sorts
of
things
and
I'll
be
walking
through
some
of
that
today.
So
when
I
think
about
axelr
and
the
feature
set
that
we
actually
offer
I
separate
things
into
two
universes
on
one
side
of
the
world,
we've
got
the
ability
to
Bridge
and
send
tokens,
so
we've
got
deposit
addresses
or
something
we've
got.
B
We've
got
an
on-chain
method
called
send
tokens
and
we
actually
have
this
new
capability
called
interchain
tokens
which
I'll
show
in
a
moment
here.
But
the
first
one
I
want
to
talk
about
is
deposit
addresses.
Deposit
addresses
are
basically
the
idea
that
we're
going
to
bake
together
the
source
chain,
the
destination
chain
that
you
want
to
send
assets
to
the
destination,
address
and
an
asset.
And
then
what
happens?
B
So
one
of
the
examples
of
this
you
could
think
about
is
hey
what,
if
I
want
to
pull
money
out
of
a
DEX
or
even
a
centralized
exchange
on
polygon
on
ethereum,
Etc
and
I
want
those
assets
to
end
up
on
file
coin
or
the
fpvm?
You
can
do
that
with
a
deposit
address.
You
just
create
a
deposit
address
on
ethereum.
You
don't
need
to
have
any
assets
there.
You
can
have
any
wallet
there
and
then
that
deposit
address
can
be
created
that
will
automatically
forward
all
those
assets
to
filecoin.
B
So
we
think
that's
a
really
exciting,
really
easy
way
for
for
developers
and
users
to
move
assets
around
and
we
do
have
an
on-chain
equivalent
called
send
token.
So
we've
got
an
evm
Gateway
that
Gateway
contract
smart
contract
that
exists
on
all
the
evm
chains
that
we're
on,
and
you
can
just
basically
call
the
send
token
method
on
any
of
those
gateways.
B
You
can
pass
it
what
destination
chain
you
want
to
send
what
the
destination
address
is
what
asset
and
then
the
amount,
and
obviously
you
have
to
approve
that
you
have
to
approve
the
Gateway
on
the
token.
But
it's
relatively
simple,
just
like
one
or
two
transactions
and
you
are
able
to
go
ahead
and
transfer
assets
into
the
filecoin
universe
from
anywhere
else
in
the
world,
the
last
one.
So
the
the
first
human
methods
that
I
mentioned
so
this
deposit
address
and
that
send
token.
B
It
only
supports
tokens
that
are
kind
of
natively
supported
by
the
actual
network.
But
we
know
that
there
are
many,
many
more
tokens
that
we
don't
support,
natively,
and
so
what
we
built
is
what
we
call
our
interchange
token
standard.
So
this
is
a
web
interface
as
well
as
a
bunch
of
smart
contracts
that
basically
enable
you
to
take
any
erc20
on
any
of
the
evm
blockchains
that
we
support
and
create
a
version
of
that
token
on
all
the
blockchains.
B
And
then
we
give
you
all
of
the
you're
effectively
creating
your
own
Bridge,
because
you're,
given
all
of
the
methods
on
your
contracts
that
are
enable
you
to
send
tokens
back
and
forth
where
we
automatically
handle
the
the
locking
the
releasing
the
minting
the
burning
to
really
give
you
this
single
token.
That
works
a
bunch
across
a
bunch
of
different
blockchains.
B
So
that's
the
the
sending
tokens
side
of
the
world
which
I
think
is
a
fundamentally
important,
primitive.
But
to
me
it's
not
actually
the
most
exciting,
primitive.
To
me.
The
exciting
thing
comes
with
generalized
message,
passing
or
GMP,
where
we
can
actually
now
move
compute
and
send
messages
and
interact
between
blockchains
in
any
arbitrary
way
that
we
want
to
as
developers.
B
So
you
can
think
of
this
as
instead
of
moving
assets
to
the
compute,
you
can
think
of
it
as
moving
the
compute
to
where
the
assets
are.
So
imagine
your
your
home
base
is
the
fvm,
and
now
you
want
to
send
a
message
and
do
something
on
another
chain
or
interact
with
someone
else's
smart
contracts.
You
you
can
do
that
now
with
General
message.
Passing
these
methods
should
actually
look
relatively
similar
to
the
the
ones
you
saw
the
send
token
to
get
deposit
address
effectively
insulated.
B
You
can
specify
the
destination
chain,
the
designation
address
and
the
payload
that
you
want
to
send,
and
that
can
be
anything
you
want
to
send
it's
basically
just
a
bytes
and
then
on
the
destination
chain.
You
have
the
corresponding
one,
where
you're,
given
the
source
chain,
that
the
message
came
from
the
source
address
that
it
came
from
and
a
payload
and
you'll
notice.
B
This
is
actually
an
internal
method,
because
what
happens
within
the
Excel
network
is
we
noticed
that
a
message
was
initiated
on
a
source
chain,
a
set
of
independent
validators,
achieved
consensus
and
say
yes,
this
happened.
This
is
truth
and
then
they
sign
a
message
that
gets
approved
on
the
destination
chain
and
then
that
approval
then
allows
execution
on
the
destination
chain,
which
then
calls
your
internal
method.
B
So
you
can
be
sure
that
any
function
calls
that
get
into
your
execute
method
have
been
verified,
have
been
attested
to
by
a
decentralized
set
of
independent
validators
and
one
of
the
hardest
parts.
When
you
start
thinking
interchange
when
you
start
building
these
more
complex
applications
is
how
do
you
pay
for
all
the
gas,
because
you've
got
gas
costs
on
the
source
chain?
B
You've
got
the
axillary
gas
cost
for
that
decentralized
consensus
around
what
is
truth,
and
then
you
have
the
gas
costs
in
the
destination
chain,
where
you're
actually
executing
whatever
code
that
you've
written
we've
built
a
method
that
tries
to
make
this
very,
very
easy.
Where
we
have
this
pay
native
gas
for
contract
call
method
so
effectively.
B
What
you
can
do
is
you
can
pay
on
the
source
chain
for
that
end-to-end
message,
so
you
pay
in
the
native
currency
of
the
source
chain
and
that
will
pay
for
the
decentralized
consensus
and
that
pays
for
the
execution
on
the
destination
chain,
so
really
making
it
easy.
So
you
don't
have
to
worry
about
relaying.
You
don't
have
to
worry
about
going
and
putting
gas
in
all
the
different
chains
that
you
want
to
interact
with
when
you
think
about
General
message.
Passing
behind
the
hood.
B
You've
got
your
Source
chain
where
you've
got
your
app
logic.
You
pay
the
gas
service
for
the
end-to-end
transaction.
Then
the
Gateway
picks
that
up
it's
approved
by
the
excellent
worker
confirmed
that
it
happened
by
the
actual
Network
and
then
that
confirmation
approval
is
passed
to
the
Gateway.
On
the
destination
chain,
and
then
we
call
out
to
your
dap
logic,
so
you
can
actually
see
those
those
end
results
and
do
something
interesting
with
them.
B
It
so
I'm
going
to
go
ahead
and
do
that
so
we're
going
to
jump
over
into
remix
where
basically
I've
got
a
blank
file
here
called
gmp.soul,
and
what
I
want
to
do
with
you
is
I
want
to
build
a
relatively
simple
smart
contract,
we'll
deploy
it
to
filecoin,
we'll
deploy
it
to
I,
don't
know
binance
and
then
we'll
send
a
message
from
one
chain
to
another
and
we'll
see
how
we
can
actually
execute
across
chain.
So
let's
go
ahead
and
start
off
by
just
setting
up
a
really
simple
smart
contract
and
I'll.
B
Just
close
these
things
out,
keep
the
focus
here.
Okay,
so
simple
effects,
I
will
just
say:
pregnancy,
zero,
eight,
zero
typing
is
hard
in
front
of
other
people.
I
apologize,
and
this
is
going
to
be
a
contract
called
sender.
Receiver,
so
you
could
theoretically
separate
and
have
a
sender
contract
and
a
receiver
contract
that
have
do
different
things
and
have
different
addresses
and
things
like
that
or
we
can
build
it
all
into
one
contract.
So
you
can
kind
of
create
this
peer-to-peer
network
of
smart
contracts,
so
that
is
it.
B
We
now
have
a
smart
contract,
but
now
let's
go
ahead
and
actually
do
something
interesting
with
it.
So
I'm
going
to
pull
in
a
few
different,
Imports
and
so
I'm
going
to
import
a
few
different
things.
So
we'll
just
get
this
set
up
here,
so
we're
going
to
import
from
and
all
this
is
going
to
come
from
the
Axor
Network,
npm
scope,
XLR,
GMP,
SDK
solidity
and
then
contracts.
Now,
the
three
things
we're
going
to
actually
want
to
pull
in
are
going
to
be.
The
Axel
are
executable.
B
This
is
a
contract
that
we're
going
to
extend
and
inherit
from
that
gives
us
those
methods
like
execute,
where
it's
actually
verifying
that
the
the
message
is
valid
before
it
passes
it
to
that
internal
version.
So
that's
going
to
be
from
the
executable,
folder
and
xlrx
executable.sol
by
the
way,
if
I
make
a
mistake
during
this
demo,
it
is
definitely
going
to
be
in
these
Imports
so
feel
free
to
call
out
if
I,
if
you
see
me,
make
any
mistakes.
A
Yeah,
but
it's
the
best
way
so
I'm
glad
I'm,
glad
you're
doing
this.
I
love
this.
This
is
why
this
is
why
I
love
getting
people
on
and
doing
live
coding,
because
you
get
to
see
and
the
best
thing
being.
Is
people
get
to
see
that
we're
not
superhuman
right?
We
make
mistakes
too.
We
make
typos
we
have
to.
We
have
to
Google
stuff
right.
So
it's
it's
always
great
I
like
that's.
That's
why
I
love
people
doing
live
coding
so
crack
on
it's.
B
Real,
like
you,
see
real,
live
debugging,
you
see
real
live
typos,
it's
amazing
yeah,
and
if,
if
I
can
do
it
in
20
minutes,
you
can
you
can
follow
along
and
type
the
same
things
and
get
the
same
results,
but
hopefully
you're
building
something
that
matters
to
you,
which
is
what
matters.
So
we
need
a
handle
on
the
iax
or
Gateway.
B
So
this
is
the
interface
for
the
extra
Gateway
so
that
we
can
get
access
to
that
send
token
and
call
contract
methods
Etc,
and
the
last
thing
we're
going
to
need
is
that
gas
service,
so
that's
gonna,
be
ixlr
gas
service
ass
service,
we're
going
to
pull
that
one
in
from
interfaces.
Oops
I,
don't
know
why
Chrome
has
prompting
me
for
a
password
enter
faces,
high
axelr
gas
service.
B
B
And
the
other
piece
that
we
need
to
save
is
actually
the
Gateway
and
the
way
that
we're
going
to
do.
That
is
we're
going
to
extend
the
access
executable.
So
we're
going
to
say,
send
a
receiver
is
XLR
executable
and
then
I
will
add
it
to
the
Constructor
here.
X
or
executable
and
I
will
pass
in
that
gateway
address
all
right.
B
So
now,
when
we
before
the
smart
contract
to
any
blockchain
we're
able
to
configure
the
Gateway
so
that
it
knows
how
to
communicate
to
the
Gateway
which
we'll
send
the
message
across
chain,
and
it
knows
how
to
pay
for
those
transactions.
So
let's
go
ahead
and
now
start
using
some
of
these
capabilities.
So
the
first
thing
I'm
going
to
create
is
the
ability
to
send
a
message
so
I'll
make
a
function
called,
send
message
and
we're
going
to
take
a
few
different
parameters.
B
So
I'm
going
to
take
a
string,
call
data
of
the
destination
chain,
string,
call
data
of
the
destination
address
and
we're
going
to
create
a
string
call
data
of
our
message.
So
with
those
three
parameters,
we
know
where
message
is
going
to
go
and
what
the
message
actually
is.
So
let's
go
ahead
and
implement
this.
B
It's
going
to
be
external
and
payable,
so
it's
payable
because
we
want
anyone
to
be
able
to
send
a
message
and
then,
in
order
to
do
that,
they
need
to
pay
the
native
gas
in
order
to
execute
that
cross
chain
transaction.
So
for
sync:
let's
go
ahead
and
encode
our
message
so
we'll
see
if
bytes
memory
payload
is
equal
to
the
API
encode
of
our
message.
B
Now
we
have
our
actual
message
that
we're
going
to
be
sending
let's
go
ahead
and
pay
for
the
gas,
so
I'm
going
to
call
the
gas
service
and
it's
got
a
method
called
pay
native
gas
or
contract
call
it's
a
very
long
method
name,
but
it's
very
specific
and
it's
hopefully
clear
what
it's
doing
here-
we're
just
going
to
pass
all
of
the
eth
or
fil
or
avax
or
whatever.
We
pass
in
we'll
pass
that
directly
to
that
gas
service
and
then
we'll
give
it
the
parameter.
B
So
we're
going
to
tell
it
what
this
contract
is.
We're
going
to
tell
it
where
the
message
is
going,
we're
going
to
tell
it
the
address
that
it's
going
to
show
the
payload,
because
the
payload
is
going
to
drive
some
of
the
cost
and
we'll
tell
them.
Who
is
the
original
sender
of
this
message?
So
with
that
we
have
now
paid
for
a
transaction,
and
now
we
can
actually
call
the
Gateway
and
send
it
and
something
magical
will
happen.
B
So
we'll
say:
gateway.call,
contract
and
I'm
going
to
pass
in
the
destination
chain
destination
address
and
the
payload.
This
should
look
pretty
familiar
by
now,
so
we
are
now
able
to
send
messages,
but
in
order
to
actually
receive
messages,
we
need
to
implement
the
corresponding
xq
method.
So
it's
going
to
look
very,
very
similar
similar
at
this
point,
so
we'll
just
create
an
execute
method.
Here
this
is
going
to
take
a
string
call
data
of
the
source
chain.
B
So
when
the
the
call
comes
in
from
accessor
Network
when
it
gets
executed,
we
tell
you
where
the
message
came
from
from
that
decentralized
truth:
we've
got
string,
call
data
of
the
source
address
and
excuse
me:
bytes
call
data
of
our
payload
with
those
three
things.
Now
we're
going
to
make
this
an
internal
override
because
we're
implementing
the
interface
from
X
executable
and
then,
let's
just
save
out
that
message
so
we'll
say
message
equals
api.code
our
payload
and
we're
going
to
tell
it
that
it
is
a
string
because
we
created
this
message.
B
B
B
Of
course
you
can't
re-encode
with
yeah.
You
don't
need
to
specify
the
type
when
you're
encoding,
so
this
is
going
to
be
a
decode
of
the
payload
as
a
string
and
we've
got
a
couple
errors
here
because
we're
not
using
Association
Source
address,
but
we
can
hear
warnings,
but
we
can
just
ignore
those.
So
let's
go
ahead
and
now
deploy
these
out
to
Falcon.
So
let's
make
sure
that
it's
compiled
and
now
we're
going
to
go
ahead
and
hit,
deploy
and
run
so
in
metamask.
B
Here
I
should
see
filecoin,
hyperspace,
perfect
and
now
I'm
going
to
give
it
the
address
of
the
Gateway
in
the
gas
service.
So
this
is
really
easy
to
find
if
you
just
go
in
the
axle
docs
and
you
scroll
down
to
resources,
testnet
or
mainnet
or
whatever
environment
you're.
In
you're
going
to
see
the
address
of
the
Gateway
and
the
gas
service
on
every
blockchain
that
we
support
so
we'll
just
paste
it
in
here
we
will
hit
transact
so
that
should
create
the
contract.
B
There's
a
couple
ways
we
can
watch
this
is
we
can
go
to
either
the
mempool
and
see
our
contract
creation,
so
here
it
is
sitting
there
pending
and
then,
as
soon
as
that
completes,
we
should
be
able
to
get
that
contract
address,
but
one
of
the
things
I
want
to
do
is
while
we
wait
I,
don't
want
to
wait
for
that,
so
I'm
going
to
go
ahead
and
create
a
deploy,
the
same
contract
over
to
binance
and
then
we'll
send
messages
back
and
forth
between
those
two
blockchains.
So
let's
switch
over
to
BNB
chain.
B
So
I
think
it's
probably
still
sitting
in
the
mempool
yep
there.
It
is
still
sitting
in
the
main
pool.
Oh
no,
it's
it's
gone,
so
we
should
see
it
in
like
yep.
There
we
go
okay,
so
we
have
the
contract
address.
So
what
we
can
do
now
is
if
we
take
a
look
at
that
contract,
we
should
actually
get
the
address
of
our
contract,
but
let's
just
write
these
down,
so
we
have
them
so
we've
got
there.
That
is
our
altcoin
address.
This
is
the
address
of
our
contract
on
Falcon.
B
B
B
So
here
you
can
basically
see
everything
about
the
network,
everything
from
the
chains
that
are
integrated
to
all
the
transactions
that
are
going
through
stats,
all
those
sorts
of
things,
and
you
can
paste
in
a
transaction
address
from
any
of
the
chains
that
we
support,
so
you
can
see
and
you'll
it'll
actually
pop
up,
and
my
favorite
thing
about
this
is
this:
is
not
an
individual
transaction
on
an
individual
blockchain.
This
is
kind
of
the
aggregate
of
what's
Happening
across
all
these
blockchains.
B
This
is
the
context
of
a
message,
so
you
can
see
we
originated
a
message
on
b
b
chain
at
the
source
address
and
we're
sending
that
message
all
the
way
over
to
filecoin.
At
this
address
and
what's
happening
behind
the
scenes
is
we
can
see
that
the
contract
call
happened
on
Source
chain?
The
guess
was
paid
on
the
source
chain
right
now
we
are
doing
confirmation
so
effectively.
B
So
we
should
just
build
it
in
remix,
say
it's
at
its
address
and
just
check
it
we'll
just
ask
for
if
it
has
a
message
yep,
it's
got
an
empty
string
right
now,
which
is
exactly
what
we
expect
when
we
deployed
this
contract.
It
had
no
message
so
as
soon
as
this
full
end-to-end
interchange
transaction
completes.
We
will
see
that
this
message
will
get
updated.
So
we'll
come
back
to
that
in
a
minute,
so
I'll
just
finish
up
the
the
slides
here,
so
we
we've
built
this
smart
contract.
B
B
So
we've
got
that
for
calling
contract
sending
tokens
while
you're
sending
a
contract
cross
chain
lending
nft
linking
if
you
want
to
bring
a
bunch
of
nfts
and
Link
them
into
filecoin,
I,
think
that'd
be
very
cool.
You
can
send
and
acknowledge
messages.
You
can
actually
have
like
a
message
that
goes
out
and
response
that
comes
back.
All
these
sorts
of
things
are
just
baked
into
these
examples
that
you
can
just
basically
run
so
just
check
out
the
extra
examples.
B
B
Let's
open
gmp.sol
here,
okay,
thankfully
we
have
not
launched
our
contract
addresses,
so
we
should
be
able
to
double
check
and
see
if
our
message
it
was
approved
on
filecoins,
you
can
see
the
falcoin
transaction
right
now.
So
the
last
step
in
this
process
is
that
execution,
and
so
as
soon
as
that
execution
is
complete.
That's
when
the
the
relayer
actually
calls
that
execute
method.
We
should
see
that
our
message
here
on
the
Falcon
evm
is
correct.
B
I
think
that
is
a
RPC
error,
because
we
weren't
seeing
that
before,
unless
I
pasted
an
address
wrong,
but
yeah
so
I'm
not
going
to
wait
for
this.
Let's
just
finish
up:
oh
no,
it
is
executed,
so
we
can
actually
see
the
filecoin
transaction
here
which
should
have
transacted
out
to
my
contract
just
to
Triple
verify
the
address.
Yep
that
looks
right.
B
B
We
see
error
if
we
can't
see
the
message
yep
we're
not
seeing
the
message
I'm
not
going
to
be
able
to
debug
this
right
now,
unfortunately,
but
if
you
go
and
take
a
look
at
this
address
on
your
machine
with
a
working
RPC
endpoint,
you
should
be
successful
all
right
with
that.
We
can't
wait
to
see
what
you
build
and
that
is
going
to
be
it
for
this
presentation.
I'm
happy
to
answer
any
questions
you
have
or
have
any
discussions
you
want
to
have.
A
That
was
an
awesome
demo.
I
love
that
that's
that's
really
great
I
want
to
get
stuck
in
with
that
myself.
That's
yeah,
just
to
show
kind
of
how
easy
that
was
to
to
do
that,
because
one
of
the
big
things
is
like
falcoin
is
obviously
very
specifically
tailored
to
storage,
but
now
to
basically
be
able
to
offer
that
storage
capability
to
the
whole
rest
of
the
web
3
world
and
whatever
blockchain
you're
on
using
technology
like
axle,
makes
that
a
lot
easier.
So
that's.
B
That's
one
of
the
one
of
the
coolest
examples:
I've
come
up
with
is
like
control
access
permissions
on
the
FV
fvm
when
a
nft
transfers
so
like
you've
got
an
nft
and
polygon.
You
sell
it
on
openc
as
part
of
that
transfer
automatically
update
the
file
coin.
Permissions,
which
I
just
like
that
sort
of
like
ability
to
combine
the
best
of
two
blockchains
just
really
exciting.
To
me,.
A
B
Yeah,
so
the
the
thing
we're
most
interested
in
is
you
using
message
passing
to
do
something
interesting
or
arbitrary
across,
and
so
basically,
what
you
should
be
able
to
see
in
axler
scan
once
once
you've
done
a
transaction.
Is
this
method
with
call
contract
or
call
contract
with
token,
where
you
you
have
a
contract,
call
from
a
sourcing
to
a
destination
chain?
There's
there's
a
bunch
of
ways
of
doing
this,
so
you
do
that
with
accesscan.
B
Theoretically,
if
you
integrate
the
squid
SDK,
they
use
GMP
under
the
hood,
as
well
so
like
by
using
the
squid
SDK
you're,
also
using
general
message
passing
as
well
as,
if
you
do
something
with,
for
example,
interchange
tokens
that
that
uses
General
message
passing
under
the
hood
as
well.
So
like
you
could
build
your
own
I,
don't
know
inner
chain
nft
tool,
deploy
that
to
a
bunch
of
blockchains
and
then
send
messages
that
kind
of
mint
and
lock
and
burn
and
release
nfts
with
filecoin.
A
Yeah,
that's
cool
and
I,
like
the
the
whole.
The
way
you
handle
the
gas
management
as
well.
That's
that's
really
nice
to
be
able
to
do
that.
I've
played
around
with
sort
of
like
bridging,
not
in
sort
of
message,
passing
type
turns,
but
just
in
general
terms,
like
you
move
token
from
the
other
bridge
and
you've
got
to
do
something
like
I
haven't
got
any
native
gas
now
so
I
can't
you
know,
do
something
on
that
Network
and
you
end
up
with
a
bootstrapping
problem.
A
B
And
it's
holding
so
many
yeah
and
I've
seen
so
many
people
be
really
excited
about
this.
Even
the
concept
of
two-way
contract
calls
where
you
can
send
a
message:
let's
say
a
measuring
from
BNB
to
filecoin
and
then
within
that
execute
method
you
can
call
back
the
source
and
send
a
message
back
and
it
will.
It
will
continue
using
that
original
Gas
payment.
So
you
don't
need
any
funds
on
natural
destination
chain.
A
B
No,
it's
it's
totally
valid,
so
normally
the
answer
is
decentralized
exchanges.
So
on
most
chains
there
is
a
decentralized
exchange
where
there's
a
pair
between
axle,
usdc
and
usdc,
and
then
you
just
you,
can
use
that
to
convert.
We
have
been
working
with
the
circle
team,
a
bunch
so
I
think
in
docs.expreneur.
We
actually
now
have
an
example
where
you
can.
B
So
this
this
code
example
you
can,
you
can
see
we.
This
is
a
cross
chain
swap
using
Circle
cctp
for
bridging,
rather
than
using
axlr's
version
of
usdc
and
so
you're
still
using
general
Master
passing
because
you
have
to
send
the
message
to
the
destination
chain
of
like
what
token
do.
I
want
to
swap
back
to
what
exchange
am
I
going
to
be
using
all
those
sorts
of
things
but
you're
just
kind
of
sending
it
along
the
the
two
paths.
B
A
B
A
That
is
cool,
great
okay,
so
folks,
any
further
questions
here.
If
there's
any
more,
then
put
them
in
the
chat
very
soon,
because
I
think
we're
just
wrapping
up
now.
Thank
you
very
much
Stephen
for
that.
That
was
a
fantastic
demo
and
great
to
see
you
know
actual
technology
and
yeah
I'm
really
interested
to
see
what
what
people
build
as
well
again.
This
is
a
great
opportunity
to
extend
the
functionality
of
filecoin
storage,
Network
and
Falcon
storage
deals
out
to
other
networks
as
well.
A
That's
one
of
the
things
we're
very
keen
on
with
in
protocol
Labs
is
you
know,
kind
of
exporting
the
functionality
of
filecoin
and
decentralized
storage
to
to
other
blockchains
and
allowing
them
to
to
to
use
that
as
well.
So,
that's,
you
know
really
cool
great
well.
That
brings
us
up
to
the
end
of
this
series
of
workshops.