LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

feat(accounts): Add TxCompat field –  implement Tx integration (part 1) (#18969)

Browse Source 
Co-authored-by: unknown unknown <unknown@unknown>
This commit is contained in:
testinginprod 2024-01-08 11:15:31 +01:00 committed by GitHub
parent 38f8aa3567
commit 6848448dc2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 1196 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

860
api/cosmos/accounts/v1/account_abstraction.pulsar.go
View File

File diff suppressed because it is too large Load Diff

21
proto/cosmos/accounts/v1/account_abstraction.proto
View File

@ -17,7 +17,7 @@ message UserOperation {
string authentication_method = 2;
// authentication_data defines the authentication data associated with the authentication method.
// It is the account implementer duty to assess that the UserOperation is properly signed.
bytes authentication_data = 3;
google.protobuf.Any authentication_data = 3;
// authentication_gas_limit expresses the gas limit to be used for the authentication part of the
// UserOperation.
uint64 authentication_gas_limit = 4;
@ -42,6 +42,25 @@ message UserOperation {
// execution_gas_limit defines the gas limit to be used for the execution of the UserOperation's
// execution messages.
uint64 execution_gas_limit = 8;
// tx_compat is populated only when the operation is composed from a raw tx.
// In fact if a TX comes and the sender of the TX is an abstracted account,
// we convert the TX into a user operation, and try to authenticate using the
// x/accounts authenticate method. If a bundler tries to send a UserOperation
// with a populated tx_compat, the operation will immediately yield a failure.
TxCompat tx_compat = 9;
}
// TxCompat provides compatibility for x/accounts abstracted account with the cosmos-sdk's Txs.
// In fact TxCompat contains fields coming from the Tx in raw and decoded format. The Raw format
// is mainly needed for proper sig verification.
message TxCompat {
// auth_info_bytes contains the auth info bytes of the tx.
// Must not be modified.
bytes auth_info_bytes = 1;
// body_bytes contains the body bytes of the tx.
// must not be modified.
bytes body_bytes = 2;
}
// UserOperationResponse defines the response of a UserOperation.

2
simapp/go.mod
View File

@ -33,7 +33,7 @@ require (
google.golang.org/protobuf v1.32.0
)
require cosmossdk.io/x/accounts v0.0.0-20231013072015-ec9bcc41ef9c
require cosmossdk.io/x/accounts v0.0.0-20240104091155-b729e981f130
require (
cosmossdk.io/x/auth v0.0.0-00010101000000-000000000000

45
tests/e2e/accounts/account_abstraction_test.go
View File

@ -59,13 +59,28 @@ func TestAccountAbstraction(t *testing.T) {
aliceAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(aliceAddr)
require.NoError(t, err)
t.Run("fail - tx compat in bundle is not allowed", func(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: mockSignature,
ExecutionMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaAddrStr,
ToAddress: bundlerAddrStr,
Amount: coins(t, "1stake"), // the sender is the AA, so it has the coins and wants to pay the bundler for the gas
}),
TxCompat: &accountsv1.TxCompat{},
})
require.Contains(t, resp.Error, accounts.ErrDisallowedTxCompatInBundle.Error())
})
t.Run("ok - pay bundler and exec not implemented", func(t *testing.T) {
// we simulate executing an user operation in an abstracted account
// which only implements the authentication.
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaAddrStr,
@ -78,7 +93,7 @@ func TestAccountAbstraction(t *testing.T) {
ToAddress: aliceAddrStr,
Amount: coins(t, "2000stake"), // as the real action the sender wants to send coins to alice
}),
ExecutionGasLimit: 36000,
ExecutionGasLimit: 38000,
})
require.Empty(t, resp.Error) // no error
require.Len(t, resp.BundlerPaymentResponses, 1)
@ -97,7 +112,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: bundlerAddrStr, // abstracted account tries to send money from bundler to itself.
@ -124,7 +139,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaAddrStr,
@ -153,7 +168,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "invalid",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaAddrStr,
@ -183,7 +198,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaAddrStr,
@ -212,7 +227,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaAddrStr,
@ -241,7 +256,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaFullAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &banktypes.MsgSend{
FromAddress: aaFullAddrStr,
@ -265,7 +280,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaFullAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: nil,
BundlerPaymentGasLimit: 50000,
@ -294,7 +309,7 @@ func TestAccountAbstraction(t *testing.T) {
resp := ak.ExecuteUserOperation(ctx, bundlerAddrStr, &accountsv1.UserOperation{
Sender: aaFullAddrStr,
AuthenticationMethod: "secp256k1",
AuthenticationData: []byte("signature"),
AuthenticationData: mockSignature,
AuthenticationGasLimit: 10000,
BundlerPaymentMessages: intoAny(t, &nft.MsgSend{
ClassId: "omega-rare",
@ -308,7 +323,7 @@ func TestAccountAbstraction(t *testing.T) {
ToAddress: aliceAddrStr,
Amount: coins(t, "2000stake"),
}),
ExecutionGasLimit: 36000,
ExecutionGasLimit: 38000,
})
require.Empty(t, resp.Error) // no error
})
@ -336,3 +351,11 @@ func balanceIs(t *testing.T, ctx context.Context, app *simapp.SimApp, addr sdk.A
balance := app.BankKeeper.GetAllBalances(ctx, addr)
require.Equal(t, s, balance.String())
}
var mockSignature = &codectypes.Any{TypeUrl: "signature", Value: []byte("signature")}
func setupApp(t *testing.T) *simapp.SimApp {
t.Helper()
app := simapp.Setup(t, false)
return app
}

2
tests/go.mod
View File

@ -34,7 +34,7 @@ require (
)
require (
cosmossdk.io/x/accounts v0.0.0-20231013072015-ec9bcc41ef9c
cosmossdk.io/x/accounts v0.0.0-20240104091155-b729e981f130
cosmossdk.io/x/auth v0.0.0-00010101000000-000000000000
cosmossdk.io/x/authz v0.0.0-00010101000000-000000000000
cosmossdk.io/x/bank v0.0.0-00010101000000-000000000000

2
tests/starship/tests/go.mod
View File

@ -59,7 +59,7 @@ require (
cosmossdk.io/depinject v1.0.0-alpha.4 // indirect
cosmossdk.io/errors v1.0.0 // indirect
cosmossdk.io/store v1.0.1 // indirect
cosmossdk.io/x/accounts v0.0.0-20231013072015-ec9bcc41ef9c // indirect
cosmossdk.io/x/accounts v0.0.0-20240104091155-b729e981f130 // indirect
cosmossdk.io/x/authz v0.0.0-00010101000000-000000000000 // indirect
cosmossdk.io/x/circuit v0.0.0-20230613133644-0a778132a60f // indirect
cosmossdk.io/x/distribution v0.0.0-20230925135524-a1bc045b3190 // indirect

10
x/accounts/keeper_account_abstraction.go
View File

@ -17,6 +17,9 @@ var (
ErrBundlerPayment = errors.New("bundler payment failed")
// ErrExecution is returned when the execution fails.
ErrExecution = errors.New("execution failed")
// ErrDisallowedTxCompatInBundle is returned when the tx compat
// is populated in a bundle.
ErrDisallowedTxCompatInBundle = errors.New("tx compat field populated in bundle")
)
// ExecuteUserOperation handles the execution of an abstracted account UserOperation.
@ -25,6 +28,13 @@ func (k Keeper) ExecuteUserOperation(
bundler string,
op *v1.UserOperation,
) *v1.UserOperationResponse {
// TxCompat field must not be allowed in a UserOperation sent from a bundle.
// Only the runtime can populate this field when an abstracted account sends
// a tx (not from a bundle) and this is converted into a UserOperation.
if op.TxCompat != nil {
return &v1.UserOperationResponse{Error: ErrDisallowedTxCompatInBundle.Error()}
}
resp := &v1.UserOperationResponse{}
// authenticate

15
x/accounts/msg_server.go
View File

@ -3,9 +3,6 @@ package accounts
import (
"context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"cosmossdk.io/core/event"
"cosmossdk.io/x/accounts/internal/implementation"
v1 "cosmossdk.io/x/accounts/v1"
@ -103,5 +100,15 @@ func (m msgServer) Execute(ctx context.Context, execute *v1.MsgExecute) (*v1.Msg
}
func (m msgServer) ExecuteBundle(ctx context.Context, req *v1.MsgExecuteBundle) (*v1.MsgExecuteBundleResponse, error) {
return nil, status.Error(codes.Unimplemented, "not implemented")
_, err := m.k.addressCodec.StringToBytes(req.Bundler)
if err != nil {
return nil, err
}
resp := &v1.MsgExecuteBundleResponse{Responses: make([]*v1.UserOperationResponse, len(req.Operations))}
for i, op := range req.Operations {
resp.Responses[i] = m.k.ExecuteUserOperation(ctx, req.Bundler, op)
}
return resp, nil
}

399
x/accounts/v1/account_abstraction.pb.go
View File

@ -34,7 +34,7 @@ type UserOperation struct {
AuthenticationMethod string `protobuf:"bytes,2,opt,name=authentication_method,json=authenticationMethod,proto3" json:"authentication_method,omitempty"`
// authentication_data defines the authentication data associated with the authentication method.
// It is the account implementer duty to assess that the UserOperation is properly signed.
AuthenticationData []byte `protobuf:"bytes,3,opt,name=authentication_data,json=authenticationData,proto3" json:"authentication_data,omitempty"`
AuthenticationData *types.Any `protobuf:"bytes,3,opt,name=authentication_data,json=authenticationData,proto3" json:"authentication_data,omitempty"`
// authentication_gas_limit expresses the gas limit to be used for the authentication part of the
// UserOperation.
AuthenticationGasLimit uint64 `protobuf:"varint,4,opt,name=authentication_gas_limit,json=authenticationGasLimit,proto3" json:"authentication_gas_limit,omitempty"`
@ -59,6 +59,12 @@ type UserOperation struct {
// execution_gas_limit defines the gas limit to be used for the execution of the UserOperation's
// execution messages.
ExecutionGasLimit uint64 `protobuf:"varint,8,opt,name=execution_gas_limit,json=executionGasLimit,proto3" json:"execution_gas_limit,omitempty"`
// tx_compat is populated only when the operation is composed from a raw tx.
// In fact if a TX comes and the sender of the TX is an abstracted account,
// we convert the TX into a user operation, and try to authenticate using the
// x/accounts authenticate method. If a bundler tries to send a UserOperation
// with a populated tx_compat, the operation will immediately yield a failure.
TxCompat *TxCompat `protobuf:"bytes,9,opt,name=tx_compat,json=txCompat,proto3" json:"tx_compat,omitempty"`
}
func (m *UserOperation) Reset() { *m = UserOperation{} }
@ -108,7 +114,7 @@ func (m *UserOperation) GetAuthenticationMethod() string {
return ""
}
func (m *UserOperation) GetAuthenticationData() []byte {
func (m *UserOperation) GetAuthenticationData() *types.Any {
if m != nil {
return m.AuthenticationData
}
@ -150,6 +156,72 @@ func (m *UserOperation) GetExecutionGasLimit() uint64 {
return 0
}
func (m *UserOperation) GetTxCompat() *TxCompat {
if m != nil {
return m.TxCompat
}
return nil
}
// TxCompat provides compatibility for x/accounts abstracted account with the cosmos-sdk's Txs.
// In fact TxCompat contains fields coming from the Tx in raw and decoded format. The Raw format
// is mainly needed for proper sig verification.
type TxCompat struct {
// auth_info_bytes contains the auth info bytes of the tx.
// Must not be modified.
AuthInfoBytes []byte `protobuf:"bytes,1,opt,name=auth_info_bytes,json=authInfoBytes,proto3" json:"auth_info_bytes,omitempty"`
// body_bytes contains the body bytes of the tx.
// must not be modified.
BodyBytes []byte `protobuf:"bytes,2,opt,name=body_bytes,json=bodyBytes,proto3" json:"body_bytes,omitempty"`
}
func (m *TxCompat) Reset() { *m = TxCompat{} }
func (m *TxCompat) String() string { return proto.CompactTextString(m) }
func (*TxCompat) ProtoMessage() {}
func (*TxCompat) Descriptor() ([]byte, []int) {
return fileDescriptor_9f9bcc910ad46d4b, []int{1}
}
func (m *TxCompat) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *TxCompat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_TxCompat.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *TxCompat) XXX_Merge(src proto.Message) {
xxx_messageInfo_TxCompat.Merge(m, src)
}
func (m *TxCompat) XXX_Size() int {
return m.Size()
}
func (m *TxCompat) XXX_DiscardUnknown() {
xxx_messageInfo_TxCompat.DiscardUnknown(m)
}
var xxx_messageInfo_TxCompat proto.InternalMessageInfo
func (m *TxCompat) GetAuthInfoBytes() []byte {
if m != nil {
return m.AuthInfoBytes
}
return nil
}
func (m *TxCompat) GetBodyBytes() []byte {
if m != nil {
return m.BodyBytes
}
return nil
}
// UserOperationResponse defines the response of a UserOperation.
// If the operation fails the error field will be populated.
type UserOperationResponse struct {
@ -176,7 +248,7 @@ func (m *UserOperationResponse) Reset() { *m = UserOperationResponse{} }
func (m *UserOperationResponse) String() string { return proto.CompactTextString(m) }
func (*UserOperationResponse) ProtoMessage() {}
func (*UserOperationResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_9f9bcc910ad46d4b, []int{1}
return fileDescriptor_9f9bcc910ad46d4b, []int{2}
}
func (m *UserOperationResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -249,6 +321,7 @@ func (m *UserOperationResponse) GetError() string {
func init() {
proto.RegisterType((*UserOperation)(nil), "cosmos.accounts.v1.UserOperation")
proto.RegisterType((*TxCompat)(nil), "cosmos.accounts.v1.TxCompat")
proto.RegisterType((*UserOperationResponse)(nil), "cosmos.accounts.v1.UserOperationResponse")
}
@ -257,36 +330,41 @@ func init() {
}
var fileDescriptor_9f9bcc910ad46d4b = []byte{
// 461 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xcd, 0x6e, 0xd3, 0x40,
0x14, 0x85, 0xe3, 0x24, 0x0d, 0x74, 0x00, 0x09, 0xa6, 0x49, 0xea, 0x76, 0x61, 0x45, 0x5d, 0x65,
0x51, 0x8d, 0x55, 0x8a, 0xf8, 0x59, 0xf2, 0x27, 0x36, 0x14, 0x2a, 0x4b, 0xdd, 0xb0, 0xb1, 0x26,
0xf6, 0x25, 0xb5, 0x88, 0x67, 0xa2, 0xb9, 0xe3, 0xaa, 0x79, 0x0b, 0xde, 0x0a, 0x96, 0x5d, 0xb2,
0x44, 0x89, 0x78, 0x0f, 0x94, 0x19, 0xff, 0xc4, 0x71, 0x95, 0x5d, 0xac, 0x7b, 0xce, 0x3d, 0x27,
0xdf, 0xcc, 0x90, 0xd3, 0x48, 0x62, 0x2a, 0xd1, 0xe7, 0x51, 0x24, 0x33, 0xa1, 0xd1, 0xbf, 0x39,
0x2b, 0x7e, 0x87, 0x7c, 0x82, 0x5a, 0xf1, 0x48, 0x27, 0x52, 0xb0, 0xb9, 0x92, 0x5a, 0x52, 0x6a,
0xd5, 0xac, 0x50, 0xb3, 0x9b, 0xb3, 0xe3, 0xa3, 0xa9, 0x94, 0xd3, 0x19, 0xf8, 0x46, 0x31, 0xc9,
0xbe, 0xfb, 0x5c, 0x2c, 0xac, 0xfc, 0xe4, 0x57, 0x87, 0x3c, 0xb9, 0x42, 0x50, 0x5f, 0xe7, 0xa0,
0xf8, 0x7a, 0x0d, 0x1d, 0x92, 0x1e, 0x82, 0x88, 0x41, 0xb9, 0xce, 0xc8, 0x19, 0xef, 0x07, 0xf9,
0x17, 0x3d, 0x27, 0x03, 0x9e, 0xe9, 0x6b, 0x10, 0x3a, 0x89, 0x8c, 0x32, 0x4c, 0x41, 0x5f, 0xcb,
0xd8, 0x6d, 0x1b, 0x59, 0xbf, 0x3e, 0xbc, 0x30, 0x33, 0xea, 0x93, 0x83, 0x2d, 0x53, 0xcc, 0x35,
0x77, 0x3b, 0x23, 0x67, 0xfc, 0x38, 0xa0, 0xf5, 0xd1, 0x07, 0xae, 0x39, 0x7d, 0x4d, 0xdc, 0x2d,
0xc3, 0x94, 0x63, 0x38, 0x4b, 0xd2, 0x44, 0xbb, 0xdd, 0x91, 0x33, 0xee, 0x06, 0xc3, 0xfa, 0xfc,
0x13, 0xc7, 0xcf, 0xeb, 0x29, 0xfd, 0x42, 0xdc, 0x49, 0x26, 0xe2, 0x19, 0xa8, 0x70, 0xce, 0x17,
0x29, 0x08, 0x1d, 0xa6, 0x80, 0xc8, 0xa7, 0x80, 0xee, 0xde, 0xa8, 0x33, 0x7e, 0xf4, 0xbc, 0xcf,
0x2c, 0x07, 0x56, 0x70, 0x60, 0x6f, 0xc5, 0x22, 0x18, 0xe6, 0xae, 0x4b, 0x6b, 0xba, 0xc8, 0x3d,
0xf4, 0x0d, 0x39, 0xda, 0xde, 0x57, 0x55, 0xe9, 0xd9, 0x2a, 0x75, 0x6b, 0x59, 0xe5, 0x3d, 0xa1,
0x70, 0x0b, 0x51, 0x96, 0x53, 0xca, 0x4b, 0x3c, 0xd8, 0x51, 0xe2, 0x59, 0xa9, 0x2f, 0xf3, 0x19,
0x39, 0xa8, 0x96, 0x54, 0xc9, 0x0f, 0x4d, 0x72, 0xa5, 0x2f, 0x42, 0x4f, 0xfe, 0xb5, 0xc9, 0xa0,
0x76, 0x92, 0x01, 0xe0, 0x5c, 0x0a, 0x04, 0xfa, 0x92, 0x1c, 0xde, 0xc3, 0x34, 0x43, 0x88, 0xcd,
0x11, 0x77, 0x83, 0x41, 0x03, 0xe9, 0x15, 0x42, 0x4c, 0x5f, 0x35, 0x89, 0x96, 0xc6, 0xb6, 0x35,
0x36, 0x00, 0x18, 0xe3, 0x65, 0x13, 0x9d, 0xca, 0xcb, 0xa0, 0xdb, 0xd9, 0x81, 0xe1, 0xb0, 0xbe,
0xaf, 0xf8, 0x07, 0x48, 0x4f, 0x37, 0x89, 0x96, 0x25, 0xec, 0x85, 0x78, 0xba, 0xc9, 0xc2, 0xe4,
0x7f, 0xdc, 0x44, 0x57, 0x25, 0xef, 0xba, 0x05, 0xd5, 0xfa, 0x2a, 0xb4, 0x4f, 0xf6, 0x40, 0x29,
0xa9, 0xcc, 0x69, 0xef, 0x07, 0xf6, 0xe3, 0xdd, 0x8b, 0xdf, 0x4b, 0xcf, 0xb9, 0x5b, 0x7a, 0xce,
0xdf, 0xa5, 0xe7, 0xfc, 0x5c, 0x79, 0xad, 0xbb, 0x95, 0xd7, 0xfa, 0xb3, 0xf2, 0x5a, 0xdf, 0x8e,
0xed, 0xd3, 0xc3, 0xf8, 0x07, 0x4b, 0xa4, 0x7f, 0xbb, 0xf9, 0x60, 0x27, 0x3d, 0x93, 0x76, 0xfe,
0x3f, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xb6, 0x1b, 0x5c, 0xcd, 0x03, 0x00, 0x00,
// 536 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xcf, 0x6f, 0xd3, 0x30,
0x18, 0x6d, 0xda, 0xae, 0xb4, 0x86, 0x09, 0xf0, 0xda, 0x2e, 0x9b, 0x20, 0xaa, 0x7a, 0x40, 0x3d,
0x4c, 0x8e, 0xc6, 0x10, 0xb0, 0x23, 0x1b, 0x13, 0x42, 0x62, 0x30, 0x22, 0x76, 0xe1, 0x12, 0x39,
0x89, 0xdb, 0x45, 0x34, 0x76, 0x64, 0x3b, 0x53, 0xf3, 0x5f, 0x70, 0xe4, 0x4f, 0xe2, 0xb8, 0x23,
0x47, 0xd4, 0x8a, 0xff, 0x03, 0xc5, 0xf9, 0xd5, 0x34, 0xd0, 0x9b, 0xfd, 0x7d, 0xef, 0x7d, 0xef,
0xc5, 0xef, 0x53, 0xc0, 0x91, 0xcb, 0x44, 0xc0, 0x84, 0x89, 0x5d, 0x97, 0x45, 0x54, 0x0a, 0xf3,
0xf6, 0x38, 0x3f, 0xdb, 0xd8, 0x11, 0x92, 0x63, 0x57, 0xfa, 0x8c, 0xa2, 0x90, 0x33, 0xc9, 0x20,
0x4c, 0xd1, 0x28, 0x47, 0xa3, 0xdb, 0xe3, 0xc3, 0x83, 0x19, 0x63, 0xb3, 0x39, 0x31, 0x15, 0xc2,
0x89, 0xa6, 0x26, 0xa6, 0x71, 0x0a, 0x1f, 0xff, 0x68, 0x83, 0xdd, 0x6b, 0x41, 0xf8, 0xa7, 0x90,
0x70, 0x9c, 0x8c, 0x81, 0x43, 0xd0, 0x11, 0x84, 0x7a, 0x84, 0xeb, 0xda, 0x48, 0x9b, 0xf4, 0xac,
0xec, 0x06, 0x4f, 0xc0, 0x00, 0x47, 0xf2, 0x86, 0x50, 0xe9, 0xbb, 0x0a, 0x69, 0x07, 0x44, 0xde,
0x30, 0x4f, 0x6f, 0x2a, 0x58, 0xbf, 0xda, 0xbc, 0x54, 0x3d, 0x78, 0x01, 0xf6, 0x36, 0x48, 0x1e,
0x96, 0x58, 0x6f, 0x8d, 0xb4, 0xc9, 0xfd, 0xe7, 0x7d, 0x94, 0xfa, 0x42, 0xb9, 0x2f, 0xf4, 0x86,
0xc6, 0x16, 0xac, 0x12, 0xde, 0x62, 0x89, 0xe1, 0x6b, 0xa0, 0x6f, 0x8c, 0x99, 0x61, 0x61, 0xcf,
0xfd, 0xc0, 0x97, 0x7a, 0x7b, 0xa4, 0x4d, 0xda, 0xd6, 0xb0, 0xda, 0x7f, 0x87, 0xc5, 0x87, 0xa4,
0x0b, 0x3f, 0x02, 0xdd, 0x89, 0xa8, 0x37, 0x27, 0xdc, 0x0e, 0x71, 0x1c, 0x10, 0x2a, 0xed, 0x80,
0x08, 0x81, 0x67, 0x44, 0xe8, 0x3b, 0xa3, 0xd6, 0x7f, 0x5d, 0x0c, 0x33, 0xd6, 0x55, 0x4a, 0xba,
0xcc, 0x38, 0xf0, 0x14, 0x1c, 0x6c, 0xce, 0x2b, 0xad, 0x74, 0x52, 0x2b, 0x55, 0x6a, 0x61, 0xe5,
0x1c, 0x40, 0xb2, 0x20, 0x6e, 0x94, 0xbd, 0x5d, 0x66, 0xe2, 0xde, 0x16, 0x13, 0x8f, 0x0b, 0x7c,
0xa1, 0x8f, 0xc0, 0x5e, 0x39, 0xa4, 0x54, 0xee, 0x2a, 0xe5, 0x12, 0x5f, 0x88, 0x9e, 0x82, 0x9e,
0x5c, 0xd8, 0x2e, 0x0b, 0x42, 0x2c, 0xf5, 0x9e, 0x7a, 0xf6, 0x27, 0xa8, 0xbe, 0x22, 0xe8, 0xcb,
0xe2, 0x5c, 0x61, 0xac, 0xae, 0xcc, 0x4e, 0xe3, 0xcf, 0xa0, 0x9b, 0x57, 0xe1, 0x33, 0xf0, 0x30,
0x79, 0x60, 0xdb, 0xa7, 0x53, 0x66, 0x3b, 0xb1, 0x24, 0x42, 0x6d, 0xc7, 0x03, 0x6b, 0x37, 0x29,
0xbf, 0xa7, 0x53, 0x76, 0x96, 0x14, 0xe1, 0x53, 0x00, 0x1c, 0xe6, 0xc5, 0x19, 0xa4, 0xa9, 0x20,
0xbd, 0xa4, 0xa2, 0xda, 0xe3, 0x3f, 0x4d, 0x30, 0xa8, 0x6c, 0x9b, 0x45, 0x44, 0xc8, 0xa8, 0x20,
0xf0, 0x25, 0xd8, 0xff, 0x47, 0xc2, 0x91, 0x20, 0x9e, 0x12, 0x6a, 0x5b, 0x83, 0x5a, 0xc0, 0xd7,
0x82, 0x78, 0xf0, 0x55, 0x3d, 0xdf, 0x82, 0xd8, 0x4c, 0x89, 0xb5, 0x38, 0x14, 0xf1, 0xaa, 0x1e,
0x24, 0xcf, 0xcc, 0x08, 0xbd, 0xb5, 0x25, 0x94, 0xfd, 0xea, 0xbc, 0xfc, 0x0b, 0x04, 0x3c, 0x5a,
0xcf, 0xb7, 0x30, 0x91, 0xae, 0xe7, 0xa3, 0xf5, 0x64, 0x94, 0xfe, 0xc5, 0x7a, 0x90, 0xa5, 0xf2,
0xb6, 0x9d, 0x2c, 0xc7, 0x97, 0xa2, 0x7d, 0xb0, 0x43, 0x38, 0x67, 0x5c, 0xed, 0x5e, 0xcf, 0x4a,
0x2f, 0x67, 0x2f, 0x7e, 0x2e, 0x0d, 0xed, 0x6e, 0x69, 0x68, 0xbf, 0x97, 0x86, 0xf6, 0x7d, 0x65,
0x34, 0xee, 0x56, 0x46, 0xe3, 0xd7, 0xca, 0x68, 0x7c, 0x3d, 0x4c, 0xb3, 0x17, 0xde, 0x37, 0xe4,
0x33, 0x73, 0xb1, 0xfe, 0x53, 0x71, 0x3a, 0x4a, 0xed, 0xe4, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff,
0xb2, 0x84, 0x4a, 0x05, 0x71, 0x04, 0x00, 0x00,
}
func (m *UserOperation) Marshal() (dAtA []byte, err error) {
@ -309,6 +387,18 @@ func (m *UserOperation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.TxCompat != nil {
{
size, err := m.TxCompat.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintAccountAbstraction(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x4a
}
if m.ExecutionGasLimit != 0 {
i = encodeVarintAccountAbstraction(dAtA, i, uint64(m.ExecutionGasLimit))
i--
@ -352,10 +442,15 @@ func (m *UserOperation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x20
}
if len(m.AuthenticationData) > 0 {
i -= len(m.AuthenticationData)
copy(dAtA[i:], m.AuthenticationData)
i = encodeVarintAccountAbstraction(dAtA, i, uint64(len(m.AuthenticationData)))
if m.AuthenticationData != nil {
{
size, err := m.AuthenticationData.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintAccountAbstraction(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
@ -376,6 +471,43 @@ func (m *UserOperation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *TxCompat) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *TxCompat) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *TxCompat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.BodyBytes) > 0 {
i -= len(m.BodyBytes)
copy(dAtA[i:], m.BodyBytes)
i = encodeVarintAccountAbstraction(dAtA, i, uint64(len(m.BodyBytes)))
i--
dAtA[i] = 0x12
}
if len(m.AuthInfoBytes) > 0 {
i -= len(m.AuthInfoBytes)
copy(dAtA[i:], m.AuthInfoBytes)
i = encodeVarintAccountAbstraction(dAtA, i, uint64(len(m.AuthInfoBytes)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *UserOperationResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -474,8 +606,8 @@ func (m *UserOperation) Size() (n int) {
if l > 0 {
n += 1 + l + sovAccountAbstraction(uint64(l))
}
l = len(m.AuthenticationData)
if l > 0 {
if m.AuthenticationData != nil {
l = m.AuthenticationData.Size()
n += 1 + l + sovAccountAbstraction(uint64(l))
}
if m.AuthenticationGasLimit != 0 {
@ -499,6 +631,27 @@ func (m *UserOperation) Size() (n int) {
if m.ExecutionGasLimit != 0 {
n += 1 + sovAccountAbstraction(uint64(m.ExecutionGasLimit))
}
if m.TxCompat != nil {
l = m.TxCompat.Size()
n += 1 + l + sovAccountAbstraction(uint64(l))
}
return n
}
func (m *TxCompat) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.AuthInfoBytes)
if l > 0 {
n += 1 + l + sovAccountAbstraction(uint64(l))
}
l = len(m.BodyBytes)
if l > 0 {
n += 1 + l + sovAccountAbstraction(uint64(l))
}
return n
}
@ -639,7 +792,7 @@ func (m *UserOperation) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AuthenticationData", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAccountAbstraction
@ -649,24 +802,26 @@ func (m *UserOperation) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
if msglen < 0 {
return ErrInvalidLengthAccountAbstraction
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthAccountAbstraction
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AuthenticationData = append(m.AuthenticationData[:0], dAtA[iNdEx:postIndex]...)
if m.AuthenticationData == nil {
m.AuthenticationData = []byte{}
m.AuthenticationData = &types.Any{}
}
if err := m.AuthenticationData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
@ -794,6 +949,160 @@ func (m *UserOperation) Unmarshal(dAtA []byte) error {
break
}
}
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TxCompat", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAccountAbstraction
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthAccountAbstraction
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthAccountAbstraction
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.TxCompat == nil {
m.TxCompat = &TxCompat{}
}
if err := m.TxCompat.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipAccountAbstraction(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthAccountAbstraction
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *TxCompat) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAccountAbstraction
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: TxCompat: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TxCompat: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AuthInfoBytes", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAccountAbstraction
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthAccountAbstraction
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthAccountAbstraction
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AuthInfoBytes = append(m.AuthInfoBytes[:0], dAtA[iNdEx:postIndex]...)
if m.AuthInfoBytes == nil {
m.AuthInfoBytes = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BodyBytes", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAccountAbstraction
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthAccountAbstraction
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthAccountAbstraction
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.BodyBytes = append(m.BodyBytes[:0], dAtA[iNdEx:postIndex]...)
if m.BodyBytes == nil {
m.BodyBytes = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipAccountAbstraction(dAtA[iNdEx:])