7496150241

Committed 12 Jan 2024 12:19AM UTC coverage: 77.601%. Remained the same

Build # 7496150241

Build Type

Pull #99

github

Committed by

web-flow

Commit Message

build(deps): bump github.com/ethereum/go-ethereum in /examples

Bumps [github.com/ethereum/go-ethereum](https://github.com/ethereum/go-ethereum) from 1.13.8 to 1.13.10.
- [Release notes](https://github.com/ethereum/go-ethereum/releases)
- [Commits](https://github.com/ethereum/go-ethereum/compare/v1.13.8...v1.13.10)

---
updated-dependencies:
- dependency-name: github.com/ethereum/go-ethereum
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #99: build(deps): bump github.com/ethereum/go-ethereum from 1.13.8 to 1.13.10 in /examples

Run Details

1805 of 2326 relevant lines covered (77.6%)

1420.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.15

/event.go

package w3

import (
        "fmt"

        "github.com/ethereum/go-ethereum/accounts/abi"
        "github.com/ethereum/go-ethereum/common"
        "github.com/ethereum/go-ethereum/core/types"
        "github.com/ethereum/go-ethereum/crypto"
        _abi "github.com/lmittmann/w3/internal/abi"
)

// Event represents a Smart Contract event decoder.
type Event struct {
        Signature string        // Event signature
        Topic0    common.Hash   // Hash of event signature (Topic 0)
        Args      abi.Arguments // Arguments

        indexedArgs abi.Arguments // Subset of Args that are indexed
}

// NewEvent returns a new Smart Contract event log decoder from the given
// Solidity event signature.
//
// An error is returned if the signature parsing fails.
func NewEvent(signature string) (*Event, error) {
        name, args, err := _abi.ParseWithName(signature)
        if err != nil {
                return nil, fmt.Errorf("%w: %v", ErrInvalidABI, err)
        }
        if name == "" {
                return nil, fmt.Errorf("%w: missing event name", ErrInvalidABI)
        }

        indexedArgs := make(abi.Arguments, 0)
        for _, arg := range args {
                if arg.Indexed {
                        arg.Indexed = false
                        indexedArgs = append(indexedArgs, arg)
                }
        }

        sig := args.SignatureWithName(name)
        return &Event{
                Signature:   sig,
                Topic0:      crypto.Keccak256Hash([]byte(sig)),
                Args:        abi.Arguments(args),
                indexedArgs: indexedArgs,
        }, nil
}

// MustNewEvent is like [NewEvent] but panics if the signature parsing fails.
func MustNewEvent(signature string) *Event {
        event, err := NewEvent(signature)
        if err != nil {
                panic(err)
        }
        return event
}

// DecodeArgs decodes the topics and data of the given log to the given args.
func (e *Event) DecodeArgs(log *types.Log, args ...any) error {
        if len(log.Topics) <= 0 || e.Topic0 != log.Topics[0] {
                return fmt.Errorf("w3: topic0 mismatch")
        }

        if len(e.Args) != len(args) {
                return fmt.Errorf("%w: expected %d arguments, got %d", ErrArgumentMismatch, len(e.Args), len(args))
        }
        if len(e.indexedArgs) != len(log.Topics)-1 {
                return fmt.Errorf("%w: expected %d indexed arguments, got %d", ErrArgumentMismatch, len(e.indexedArgs), len(log.Topics)-1)
        }

        indexedArgs := make([]any, 0, len(e.indexedArgs))
        nonIndexedArgs := make([]any, 0, len(e.Args)-len(e.indexedArgs))
        for i, arg := range e.Args {
                if arg.Indexed {
                        indexedArgs = append(indexedArgs, args[i])
                } else {
                        nonIndexedArgs = append(nonIndexedArgs, args[i])
                }
        }

        // decode indexed args
        for i, arg := range indexedArgs {
                if err := (_abi.Arguments{e.indexedArgs[i]}).Decode(log.Topics[i+1][:], arg); err != nil {
                        return err
                }
        }

        // decode non-indexed args
        if err := _abi.Arguments(e.Args).Decode(log.Data, nonIndexedArgs...); err != nil {
                return err
        }
        return nil
}

1	package w3
2
3	import (
4	"fmt"
5
6	"github.com/ethereum/go-ethereum/accounts/abi"
7	"github.com/ethereum/go-ethereum/common"
8	"github.com/ethereum/go-ethereum/core/types"
9	"github.com/ethereum/go-ethereum/crypto"
10	_abi "github.com/lmittmann/w3/internal/abi"
11	)
12
13	// Event represents a Smart Contract event decoder.
14	type Event struct {
15	Signature string // Event signature
16	Topic0 common.Hash // Hash of event signature (Topic 0)
17	Args abi.Arguments // Arguments
18
19	indexedArgs abi.Arguments // Subset of Args that are indexed
20	}
21
22	// NewEvent returns a new Smart Contract event log decoder from the given
23	// Solidity event signature.
24	//
25	// An error is returned if the signature parsing fails.
26	func NewEvent(signature string) (*Event, error) {	11✔
27	name, args, err := _abi.ParseWithName(signature)	11✔
28	if err != nil {	11✔
29	return nil, fmt.Errorf("%w: %v", ErrInvalidABI, err)	×
30	}	×
31	if name == "" {	11✔
32	return nil, fmt.Errorf("%w: missing event name", ErrInvalidABI)	×
33	}	×
34
35	indexedArgs := make(abi.Arguments, 0)	11✔
36	for _, arg := range args {	46✔
37	if arg.Indexed {	46✔
38	arg.Indexed = false	11✔
39	indexedArgs = append(indexedArgs, arg)	11✔
40	}	11✔
41	}
42
43	sig := args.SignatureWithName(name)	11✔
44	return &Event{	11✔
45	Signature: sig,	11✔
46	Topic0: crypto.Keccak256Hash([]byte(sig)),	11✔
47	Args: abi.Arguments(args),	11✔
48	indexedArgs: indexedArgs,	11✔
49	}, nil	11✔
50	}
51
52	// MustNewEvent is like [NewEvent] but panics if the signature parsing fails.
53	func MustNewEvent(signature string) *Event {	7✔
54	event, err := NewEvent(signature)	7✔
55	if err != nil {	7✔
56	panic(err)	×
57	}
58	return event	7✔
59	}
60
61	// DecodeArgs decodes the topics and data of the given log to the given args.
62	func (e Event) DecodeArgs(log types.Log, args ...any) error {	7✔
63	if len(log.Topics) <= 0 \|\| e.Topic0 != log.Topics[0] {	7✔
64	return fmt.Errorf("w3: topic0 mismatch")	×
65	}	×
66
67	if len(e.Args) != len(args) {	7✔
68	return fmt.Errorf("%w: expected %d arguments, got %d", ErrArgumentMismatch, len(e.Args), len(args))	×
69	}	×
70	if len(e.indexedArgs) != len(log.Topics)-1 {	7✔
71	return fmt.Errorf("%w: expected %d indexed arguments, got %d", ErrArgumentMismatch, len(e.indexedArgs), len(log.Topics)-1)	×
72	}	×
73
74	indexedArgs := make([]any, 0, len(e.indexedArgs))	7✔
75	nonIndexedArgs := make([]any, 0, len(e.Args)-len(e.indexedArgs))	7✔
76	for i, arg := range e.Args {	30✔
77	if arg.Indexed {	34✔
78	indexedArgs = append(indexedArgs, args[i])	11✔
79	} else {	23✔
80	nonIndexedArgs = append(nonIndexedArgs, args[i])	12✔
81	}	12✔
82	}
83
84	// decode indexed args
85	for i, arg := range indexedArgs {	18✔
86	if err := (_abi.Arguments{e.indexedArgs[i]}).Decode(log.Topics[i+1][:], arg); err != nil {	11✔
87	return err	×
88	}	×
89	}
90
91	// decode non-indexed args
92	if err := _abi.Arguments(e.Args).Decode(log.Data, nonIndexedArgs...); err != nil {	7✔
93	return err	×
94	}	×
95	return nil	7✔
96	}

lmittmann / w3 / 7496150241

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous