grassrootseconomics/eth-tracker
8
0
Fork 0
mirror of https://github.com/grassrootseconomics/eth-tracker.git synced 2025-11-04 10:28:22 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: revert event should match success event

Browse Source
This commit is contained in:
Mohamed Sohail 2024-04-18 16:09:21 +08:00
parent 6353d33710
commit 79ec07ef5d
Signed by: kamikazechaser
GPG Key ID: 7DD45520C01CD85D
5 changed files with 69 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
internal/handler/faucet.go → internal/handler/faucet_give.go
View File

@ -79,8 +79,9 @@ func (h *FaucetGiveHandler) HandleRevert(ctx context.Context, msg RevertMessage,
TxType: "FAUCET_GIVE",
Payload: map[string]any{
"revertReason": msg.RevertReason,
"from": msg.From,
"to": to.Hex(),
"recipient": to.Hex(),
"token": common.ZeroAddress.Hex(),
"amount": "0",
},
}
@ -95,7 +96,9 @@ func (h *FaucetGiveHandler) HandleRevert(ctx context.Context, msg RevertMessage,
TxType: "FAUCET_GIVE",
Payload: map[string]any{
"revertReason": msg.RevertReason,
"from": msg.From,
"recipient": common.ZeroAddress.Hex(),
"token": common.ZeroAddress.Hex(),
"amount": "0",
},
}

2
internal/handler/handler.go
View File

@ -41,6 +41,6 @@ type (
func New() []Handler {
return []Handler{
&TransferHandler{},
&TokenTransferHandler{},
}
}

36
internal/handler/token_burn.go
View File

@ -10,49 +10,49 @@ import (
)
type (
BurnHandler struct {
TokenBurnHandler struct {
topicHash common.Hash
event *w3.Event
}
)
var (
burnTopicHash = w3.H("0xcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5")
burnEvent = w3.MustNewEvent("Burn(address indexed _burner, uint256 _value)")
burnToSig = w3.MustNewFunc("burn(uint256)", "bool")
tokenBurnTopicHash = w3.H("0xcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5")
tokenBurnEvent = w3.MustNewEvent("tokenBurn(address indexed _tokenBurner, uint256 _value)")
tokenBurnToSig = w3.MustNewFunc("tokenBurn(uint256)", "bool")
)
func (h *BurnHandler) HandleLog(ctx context.Context, msg LogMessage, emitter emitter.Emitter) error {
if msg.Log.Topics[0] == burnTopicHash {
func (h *TokenBurnHandler) HandleLog(ctx context.Context, msg LogMessage, emitter emitter.Emitter) error {
if msg.Log.Topics[0] == tokenBurnTopicHash {
var (
burner common.Address
tokenBurner common.Address
value big.Int
)
if err := burnEvent.DecodeArgs(msg.Log, &burner, &value); err != nil {
if err := tokenBurnEvent.DecodeArgs(msg.Log, &tokenBurner, &value); err != nil {
return err
}
burnEvent := Event{
tokenBurnEvent := Event{
Block: msg.Log.BlockNumber,
ContractAddress: msg.Log.Address.Hex(),
Success: true,
Timestamp: msg.BlockTime,
TxHash: msg.Log.TxHash.Hex(),
TxType: "BURN",
TxType: "TOKEN_BURN",
Payload: map[string]any{
"burner": burner.Hex(),
"tokenBurner": tokenBurner.Hex(),
"value": value.String(),
},
}
return emitter.Emit(ctx, burnEvent)
return emitter.Emit(ctx, tokenBurnEvent)
}
return nil
}
func (h *BurnHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitter emitter.Emitter) error {
func (h *TokenBurnHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitter emitter.Emitter) error {
if len(msg.InputData) < 8 {
return nil
}
@ -63,25 +63,25 @@ func (h *BurnHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitt
value big.Int
)
if err := burnToSig.DecodeArgs(w3.B(msg.InputData), &value); err != nil {
if err := tokenBurnToSig.DecodeArgs(w3.B(msg.InputData), &value); err != nil {
return err
}
burnEvent := Event{
tokenBurnEvent := Event{
Block: msg.Block,
ContractAddress: msg.ContractAddress,
Success: false,
Timestamp: msg.Timestamp,
TxHash: msg.TxHash,
TxType: "BURN",
TxType: "TOKEN_BURN",
Payload: map[string]any{
"revertReason": msg.RevertReason,
"burner": msg.From,
"tokenBurner": msg.From,
"value": value.String(),
},
}
return emitter.Emit(ctx, burnEvent)
return emitter.Emit(ctx, tokenBurnEvent)
}
return nil

36
internal/handler/token_mint.go
View File

@ -10,51 +10,51 @@ import (
)
type (
MintHandler struct {
TokenMintHandler struct {
topicHash common.Hash
event *w3.Event
}
)
var (
mintTopicHash = w3.H("0xab8530f87dc9b59234c4623bf917212bb2536d647574c8e7e5da92c2ede0c9f8")
mintEvent = w3.MustNewEvent("Mint(address indexed _minter, address indexed _beneficiary, uint256 _value)")
mintToSig = w3.MustNewFunc("mintTo(address, uint256)", "bool")
tokenMintTopicHash = w3.H("0xab8530f87dc9b59234c4623bf917212bb2536d647574c8e7e5da92c2ede0c9f8")
tokenMintEvent = w3.MustNewEvent("tokenMint(address indexed _tokenMinter, address indexed _beneficiary, uint256 _value)")
tokenMintToSig = w3.MustNewFunc("tokenMintTo(address, uint256)", "bool")
)
func (h *MintHandler) HandleLog(ctx context.Context, msg LogMessage, emitter emitter.Emitter) error {
if msg.Log.Topics[0] == mintTopicHash {
func (h *TokenMintHandler) HandleLog(ctx context.Context, msg LogMessage, emitter emitter.Emitter) error {
if msg.Log.Topics[0] == tokenMintTopicHash {
var (
minter common.Address
tokenMinter common.Address
to common.Address
value big.Int
)
if err := mintEvent.DecodeArgs(msg.Log, &minter, &to, &value); err != nil {
if err := tokenMintEvent.DecodeArgs(msg.Log, &tokenMinter, &to, &value); err != nil {
return err
}
mintEvent := Event{
tokenMintEvent := Event{
Block: msg.Log.BlockNumber,
ContractAddress: msg.Log.Address.Hex(),
Success: true,
Timestamp: msg.BlockTime,
TxHash: msg.Log.TxHash.Hex(),
TxType: "MINT",
TxType: "TOKEN_MINT",
Payload: map[string]any{
"minter": minter.Hex(),
"tokenMinter": tokenMinter.Hex(),
"to": to.Hex(),
"value": value.String(),
},
}
return emitter.Emit(ctx, mintEvent)
return emitter.Emit(ctx, tokenMintEvent)
}
return nil
}
func (h *MintHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitter emitter.Emitter) error {
func (h *TokenMintHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitter emitter.Emitter) error {
if len(msg.InputData) < 8 {
return nil
}
@ -66,26 +66,26 @@ func (h *MintHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitt
value big.Int
)
if err := mintToSig.DecodeArgs(w3.B(msg.InputData), &to, &value); err != nil {
if err := tokenMintToSig.DecodeArgs(w3.B(msg.InputData), &to, &value); err != nil {
return err
}
mintEvent := Event{
tokenMintEvent := Event{
Block: msg.Block,
ContractAddress: msg.ContractAddress,
Success: false,
Timestamp: msg.Timestamp,
TxHash: msg.TxHash,
TxType: "MINT",
TxType: "TOKEN_MINT",
Payload: map[string]any{
"revertReason": msg.RevertReason,
"minter": msg.From,
"tokenMinter": msg.From,
"to": to.Hex(),
"value": value.String(),
},
}
return emitter.Emit(ctx, mintEvent)
return emitter.Emit(ctx, tokenMintEvent)
}
return nil

40
internal/handler/token_transfer.go
View File

@ -10,38 +10,38 @@ import (
)
type (
TransferHandler struct {
TokenTransferHandler struct {
topicHash common.Hash
event *w3.Event
}
)
var (
transferTopicHash = w3.H("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
transferEvent = w3.MustNewEvent("Transfer(address indexed _from, address indexed _to, uint256 _value)")
transferSig = w3.MustNewFunc("transfer(address, uint256)", "bool")
transferFromSig = w3.MustNewFunc("transferFrom(address, address, uint256)", "bool")
tokenTransferTopicHash = w3.H("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
tokenTransferEvent = w3.MustNewEvent("tokenTransfer(address indexed _from, address indexed _to, uint256 _value)")
tokenTransferSig = w3.MustNewFunc("tokenTransfer(address, uint256)", "bool")
tokenTransferFromSig = w3.MustNewFunc("tokenTransferFrom(address, address, uint256)", "bool")
)
func (h *TransferHandler) HandleLog(ctx context.Context, msg LogMessage, emitter emitter.Emitter) error {
if msg.Log.Topics[0] == transferTopicHash {
func (h *TokenTransferHandler) HandleLog(ctx context.Context, msg LogMessage, emitter emitter.Emitter) error {
if msg.Log.Topics[0] == tokenTransferTopicHash {
var (
from common.Address
to common.Address
value big.Int
)
if err := transferEvent.DecodeArgs(msg.Log, &from, &to, &value); err != nil {
if err := tokenTransferEvent.DecodeArgs(msg.Log, &from, &to, &value); err != nil {
return err
}
transferEvent := Event{
tokenTransferEvent := Event{
Block: msg.Log.BlockNumber,
ContractAddress: msg.Log.Address.Hex(),
Success: true,
Timestamp: msg.BlockTime,
TxHash: msg.Log.TxHash.Hex(),
TxType: "TRANSFER",
TxType: "TOKEN_TRANSFER",
Payload: map[string]any{
"from": from.Hex(),
"to": to.Hex(),
@ -49,13 +49,13 @@ func (h *TransferHandler) HandleLog(ctx context.Context, msg LogMessage, emitter
},
}
return emitter.Emit(ctx, transferEvent)
return emitter.Emit(ctx, tokenTransferEvent)
}
return nil
}
func (h *TransferHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitter emitter.Emitter) error {
func (h *TokenTransferHandler) HandleRevert(ctx context.Context, msg RevertMessage, emitter emitter.Emitter) error {
if len(msg.InputData) < 8 {
return nil
}
@ -67,17 +67,17 @@ func (h *TransferHandler) HandleRevert(ctx context.Context, msg RevertMessage, e
value big.Int
)
if err := transferSig.DecodeArgs(w3.B(msg.InputData), &to, &value); err != nil {
if err := tokenTransferSig.DecodeArgs(w3.B(msg.InputData), &to, &value); err != nil {
return err
}
transferEvent := Event{
tokenTransferEvent := Event{
Block: msg.Block,
ContractAddress: msg.ContractAddress,
Success: false,
Timestamp: msg.Timestamp,
TxHash: msg.TxHash,
TxType: "TRANSFER",
TxType: "TOKEN_TRANSFER",
Payload: map[string]any{
"revertReason": msg.RevertReason,
"from": msg.From,
@ -86,7 +86,7 @@ func (h *TransferHandler) HandleRevert(ctx context.Context, msg RevertMessage, e
},
}
return emitter.Emit(ctx, transferEvent)
return emitter.Emit(ctx, tokenTransferEvent)
case "23b872dd":
var (
from common.Address
@ -94,17 +94,17 @@ func (h *TransferHandler) HandleRevert(ctx context.Context, msg RevertMessage, e
value big.Int
)
if err := transferFromSig.DecodeArgs(w3.B(msg.InputData), &from, &to, &value); err != nil {
if err := tokenTransferFromSig.DecodeArgs(w3.B(msg.InputData), &from, &to, &value); err != nil {
return err
}
transferEvent := Event{
tokenTransferEvent := Event{
Block: msg.Block,
ContractAddress: msg.ContractAddress,
Success: false,
Timestamp: msg.Timestamp,
TxHash: msg.TxHash,
TxType: "TRANSFER",
TxType: "TOKEN_TRANSFER",
Payload: map[string]any{
"revertReason": msg.RevertReason,
"from": from.Hex(),
@ -113,7 +113,7 @@ func (h *TransferHandler) HandleRevert(ctx context.Context, msg RevertMessage, e
},
}
return emitter.Emit(ctx, transferEvent)
return emitter.Emit(ctx, tokenTransferEvent)
}
return nil