►
From YouTube: EIP-3074: AUTH and AUTHCALL opcodes Community call with Sam W., Ansgar D, Matt G. & Micah Z.
Description
Topics covered:
1:55 - Main motivation
2:50 - What is sponsored transactions
3:00 - Current situations
4:35 - EIP-3074 summary
5:02 - Definitions - Invokers
5:50 - Commit
7:19 - Use cases
7:48 - Caveats
11:00 - since last time
14:35 - Demo by Ansgar
29:56 - Getting the gas estimation from wallets perspective
33:50 - With this EIP in place, token holders will be able to transfer ERC 20 tokens without having any ETH balance, Is it correct?
37:30 - How long this piece of work has taken to come along, any learnings?
43:55 - What can be done to mitigate the malicious invoker? Is it expected that the community will only rally around the trusted invoker?
46:20 - Can someone fork Metamask and change it and have people install it on chrome?
48:54 - What will be the interface between the wallet and web3 framework to interact with invokers? How these standards should be developed?
51:13 - Scenario where dapps need to be aware of use cases, that needs to be considered for standards?
52:34 - What would be a good lead time for having low-hanging fruit support?
53:20 - ETA of audit report
Telegram link for the 3074 group:
https://t.me/joinchat/ZugEkWOfLWM2OGRi
EIP - https://eips.ethereum.org/EIPS/eip-3074
Overview of EIP-3074 with Sam Wilson in PEEPanEIP (note: there have been some changes in specs since this recording) - https://youtu.be/4A3N8dvdaSk
Announcement blog - https://medium.com/ethereum-cat-herders/eip-3074-community-call-ec87b66672e1
- Berlin EIP playlist - https://www.youtube.com/playlist?list=PL4cwHXAawZxrR3Z0I0eubH2fx_4Rej794
- London playlist - https://www.youtube.com/playlist?list=PL4cwHXAawZxppsQYazgJ3EWWWjY2vNxVp
Follow authors
---------------------------
Sam Wilson @_SamWilsn_ | Matt Garnett @lightclients | Ansgar Detriechs @adietrichs
Contact Ethereum Cat Herders
---------------------------------------------------
Discord: https://discord.gg/tzYmDmF
Twitter: https://twitter.com/EthCatHerders
Medium: https://medium.com/ethereum-cat-herders
GitHub: https://github.com/ethereum-cat-herders/PM
Email: support@ethereumcatherders.com
Website: https://www.ethereumcatherders.com/
A
A
And
today's
host,
we
are
going
to
talk
about
eap,
307
for
auth
and
art
call
up
codes,
so
we
have
been
joined
by
co-authors,
sam
wilson
and
scotty
tricks,
matt
ganette,
with
a
wide
a
variety
of
people
from
tap
developers,
infrastructure
providers
and
research.
Your
community
ab3074
is
a
standard
track.
Core
eib
proposed
in
october
2020
and
currently
individual
status
currently
on
independent
developers
testnet.
This
is
also
in
the
process
of
getting
an
audit
done
with
the
help
of
ethereum
foundation.
A
So
I
I
suppose,
like
with
the
cryptocurrency
people,
are
generally
cautious
about
the
security,
so
audit
was
needed
in
this
case.
The
goal
of
this
community
call
is
to
demonstrate
what
this
eip
has
to
offer
to
the
ethereum
developers
and
users
and
get
answers
to
potential
concerns.
So
without
further
ado,
let
me
pass
it
over
to
the
code.
A
B
B
and
we've.
We've
done
some
research
and
we
think
that
it's
going
to
be
okay
to
allow
for
this,
and
we've
also
have
some
auditing
firms
looking
into
this
stuff
to
determine
so
this
is,
I
want
to
add.
This
is
another
motivation
because
I
think,
is
a
really
important
aspect
of
3074
and
it
will
bring
a
lot
of
benefits
to
users.
B
So
everyone,
I
think
here
knows
what
a
sponsored
transaction
is.
The
account
that
pays
for
gas
is
not
the
account
that
is
going
to
perform
the
action,
and
today
sponsored
transactions
exist,
but
they're
mostly
emulated
with
meta
transactions,
so
interior
transactions
and
opengsn
are
pretty
well
known
groups
working
in
the
space.
B
The
issue
that
I
think
that's
really
stopping
this
technology
from
going
mainstream.
Is
that
there's
not
really
a
good
way
to
interact
with
contracts
that
don't
support
meta
transactions
and
if
the
and,
if
there's
no
way
to
interact
with
that
contract,
then
you
have
to
redeploy
the
contracts
you
want
to
interact
with
to
have
this
functionality
and
the
nice
thing
about
3074.
Is
it
allows
you
to
kind
of
sidestep
that
and
just
interact
with
everything
that
already
exists
on
mainnet?
B
So
another
thing
that
we've
looked
into
since
we
last
talked
was
that
we
did
a
dune
analytics
dashboard
and
I
can
send
you
the
link
if
anyone
is
interested.
But
I
was
curious
to
see
how
much
people
are
spending
on
erc20
approvals,
and
I
found
that
over
the
last
month,
users
are
spending
23.8
million
dollars
just
approving
their
tokens,
just
approving
use
of
their
tokens
on
ethereum,
and
I
pretty
confident
that
in
you
know
the
worst
case,
we
can
improve
this
by
about
30.
B
So
every
month,
we'll
save
users
several
million
dollars,
and
I
think
that
this
is
a
you
know.
A
pretty
important
thing
to
understand,
because
these
are
this
is
money
that
users
are
actually
spending
directly
out
of
their
pocket
to
interact
with
the
chain
and
if
we
can
significantly
reduce
that,
that's
a
huge
win
for
you
know
people
joining
ethereum
and
not
being
so
scared
away
about
how
expensive
it
is.
B
C
B
So
we
have
these
contracts
that
are
called
invokers,
and
these
are
the
contracts
that
sort
of
act
as
it's
from
back
to
walled
extensions
for
for
accounts,
and
they
are
the
contracts
that
actually
do
the
signature,
recovery,
and
so
the
invoker
is
a
very
special
contract
in
the
3070
world,
because
it
enforces
all
of
the
things
that
keep
that
the
protocol
typically
enforces
to
keep
accounts
safe.
And
so,
if
you
think
about
what
you
need
to
do
to
interact
with
ethereum,
you
have
to
adhere
to
these
replay
protection
rules.
B
B
The
way
that
we
have
done
the
invoker
is,
we
have
user
signing
over
a
commit,
and
this
commit
is
the
hash
of
all
the
things
that
you
would
expect
to
be
in
a
transaction,
and
these
are
the
things
that
should
keep
your
your
transaction,
secure
from
being
replayed
or
from
you
know,
generally
being
manipulated,
and
so
it
might
look
something
like
this.
You
might
have
a
commit
that
you
sign
over,
that
is
of
the
hash
of
the
nonstick
to
the
gas
and
the
call
data.
B
But
the
nice
thing
about
the
commit
is
that,
because
it
is
just
a
hash
of
data
and
the
invoker
smart
contracts
are
able
to,
you
know
verify,
and
you
know,
create
any
kind
of
commit
message.
You
can
have
more
complicated
schemes.
So
a
really
nice
thing
about
eip3074
is
that
it
allows
for
users
to
send
to
basically
batch
transactions,
and
the
erc20
example
is
the.
D
B
Approve
example
is
a
good
example,
because,
typically,
if
you
want
to
approve
and
then
do
an
action
with
that
token,
it
must
be
done
in
multiple
transactions,
because
you
have
to
have
the
message
that
sender
for
your
approve
to
be
the
eoa,
and
this
actually
allows
the
message
up
sender
to
be
set
arbitrarily.
So
you
can
call,
you
know,
have
multiple
what
would
typically
be
transactions
done
within
a
single
transaction,
and
so
this
leaves
tons
of
benefits
from
ux
to
saving
gas.
Since
you
don't
have
to
pay
the
intrinsic
gas
for
each
of
these
calls.
B
Some
of
the
use
cases
we
talked
about,
but
you
know
generally
sponsored
transactions,
batching,
there's
ideas
of
having
parallel
nonsense
transactions
that
expire,
alarm,
clock,
style
transactions
and
you
know
generally
just
having
contract
wallets
for
free.
This
is
like
a
really
open
design
space
and
I'm
pretty
curious
to
see
what
some
of
the
people
who
are
really
working
more
closely
with
wallets
and
and
user
experience
can
come
up
with
here.
B
You
know
hotly
debated
topics
around
3074
is
like.
Is
this
an
okay
assumption
mike
the
other
caveat
that
exists
3074?
Is
there
the
the
value
has
to
be
deducted
from
the
invoker,
and
the
reasons
for
this
are
there
is
an
invariant
in
the
protocol
that
that
basically
says
you
can
verify
a
transaxis
ballad
by
just
looking
at
the
current
state
and
the
transaction
object,
there's
no
execution
needed
and
if
you
were
to
deduct
value
from
a
user
during
the
execution
of
a
smart
contract.
B
I
think
that
this
this
this
this
bullet
point
is
from
the
last
call
whenever
we
did
not
allow
the
the
self
sponsorship,
which
would
mean
that
if
the
transaction
origin
is
trying
to
become
the
authorized
address,
that
was
not
going
to
be
allowed,
and
this
is
something
that
we
may
still
have
to
walk
back.
We
may
not
allow
self-sponsoring.
In
that
case,
it
becomes
again
difficult
to
try
and
communicate
to
users
how
exactly
3074
works,
and
so
I'm
going
to
have
to
rely
heavily
on.
B
You
know
the
input
from
wall
teams
to
understand
how
they
think
that
can
be
done,
and
you
know
generally,
if,
if
we
can't
deduct
value
from
the
user
and
the
invoker
has
to
hold
ether
for
the
user,
this
is
something
that
it's
unclear.
How
to
properly
educate
users
about
users
are
very
familiar
with
erc20
tokens.
They
understand
that
they
don't
look
at
their
account
balance
in
their
under
their
their
accounts
in
the
try.
B
They
look
at
it
under
the
rc20
token,
and
this
is
kind
of
an
extension
of
that,
but
it
requires
education
and
a
good
user
experience.
The
last
slide
here,
I
think,
is
just
a
couple
updates.
I
mentioned
that
we
had
lifted
the
self-sponsoring
restriction,
so
I
think
that
this
is
going
to
be
if
we
can,
if
we
get
good
feedback
from
these
audits
that
we
started,
I
think
that
this
is
really
going
to
help
eip
3074
be
much
closer
to
the
best
possible
upgrade
that
we
can
have.
B
So
we
have
begun
some
audits
with
two
firms.
One
audit
team
is
looking
at
how
eap
3074
is
going
to
affect
contracts
on
mainnet.
I
think
that
some
contracts
today
are
using
a
a
really
naive
flash
loan
protection,
which
is
just
checking
that
the
method
of
sender
is
equal
to
the
txl
origin,
and
they
do
this
just
so.
They
are
a
little
bit
more
secure
against
flash
loans,
and
this
eip
was
going
to
break
that
in
variance,
and
so
it's
important
to
understand
how
that's
going
to
affect
the
net
contract.
B
Today,
we've
been
working
to
release
a
test
net
so
that
people
can
actually
start
building
and
playing
around
with
30-74,
and
so
I've
got
this
link
here
to
the
pushy
test
net,
which
is
going.
It's
we
plan
to
keep
it
running
until
there
is.
You
know,
confidence
3074
is
going
to
go
into
mainnet
and
we
can
actually
get
it
on
ring
could
be
in
robesten.
So
all
the
information
is
in
that
link
and
you
can
see
exactly
how
to
connect
and
deploy
contracts.
B
There
we've
had
some
discussions
in
all
core
devs
the
last
few
weeks
and
it's
pretty
confident
to
say
that
we're
not
going
to
make
it
into
london.
The
client
teams
really
want
to
keep
the
london
hard
fork,
skinny
and
focus
just
on
eip1559,
but
they
are
optimistic
that
a
feature
fork
is
possible
quickly
after
and
we're
considered
for
inclusion
for
that
future
fork.
That
would
earliest
would
be
around
october.
If
the
merge
happens
around
that
time
and
they
need
to
push
back
the
latest
that
might
happen
is
february.
B
So,
assuming
that
everything
goes
well
with
the
audits,
I
am
optimistic
that
we
can,
you
know,
get
our
get
this
eip
into
this
hard
fork.
But
it's
you
know
it's
still
unofficial
at
the
moment.
It's
something
that
we're
still
working
for,
but
we
are
being
considered
for
inclusion
for
it.
We
talked
with
open,
zeppelin
and
they're
interested
in
writing
invokers.
B
So
I
think
that
this
is
generally
a
positive
sign
and
if
anyone
else
here
is
interested
in
writing,
invokers
and
working
with
us,
we're
happy
to
to
have
some
calls
and
discuss
how
to
do
that,
and
finally,
we're
working
on
some
governance
proposals
with
some
defy
projects
to
help
fund
eip3074
development,
especially
these
contract
audits,
because
the
like,
I
said,
the
invokers
are
very,
very
important.
They're
secure,
and
so
we
want
to
make
sure
that
the
audits
are
done.
You
know
done
very
thoroughly.
B
B
E
E
So
basically
this
came
out
of
last
week.
We
wanted
to
kind
of
benchmark
a
little
bit
these
these
kind
of
gas
savings
around
batching
transactions
and
in
that
process
we
we.
We
figured
that,
like
even
better
than
just
us
kind
of
testing,
these
specific
use
cases
would
be
just
like
to
to
enable
people
to
just
do
it
on
their
own
right,
like
for
whatever
use
case
they're
interested
in
just
be
able
to
go
ahead
and
create
simple
examples
and
actually
kind
of
like
run
it
test.
E
E
You
wouldn't
normally
develop
your
like
production
project
in
there,
but
like
for
portland,
it's
awesome,
so
we
had,
we
deployed
a
fork.
You
can
find
it
at
remix.pushy.quote.link
by
the
way,
like
apologies,
if
there's
a
pronunciation
is
badly
off
but
like
as
we
are
targeting
the
shanghai
fork.
Pushy
is,
I
think,
according
to
wikipedia
like
the
old
center
of
shanghai.
So
that's
why
we
went
with
it
but
yeah.
E
E
That
is,
we
actually
kind
of.
We
fought
solidity
as
well
and
we
have
a
erp374
branch
and
if
you,
if
you
want
to
locally
kind
of
like
use
the
compiler
as
well,
you
could
just
compile
that
but
like.
Instead,
you
can
just
use
this
integrate
compiler,
which
is
easier
and
that
what
it
does
is
we
we.
We
didn't
want
to
make
any
decisions
on
how
of
course,
solidity
would
kind
of
implement
it.
E
So
all
we
did
was
we
only
implemented
it
in
you,
so
if
you're
familiar
with
how
how
to
kind
of
how
to
use
kind
of
assembly
within
within
contracts.
So
sorry,
I'm
jumping
a
little
bit,
but
I
hope
it
all
makes
it
kind
of
makes
sense.
So
so
we
have
like
a
some
some
example
files
here
and
and
so
right
now,
the
only
way
to
kind
of
access,
3074
functionality
is
in
this
in
this
assembly
box
and
and
this
again
and
the
way
you're
doing
it.
You
do.
E
E
You
have
like
these
eight
arguments
and
and
and
so
basically
you
you
just
kind
of
like
use
them
here,
and
then
it
does
whatever
it
does
under
the
hood,
and
so
this
is
the
way
you
can
kind
of
right
now
write,
like
example,
contracts,
and
so
this
is
kind
of
like
the
minimal
example
is
like
a
minimal
invoker
that
this
would
not
be
useful,
like
input
like
on
actual
user
mainnet,
because
it's
completely
kind
of
like
it.
It
makes
all
the
kind
of
the
mistakes
with
security-wise
that
you're
supposed
not
to
do
right.
E
So,
for
example,
it
just
doesn't
use
a
commit.
It
just
uses
like
an
empty
commit
thing,
because
anyone
can
just
basically
send
any
signature
to
it.
So
so,
if
I'm
sending
a
signature,
someone
else
could
grab
it
and
reuse
it
and
so
on.
So
this
should
not
be
used.
This
is
really
just
for
kind
of
like
for
having
like
a
minimal
version.
E
You
can
deploy
and
just
play
around
with,
and
so
we're
just
going
to
do
this
for
now,
just
just
to
kind
of
like
get
a
feeling
for
how
you
how
you
could
do
it.
So
what
you
would
do
is
you
just
create
like
a
normal
file
for
for
now,
I'm
just
going
to
use
this
kind
of
minimal,
invoker
and
then
also
the
hello
world
and
and
what
helloworld
does
here?
We
are
hello
world.
E
It's
just
like
a
minimal
contract
that
has
like
a
public
owner
variable
and
anyone
can
just
become
owner
by
just
calling
it
to
it,
and
so
now
we
kind
of
want
to.
We
want
to
basically
set
the
owner
to
to
a
to
an
account
that
that
sent
like
a
3074
transaction.
This
is
kind
of
like
this
is
our
goal
for
this
little
experiment.
E
So,
let's
kind
of
let's
compile
this
with
the
special
kind
of
compiler,
and
as
you
can
see,
this
was
successful.
I
mean
you
could
just
actually
write
code
in
here.
Of
course,
I'm
only
importing
to
use
the
kind
of
the
thing
is,
but
you
could
you
can
actually
just
write
the
content
in
here
and
now
we
can
just
go
ahead
and
and
deploy
as
you
can
see.
E
We
have
like
these
two
two
contracts,
so
we're
deploying
an
instance
of
hello
world
and
we
are
deploying
an
instance
of
minimal
invoker
and
while
this
is
kind
of
ongoing,
I
can
also
show
you
yeah
kind
of
like
for
creating
these
signatures.
We
have
like
we
also
developed
like
a
a
minimal
plugin,
and
you
can
find
that
on
here.
It's
in
this
list,
erp374
signus,
you
just
activate
that
and
then
you
have
this
very
bare-bones
plug-in
that
lets
you
create
these
signatures
that
you
need
to
use.
E
So
in
our
case,
so
we
have
kind
of
the
hello
world
deployed.
For
now
the
owner
is
unset,
but
if
I
were
to
just
transact
directly
then
in
a
couple
of
seconds
kind
of
this
account,
of
course,
would
become
the
owner,
but
that's
the
boring,
direct
interaction.
We
want
to
go
through
the
minimal
invoker
now,
of
course,
so
like
right.
E
For
now,
the
owner
is
just
f5,
that's
that's
kind
of
like
this
address,
but
now
we
want
to
actually
kind
of
set
it
to
like
a
fancy
kind
of
in
address
to
of
one
of
these
accounts
of
this
account.
So
so
like
this,
this
tab
has
its
own
kind
of
for
now.
It's
it
only
has
this
one
option,
so
it
has
its
own
kind
of
internal
javascript
wallet
that
that's
kind
of
has
this
address
50
75
whatever,
and
that
is
kind
of
like
only
used
to
sign
these
messages
in
the
future.
E
We
also
want
to
add,
like
functionality,
to
sign
with
the
get
get
kind
of
like
exposed
key
as
well,
but
for
now
it's
basically
just
an
internal
javascript
role
to
keep
it
separated.
So
what
you?
What
you
would
do?
Is
you
guys
you
kind
of
and
by
the
way,
if
all
this
is
too
quick
by
the
way
we're
recording
this?
E
So
if
we
go
vip
for
like
a
signature,
the
signature
has
to
be
signed
over
over
kind
of
like
this,
so
like
the
the
commit
the
invoker
address
and
this
magic
kind
of
prefix,
the
zero
x03,
and
so
we
kind
of
have
to
give
it
an
invoker
address
and
a
commit
to
actually
kind
of
to
do
to
create
the
signature
and
again
for
like
minimal
invoker
the
commit
that
it
expects
is
like
empty.
So
we
can
just
leave
that
empty,
but
we
need
to
give
it
the
invoker
address.
E
So
in
this
case
we
give
the
invoker
address.
We
can
just
leave
the
commit
empty.
We
can
just
create
a
signature,
it's
all
again
that
very
bare
bones
for
now,
so
you
have
to
kind
of
like
switch
back
and
forth
a
little
bit,
it's
kind
of
annoying,
but
I
I
hope
it's
not
too
bad
and,
of
course,
we're
free
to
write
your
own
kind
of
help
us
or
whatever.
If
you
want
to
so
basically
now
I
copied
over
the
and
what
was
the
y
parities
one.
E
So
this
is
kind
of
the
signature
this
now
again.
This
is
terrible
design
because
now
this
authorizes
kind
of
the
invoker
to
send
any
arbitrary
transactions
from
from
from
this
address
from
50
75.
But
again
it's
just
to
for
like
demonstrating
to
you
that
this
works.
So
I
just
copy
the
address
for
this
hello,
world
and
I'll
send
like
a
transaction
without
any
data,
and
this
should
kind
of
like
now
again.
E
E
Here
we
go
transaction
is
mined
and
it
is
indeed
now
the
owner
is
this
50
75.,
so
kind
of
the
transaction
actually
came,
of
course,
from
this
invoker
that
usually
would
set
message.sender
to
to
this
address,
but
instead
it
actually
was
set
to
to
this
address
right.
So
this
is
exactly
kind
of
what
all
calls
are
supposed
to
do.
So
this
is
kind
of
like
a
nice
just
like
a
hello
world
example
and
just
like
as
a
little
quicker
side.
E
So
what
we
also
kind
of
did
was
we
implemented
support
for
30
74
for
in
the
debugger.
So
if
you
want
to
kind
of
actually
go
ahead
and
look
at
what
happened
in
detail,
you
can
you
can
kind
of
open
the
debugger
and
then
you
can.
You
can
actually
step
step
through
execution.
So
let
me
kind
of
scroll
through
the
interesting
bit.
E
I
don't
know
oh
yeah
here
we
go,
I'm
a
little
bit
surprised
just
because
usually
it
kind
of
automatically
jumps
to
the
beginning
of
the
doesn't
doesn't
really
matter
so
I
just
have
to
find
the
find
where
it
yeah-
it's
maybe
a
little
bit.
Okay.
So
here
here
we
are
here
we
are
so
so
you
see,
as
you
can
see.
Basically,
for
example,
here
here
here
we
go
here.
We
have
the
earth
call.
You
can
see
how
much
gas
it
consumes.
E
All
of
this,
when,
if
you
step
once
one
further,
you
are
like
now
in
inside
of
the
of
this
contract.
All
of
these
variables
kind
of
like
are
correct.
So
so,
basically
all
of
this
works,
as
you
would
expect,
and
so
now
you
can.
You
could
basically
with
this
now
you
could
also
kind
of
create
actual
kind
of
more
functional
invokers.
We
only
just
now
started
kind
of
to
fill
this
example
contract
reaper.
So
over
the
next
few
days
there
will
be
like
more
kind
of
interesting
invokers.
E
So
let
me
let
me
just
let
me
just
give
you
like
a
very
quick
quick,
quick
example.
Show
this
very
quickly.
Stop
me
if
this
is
just
like
terribly
boring,
that's
fine
as
well,
but
I
I
think
it's
kind
of
like
a
nice
nice
little
thingy.
So
I
this
time
I'll,
deploy
two
hello
world
contracts
and
a
trusted
batch
invoker
and
the
trusted
pitching
invoker
will
kind
of
like
claim
ownership
of
both
of
them
in
one
transaction,
and
this,
of
course,
would
not
be
possible.
Oh
yeah,
okay.
E
Maybe
I'll
just
continue
clicking
a
couple
buttons
here
and
maybe
if
people
already
want
to
go
ahead
and
like
ask
questions
or
something
and
start
the
conversation,
then
maybe
now's
a
good
time,
because
they'll
take
me
like
probably
a
minute
or
so
just
to
fill
out
all
of
these
kind
of
fields
and
click
buttons,
but
I'll
continuously
on
my
screen,
so
just
for
like
closure
and
for
kind
of
this
aha
moment
when,
where
it
actually
works
but
feel
free
to
kind
of.
Like
start,
the
conversation.
F
E
So
yeah
good,
I
know
I
just
wanted
to
say
that
this
was
basically
like
a
project
that,
like
once,
we
once
we
have
this
set
set
up
and
running
and
again
this
kind
of
like
it's
just
done
today,
now
actually
kind
of
like
the
next
steps
for
us
would
be
to
actually
measure
specific
use
cases.
So,
even
just
with
this
batching
invoker
I
mean
this
is,
of
course
not
optimized
for
specific
use
cases.
B
C
C
It
seemed
like
an
open-ended
question
still
regarding
like
getting
the
gas
estimations,
and
I
wasn't
sure
if
that
had
already
been
resolved
or
is
like
a
lot
more
straightforward,
now
or
or
what
just
from
like
a
wallet's
perspective
when
interacting
with
30
74
and
being
able
to
show
to
users
for
certain
transactions
like
that,
are
bundled
up
like
what.
What
would
be
the
estimated
guess
in
advance
of
doing
the
transaction.
E
E
C
E
G
So
course
I
have
a
question
around
use
cases
and
apologies.
I
joined
the
call
late,
so
apologies
if
this
has
already
been
covered,
but
one
of
the
statements
I've
seen
regards
this
eep
on
social
media
on
reddit.
A
lot
is
that
there's
a
there's,
an
assumed
use
case,
which
is
with
this.
With
the
seep
in
place.
G
H
F
F
It
with
a
like
a
constructed
signature
as
well.
If
you
want
to
create
a
multi-sig
that
looks
like
an
eoa
sorry
could.
Could
you
say
that
part
again
sure
you
can?
You
can
use
like
a
constructed
signature
where
you
choose
the
vr
at
s
instead
of
having
a
private
key.
So
there
is
no
private
key
for
the
account
and
then
you
can
use
that
as
a
multi-sig.
If
you
want
or-
or
it
looks
like
an
eoa
sure
sure.
H
I
I
So,
basically,
you
know
sean's
point
was
you
know,
can
we
use?
Will
it
allow
us
to
do
the
approval
and
senate
transfer
using
erc20
tokens?
I
think
there's
still
a
caveat
with
that.
That
needs
to
be
highlighted
is
that
someone
else
is
sponsoring
the
transaction
for
you.
So
there's
still
a
sponsor
so
you're
giving
the
transaction
to
let's
say
itx
in
this
case,
or
I
think
the
economies
I'm
gonna
call.
I
B
So
I
will
say
that
we
aren't,
you
know
officially
included
in
the
shanghai
fork,
so
it
wouldn't
be
correct
to
say
there
is
full
consensus
on
that.
I
think
yeah
we're
optimistic
for
it
to
happen,
and
but
we
still
need
to
get
client
teams
to
say
like
yes,
this
is
definitely
going
to
happen,
but
yeah.
You
know
it
is
something
that's
taken,
a
really
long
time
to
kind
of
look
through
the
history
of
improvements
to
the
ux
of
accounts.
B
There
have
been
a
lot
of
proposals
and
I
think
you
know
the
very
first
proposal
was
kind
of
this
idea
of
account
abstraction,
which
I
feel
like
3074
learned
a
lot
from,
and
that
was
proposed
back
in
as
early
as
2015
and
through
the
years
there
have
been
many
different
proposals
and
I
think,
like
the
learning
is
just
that
number
one.
It
just
takes
a
really
really
long
time
to
change
the
ethereum
protocol,
which
is
generally
a
good
thing.
B
And
so
I
think
that
thinking
that
there
was
a
savior
kind
of
led
people
to
maybe
not
spend
as
much
time
on
trying
to
improve
the
core
protocol
and
now
that
it's
becoming
more
apparent
that
meta
transactions
probably
aren't
going
to
fix
everything
that
there
should
be
efforts
to
actually
resolve
this
in
the
protocol.
That
sort
of
pushed
people
to
look
more
into
it.
And
I
think
the
thing
that
really
kicked
off
this
latest
iteration
on
these.
B
Two
meta
transactions
as
a
very
special
type
of
execution
on
ethereum
and
that
execution
was
potentially
gonna,
be
broken
by
upgrades
that
were
being
proposed,
and
so
that
led
a
lot
more
people
to
look
into,
and
I
know
that
micah
wrote
eip
2711
as
a
response
to
kind
of,
I
think,
some
of
those
things
and
that
sort
of
led
us
to
working
on.
I
I
wrote
an
eip2733
and
then
sam,
wrote,
3074
and
that
led
us
to
like
really
focus
a
lot
more
on
it.
B
I
Yeah,
I
know
it's
a
lot
of
comment
to
that
like
just
to
the
meta
transaction
part.
So
obviously
it
was
mentioned
that
you
know
meta
transactions
may
solve
this
problem,
but
I
think
the
bigger
issue
is
that
meta
transactions
don't
work
very
well
without
the
cip.
You
know
it's
sort
of
like
the
evm
wasn't
designed.
So
if
you
look
at
an
ethereum
transaction,
it
combines
who's
going
to
execute
the
transaction
who's
going
to
pay
for
it.
That
separation
was
not
really
considered.
I
guess
when
the
evm
was
designed.
B
Yeah,
that's
a
good
point
and
we
had
a
pretty
some
pretty
interesting
conversations
with
the
open,
gsn
folks,
and
I
think
that
kind
of
let
at
least
let
me
to
a
better
understanding
of
how
some
of
these
pieces
fit
together
long
term
and
one
of
those
the
idea,
the
idea
there
is.
Basically
you
know
for
a
long
time
account
abstraction
was
thought
of
this.
B
Some
things
about
the
protocol
and
it's
hard
to
like
push
through
right
now
with
all
you
know,
15
59,
the
merge
all
these
things
happening,
and
so
you
know
3074
is
kind
of
seems
like
the
smaller
thing,
but
provides
a
lot
of
the
benefits,
the
account
obstruction.
But
it's
not
client
account
obstruction,
and
so
the
way
that,
like
I'm
kind
of
thinking
about
it
now,
is
that
3074
is
really
this
drop-in
replacement
for
meta
transactions.
It's
like
the
proper
meta
transit.
B
And
so
this
is
something
that's,
maybe
like
a
further
step
forward
to
remove
the
middleman
from
interacting
with
the
ethereum
network,
and
it's
like
a
really
complicated
problem,
because
what
inferior,
what
like
inferior
transaction,
these
relayers
do,
is
a
really
non-trivial
task
and
trying
to
put
that
on
that
burden
onto
all
consensus.
Nodes
is
potentially
like
a
very
big
ask,
and
maybe
it's
more
likely
that
we're
going
to
get
a
very
watered-down
version
of
what
these
relayers
provide,
but
that's
kind
of
how
I
see
the
transition
like
the
differences
between
3074
and
account
abstraction.
D
H
H
We
might
increa
so
today,
metamask
does
allow
signing
arbitrary
hashes
and
we
have
a
grave
warning
about.
You
know
this
can
compromise
your
account.
We
might
add
more
friction
to
that
signature.
We
in
the
context
of
this,
we
might
actually
disallow
signing
things
with
the
3074
prefix.
You
know,
there's
a
lot
of
options
for
how
to
do
this
securely.
The
safest
thing
a
wallet
can
do
is
basically
don't
sign.
H
You
know
data
that
you
don't
understand
as
a
signer
and
especially
if
it
has
this
small
prefix
at
the
beginning,
then
just
don't
sign
it,
and
as
long
as
you're
not
signing
arbitrary
data
without
you
know
scary
warnings,
then
you
should
be
fine
and
then
then
down
the
road.
We
can
start
exploring
things
like
well,
if
some
wallets
want
to
let
users
or
developers
do
really
risky
stuff.
You
know
a
lot
of
we're
in
the
ethereum
community.
We've
got
a
lot
of
hackers.
A
lot
of
people
get
really
frustrated.
H
H
Yeah,
so
for
personal,
non-profit
and
distributions
of
fewer
than
10
000
users
right
now,
yeah,
so
you
could
you
can
fork
it.
You
can
add
your
own
invoker
to
it,
and
it's
very
it's
very
possible
that
you
know.
Given
the
context
of
this,
we
might
allow
a
mechanism
for
developers
to
add
and
develop
invokers,
because
we're
going
to
need
some
environment
to
do
that
like
if
this
becomes
available.
It's
going
to
be
really
awkward
for
invoker
programmers
to
write
them
without
the
context
of
having
any
wallet
that
can
support
them.
B
I
think
that
your
team
does
a
ton
of
work
to
keep
metamask
secure
and
having
people
run.
Custom
forks,
where
they're,
not
updating
and
potentially
doing
malicious
things
is
really
bad.
So
I
don't
know
if
you
have
any
thoughts
on
this,
because
I
see
this
world
where
you
know
users
who
really
don't
understand
what
they're
doing
they
read
a
medium
post
to
download
this
version
of
metamask.
It
lets
you
do
these
amazing
things
in
apeland
and
they
are
like,
of
course
like
I
want
to.
H
Well,
it
I
think
that
our
solution
to
that
is
very
similar
to
a
couple
of
the
other
big
ecosystem
innovation
problems
like
adding
new
blockchains
and
adding
contract
accounts,
which
is
you
know.
We've
got
work
on
an
extensibility
system
that
we're
calling
snaps
and
it's
it's
totally
feasible
that
we
could
write
a
an
api
surface
for
basically
adding
a
script
to
the
wallet
that
lets
people
add
invokers,
we're
not
sure
what
that
api
surface
would
look
like
yet
because
it's
very
likely
invokers
would
involve
like
some
some
amount
of
custom
ui.
H
B
That's
cool
yeah.
I
think
you,
you
make
a
good
point
too
about
like
what
will
the
interface
between
the
wallet,
and
I
know
I
see
like
these
web
three
sort
of
frameworks
to
interact
with
invokers.
How
do
you
think
that
we
should
develop
those
standards
going
forward
like?
Is
that
something
that
you
think
is
going
to
be
an
erc
that
people
are
going
to
discuss
and
we're
going
to
work
together
with
you
know,
ethers
and
web3,
js
and
figure
out
like
how
can
we
like?
B
H
B
H
A
trick
to
the
user,
like
not
replying
in
time
yeah,
there
is
a
provider
method
for
batch
transaction.
So
while
could
overload
that
and
and
then
pass
it
through
this,
so
I
do
think
there
are
ways
that
parts
of
this
could
be
abstracted
away.
Plus,
if
you
had
like
meta
transaction
support
at
the
water
at
the
wallet
layer,
you
could
totally
have
you
know
the
dap
doesn't
need
to
know
about
how
you're
paying
for
the
transaction
or
how
you're
submitting
it
to
the
chain.
H
E
J
There's
there's
scenarios
where,
like
the
dap
needs
to
be
somehow
aware
of
it,
for
example,
like
just
one
normal
use
case,
any
any
decks
right.
Well,
you
have
like
a
first
approved
scenario,
and
then
you
have
a
swap
scenario
right,
usually
like
the
ui
on
those
apps.
They
disable
the
swap
until
you
get
the
approved
right
and
then,
in
the
case
of
having
both,
you
know
like
the
app
will
not
take
advantage
of
it,
but
with
the
current
design
without
making
any
change
right.
D
H
Yeah
and
there
there's
a
there's,
a
nice
proposal,
for
you
know
like
listening
to
transaction.
You
know
if
they
get
sped
up
or
something
or
retried,
but
we
probably
need
a
step
even
further
than
that,
where
we're
not
tracking
transaction
hashes
anymore,
like
dapps
in
that
in
that
world
yeah,
they
need
to
be
tracking,
like
the
intent
of
the
transaction
you're
almost
like
watching
for
an
internal
message,
not
for
a
transaction
hash
anymore.
H
H
On
our
end,
it
is
hard
to
answer
yeah
like
between
three
and
six
months,
and
I
think
that's
part
of
why
I'm
kind
of
of
the
camp
of
like
if
we
miss
london,
but
we
get
october
like
that's,
not
the
worst,
because
we've
got
this
test
network.
So
we're
kind
of
already
unblocked
to
build
when
we're
ready
to
and
we're
kind
of,
gonna
need
wallet
support
to
really
build.
For
this.
A
So
the
one
other
question
that
I
was
about
to
ask
that
was
also
based
on
the
timeline
itself,
considering
that
this
audit
is
going
to
be
an
important
consideration
for
most
of
the
clients,
I'm
talking
in
reference
to
the
last
all-coordinated
meeting,
it
seems
like
clients
are
inclined
towards.
You
know
having
this
included
based
on
the
report.
So
do
we
have
any
estimate
on
the
you
know,
timeline
of
the
audit
report?
When
can
we
expect
that.
B
So
I
would
say
we
would
have
pretty
good
answers
by
then
to
how
that's
going
to
interact
with
the
ethereum
network,
and
I'm
I
think
it's
like
important
for,
like
everybody
involved
to
have
a
to
you,
know,
actually
decide
that
it's
going
to
go
into
a
hard
work
as
far
out
as
we
can,
because
that's
going
to
give
everybody
the
time
to
develop
the
tools
that
interact
with
it
and
to
actually
test
and
verify
that
everything's
working
correctly
so
hopefully
like.
If
this
is
going
to
happen,
we
should
know
sometime
in
early
to
mid-june.
A
E
So
it's
it's
really
more.
Like
borrowing
any
major
problems
coming
from
the
audit
likely
it
will
move
ahead.
I
think,
although
of
course
I
mean
these
things,
you
can
never
say
for
sure
and
yeah
also
like.
I
just
now
created
a
telegram
group
because,
as
matt
was
saying,
my
telegram
might
might
just
work
out
better
than
the
discord
one
and
put
the
link
in
the
chat.
So
anyone
who
wants
to
kind
of
follow,
along
with
3074
developments
between
these
calls
and
feel
free
to
just
click
the
link
and
join
the
title
group.
B
A
E
A
Yeah
definitely
definitely,
okay,
so
with
the
explosion
of
tokens,
those
are
built
on
the
ethereum
network.
It
becomes
a
common
for
year
to
hold
valuable
assets,
and
we
were
talking
about
it
like
how
sponsored
transaction
break
the
circular
dependency
without
ether
to
pay
for
the
conversion.
I
am
assuming
this
eip3074
is
going
to
be
a
revolution,
at
least
in
the
da
for
the
developers
here.
A
So
on
behalf
of
the
ethereum
cat
hurdles,
I
would
like
to
thank
all
the
co-authors
to
bring
the
community
up
to
the
speed
with
the
development
work
and
the
test
net.
The
demo
provided
by
ansker
is
there
in
the
recording,
so
people
can
go
back
and
refer
to
also
extending
my
gratitude
to
all
the
participants
of
this
call
for
taking
out
time
and
joining
to
share
your
viewpoints
on
this
proposal.