From bf58aaf2bf507083d5fb2b7dc57d94e742580e58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juli=C3=A1n=20Toledano?= Date: Thu, 24 Oct 2024 16:37:51 +0200 Subject: [PATCH 1/2] fix(x/tx): add feePayer as signer (#22311) --- x/tx/CHANGELOG.md | 1 + x/tx/decode/decode.go | 12 ++++++++++++ x/tx/decode/decode_test.go | 36 ++++++++++++++++++++++++++++++------ 3 files changed, 43 insertions(+), 6 deletions(-) diff --git a/x/tx/CHANGELOG.md b/x/tx/CHANGELOG.md index bf8fccec6f84..246888e5b79b 100644 --- a/x/tx/CHANGELOG.md +++ b/x/tx/CHANGELOG.md @@ -38,6 +38,7 @@ Since v0.13.0, x/tx follows Cosmos SDK semver: https://github.com/cosmos/cosmos- * [#21782](https://github.com/cosmos/cosmos-sdk/pull/21782) Fix JSON attribute sort order on messages with oneof fields. * [#21825](https://github.com/cosmos/cosmos-sdk/pull/21825) Fix decimal encoding and field ordering in Amino JSON encoder. * [#21850](https://github.com/cosmos/cosmos-sdk/pull/21850) Support bytes field as signer. +* [#22311](https://github.com/cosmos/cosmos-sdk/pull/22311) Fix add feePayer as signer. ## [v0.13.5](https://github.com/cosmos/cosmos-sdk/releases/tag/x/tx/v0.13.5) - 2024-09-18 diff --git a/x/tx/decode/decode.go b/x/tx/decode/decode.go index 61b01f77e43f..39c80fb599ba 100644 --- a/x/tx/decode/decode.go +++ b/x/tx/decode/decode.go @@ -169,6 +169,18 @@ func (d *Decoder) Decode(txBytes []byte) (*DecodedTx, error) { } } + // If a fee payer is specified in the AuthInfo, it must be added to the list of signers + if authInfo.Fee != nil && authInfo.Fee.Payer != "" { + feeAddr, err := d.signingCtx.AddressCodec().StringToBytes(authInfo.Fee.Payer) + if err != nil { + return nil, errorsmod.Wrap(ErrTxDecode, err.Error()) + } + + if _, seen := seenSigners[string(feeAddr)]; !seen { + signers = append(signers, feeAddr) + } + } + return &DecodedTx{ Messages: msgs, DynamicMessages: dynamicMsgs, diff --git a/x/tx/decode/decode_test.go b/x/tx/decode/decode_test.go index 60be25387640..2fe9a5255b53 100644 --- a/x/tx/decode/decode_test.go +++ b/x/tx/decode/decode_test.go @@ -61,19 +61,42 @@ func TestDecode(t *testing.T) { gogoproto.RegisterType(&testpb.A{}, string((&testpb.A{}).ProtoReflect().Descriptor().FullName())) testCases := []struct { - name string - msg proto.Message - error string + name string + msg proto.Message + feePayer string + error string + expectedSigners int }{ { - name: "happy path", - msg: &bankv1beta1.MsgSend{}, + name: "happy path", + msg: &bankv1beta1.MsgSend{}, + expectedSigners: 1, }, { name: "empty signer option", msg: &testpb.A{}, error: "no cosmos.msg.v1.signer option found for message A; use DefineCustomGetSigners to specify a custom getter: tx parse error", }, + { + name: "invalid feePayer", + msg: &bankv1beta1.MsgSend{}, + feePayer: "payer", + error: `encoding/hex: invalid byte: U+0070 'p': tx parse error`, + }, + { + name: "valid feePayer", + msg: &bankv1beta1.MsgSend{}, + feePayer: "636f736d6f733168363935356b3836397a72306770383975717034337a373263393033666d35647a366b75306c", // hexadecimal to work with dummyAddressCodec + expectedSigners: 2, + }, + { + name: "same msg signer and feePayer", + msg: &bankv1beta1.MsgSend{ + FromAddress: "636f736d6f733168363935356b3836397a72306770383975717034337a373263393033666d35647a366b75306c", + }, + feePayer: "636f736d6f733168363935356b3836397a72306770383975717034337a373263393033666d35647a366b75306c", + expectedSigners: 1, + }, } for _, tc := range testCases { @@ -94,7 +117,7 @@ func TestDecode(t *testing.T) { Fee: &txv1beta1.Fee{ Amount: []*basev1beta1.Coin{{Amount: "100", Denom: "denom"}}, GasLimit: 100, - Payer: "payer", + Payer: tc.feePayer, Granter: "", }, }, @@ -109,6 +132,7 @@ func TestDecode(t *testing.T) { return } require.NoError(t, err) + require.Equal(t, len(decodeTx.Signers), tc.expectedSigners) require.Equal(t, fmt.Sprintf("/%s", tc.msg.ProtoReflect().Descriptor().FullName()), From 7262cf3346b906a8942f7c886ecdd774798a8741 Mon Sep 17 00:00:00 2001 From: Mark Rushakoff Date: Thu, 24 Oct 2024 14:24:31 -0400 Subject: [PATCH 2/2] feat(log): add slog-backed Logger type (#22347) --- log/CHANGELOG.md | 1 + log/README.md | 2 + log/slog/logger.go | 50 ++++++++++++++++++++++ log/slog/logger_test.go | 92 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 145 insertions(+) create mode 100644 log/slog/logger.go create mode 100644 log/slog/logger_test.go diff --git a/log/CHANGELOG.md b/log/CHANGELOG.md index 72b4e6d1adf7..f3ddac1f50b8 100644 --- a/log/CHANGELOG.md +++ b/log/CHANGELOG.md @@ -25,6 +25,7 @@ Each entry must include the Github issue reference in the following format: ### Improvements * [#22233](https://github.com/cosmos/cosmos-sdk/pull/22233) Use sonic json library for faster json handling +* [#22347](https://github.com/cosmos/cosmos-sdk/pull/22347) Add cosmossdk.io/log/slog to allow using a standard library log/slog-backed logger. ## [v1.4.1](https://github.com/cosmos/cosmos-sdk/releases/tag/log/v1.4.1) - 2024-08-16 diff --git a/log/README.md b/log/README.md index c06f26e933b4..2dd94366a29b 100644 --- a/log/README.md +++ b/log/README.md @@ -1,3 +1,5 @@ # Log The `cosmossdk.io/log` provides a zerolog logging implementation for the Cosmos SDK and Cosmos SDK modules. + +To use a logger wrapping an instance of the standard library's `log/slog` package, use `cosmossdk.io/log/slog`. diff --git a/log/slog/logger.go b/log/slog/logger.go new file mode 100644 index 000000000000..4b6c30ec4b97 --- /dev/null +++ b/log/slog/logger.go @@ -0,0 +1,50 @@ +// Package slog contains a Logger type that satisfies [cosmossdk.io/log.Logger], +// backed by a standard library [*log/slog.Logger]. +package slog + +import ( + "log/slog" + + "cosmossdk.io/log" +) + +var _ log.Logger = Logger{} + +// Logger satisfies [log.Logger] with logging backed by +// an instance of [*slog.Logger]. +type Logger struct { + log *slog.Logger +} + +// NewCustomLogger returns a Logger backed by an existing slog.Logger instance. +// All logging methods are called directly on the *slog.Logger; +// therefore it is the caller's responsibility to configure message filtering, +// level filtering, output format, and so on. +func NewCustomLogger(log *slog.Logger) Logger { + return Logger{log: log} +} + +func (l Logger) Info(msg string, keyVals ...any) { + l.log.Info(msg, keyVals...) +} + +func (l Logger) Warn(msg string, keyVals ...any) { + l.log.Warn(msg, keyVals...) +} + +func (l Logger) Error(msg string, keyVals ...any) { + l.log.Error(msg, keyVals...) +} + +func (l Logger) Debug(msg string, keyVals ...any) { + l.log.Debug(msg, keyVals...) +} + +func (l Logger) With(keyVals ...any) log.Logger { + return Logger{log: l.log.With(keyVals...)} +} + +// Impl returns l's underlying [*slog.Logger]. +func (l Logger) Impl() any { + return l.log +} diff --git a/log/slog/logger_test.go b/log/slog/logger_test.go new file mode 100644 index 000000000000..4a7a9d836eac --- /dev/null +++ b/log/slog/logger_test.go @@ -0,0 +1,92 @@ +package slog_test + +import ( + "bytes" + "encoding/json" + stdslog "log/slog" + "testing" + + "cosmossdk.io/log/slog" +) + +func TestSlog(t *testing.T) { + var buf bytes.Buffer + h := stdslog.NewJSONHandler(&buf, &stdslog.HandlerOptions{ + Level: stdslog.LevelDebug, + }) + logger := slog.NewCustomLogger(stdslog.New(h)) + + type logLine struct { + Level string `json:"level"` + Msg string `json:"msg"` + Num int `json:"num"` + } + + var line logLine + + logger.Debug("Message one", "num", 1) + if err := json.Unmarshal(buf.Bytes(), &line); err != nil { + t.Fatal(err) + } + if want := (logLine{ + Level: stdslog.LevelDebug.String(), + Msg: "Message one", + Num: 1, + }); want != line { + t.Fatalf("unexpected log record: want %v, got %v", want, line) + } + + buf.Reset() + logger.Info("Message two", "num", 2) + if err := json.Unmarshal(buf.Bytes(), &line); err != nil { + t.Fatal(err) + } + if want := (logLine{ + Level: stdslog.LevelInfo.String(), + Msg: "Message two", + Num: 2, + }); want != line { + t.Fatalf("unexpected log record: want %v, got %v", want, line) + } + + buf.Reset() + logger.Warn("Message three", "num", 3) + if err := json.Unmarshal(buf.Bytes(), &line); err != nil { + t.Fatal(err) + } + if want := (logLine{ + Level: stdslog.LevelWarn.String(), + Msg: "Message three", + Num: 3, + }); want != line { + t.Fatalf("unexpected log record: want %v, got %v", want, line) + } + + buf.Reset() + logger.Error("Message four", "num", 4) + if err := json.Unmarshal(buf.Bytes(), &line); err != nil { + t.Fatal(err) + } + if want := (logLine{ + Level: stdslog.LevelError.String(), + Msg: "Message four", + Num: 4, + }); want != line { + t.Fatalf("unexpected log record: want %v, got %v", want, line) + } + + wLogger := logger.With("num", 5) + buf.Reset() + wLogger.Info("Using .With") + + if err := json.Unmarshal(buf.Bytes(), &line); err != nil { + t.Fatal(err) + } + if want := (logLine{ + Level: stdslog.LevelInfo.String(), + Msg: "Using .With", + Num: 5, + }); want != line { + t.Fatalf("unexpected log record: want %v, got %v", want, line) + } +}