grassrootseconomics/eth-tracker
8
0
Fork 0
mirror of https://github.com/grassrootseconomics/eth-tracker.git synced 2026-05-17 10:15:21 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: refactor handlers

Browse Source
This commit is contained in:
Mohamed Sohail
2024-09-18 17:12:31 +03:00
parent 315e09fad9
commit fe7f096026
28 changed files with 1030 additions and 1147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
internal/handler/faucet_give.go Normal file
View File

@@ -0,0 +1,91 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/celoutils/v3"
"github.com/grassrootseconomics/w3-celo"
)
const faucetGiveEventName = "FAUCET_GIVE"
var (
faucetGiveEvent = w3.MustNewEvent("Give(address indexed _recipient, address indexed _token, uint256 _amount)")
faucetGiveToSig = w3.MustNewFunc("giveTo(address)", "uint256")
faucetGimmeSig = w3.MustNewFunc("gimme()", "uint256")
)
func HandleFaucetGiveLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
recipient common.Address
token common.Address
amount big.Int
)
if err := faucetGiveEvent.DecodeArgs(lp.Log, &recipient, &token, &amount); err != nil {
return err
}
faucetGiveEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: faucetGiveEventName,
Payload: map[string]any{
"recipient": recipient.Hex(),
"token": token.Hex(),
"amount": amount.String(),
},
}
return c(ctx, faucetGiveEvent)
}
}
func HandleFaucetGiveInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
faucetGiveEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: faucetGiveEventName,
}
switch idp.InputData[:8] {
case "63e4bff4":
var to common.Address
if err := faucetGiveToSig.DecodeArgs(w3.B(idp.InputData), &to); err != nil {
return err
}
faucetGiveEvent.Payload = map[string]any{
"recipient": to.Hex(),
"token": celoutils.ZeroAddress,
"amount": "0",
}
return c(ctx, faucetGiveEvent)
case "de82efb4":
faucetGiveEvent.Payload = map[string]any{
"recipient": celoutils.ZeroAddress,
"token": celoutils.ZeroAddress,
"amount": "0",
}
return c(ctx, faucetGiveEvent)
}
return nil
}
}

13
internal/handler/handler.go Normal file
View File

@@ -0,0 +1,13 @@
package handler
import "github.com/grassrootseconomics/celo-tracker/internal/cache"
type HandlerContainer struct {
cache cache.Cache
}
func New(cacheProvider cache.Cache) *HandlerContainer {
return &HandlerContainer{
cache: cacheProvider,
}
}

89
internal/handler/index_add.go Normal file
View File

@@ -0,0 +1,89 @@
package handler
import (
"context"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const indexAddEventName = "INDEX_ADD"
var (
indexAddEvent = w3.MustNewEvent("AddressAdded(address _token)")
indexAddSig = w3.MustNewFunc("add(address)", "bool")
indexRegisterSig = w3.MustNewFunc("register(address)", "bool")
)
func HandleIndexAddLog(hc *HandlerContainer) router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var address common.Address
if err := indexAddEvent.DecodeArgs(lp.Log, &address); err != nil {
return err
}
indexAddEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: indexAddEventName,
Payload: map[string]any{
"address": address.Hex(),
},
}
if err := hc.cache.Add(ctx, address.Hex()); err != nil {
return err
}
return c(ctx, indexAddEvent)
}
}
func HandleIndexAddInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
indexAddEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: indexAddEventName,
}
switch idp.InputData[:8] {
case "0a3b0a4f":
var address common.Address
indexAddEvent.Payload = map[string]any{
"address": address.Hex(),
}
if err := indexAddSig.DecodeArgs(w3.B(idp.InputData), &address); err != nil {
return err
}
return c(ctx, indexAddEvent)
case "4420e486":
var address common.Address
indexAddEvent.Payload = map[string]any{
"address": address.Hex(),
}
if err := indexRegisterSig.DecodeArgs(w3.B(idp.InputData), &address); err != nil {
return err
}
return c(ctx, indexAddEvent)
}
return nil
}
}

70
internal/handler/index_remove.go Normal file
View File

@@ -0,0 +1,70 @@
package handler
import (
"context"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const indexRemoveEventName = "INDEX_REMOVE"
var (
indexRemoveEvent = w3.MustNewEvent("AddressRemoved(address _token)")
indexRemoveSig = w3.MustNewFunc("remove(address)", "bool")
)
func HandleIndexRemoveLog(hc *HandlerContainer) router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var address common.Address
if err := indexRemoveEvent.DecodeArgs(lp.Log, &address); err != nil {
return err
}
indexRemoveEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: indexRemoveEventName,
Payload: map[string]any{
"address": address.Hex(),
},
}
if err := hc.cache.Remove(ctx, address.Hex()); err != nil {
return err
}
return c(ctx, indexRemoveEvent)
}
}
func HandleIndexRemoveInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var address common.Address
if err := indexRemoveSig.DecodeArgs(w3.B(idp.InputData), &address); err != nil {
return err
}
indexRemoveEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: indexRemoveEventName,
Payload: map[string]any{
"address": address.Hex(),
},
}
return c(ctx, indexRemoveEvent)
}
}

71
internal/handler/ownership.go Normal file
View File

@@ -0,0 +1,71 @@
package handler
import (
"context"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const ownershipEventName = "OWNERSHIP_TRANSFERRED"
var (
ownershipEvent = w3.MustNewEvent("OwnershipTransferred(address indexed previousOwner, address indexed newOwner)")
ownershipToSig = w3.MustNewFunc("transferOwnership(address)", "bool")
)
func HandleOwnershipLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
previousOwner common.Address
newOwner common.Address
)
if err := ownershipEvent.DecodeArgs(lp.Log, &previousOwner, &newOwner); err != nil {
return err
}
ownershipEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: ownershipEventName,
Payload: map[string]any{
"previousOwner": previousOwner.Hex(),
"newOwner": newOwner.Hex(),
},
}
return c(ctx, ownershipEvent)
}
}
func HandleOwnershipInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var newOwner common.Address
if err := ownershipToSig.DecodeArgs(w3.B(idp.InputData), &newOwner); err != nil {
return err
}
ownershipEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: ownershipEventName,
Payload: map[string]any{
"previousOwner": idp.From,
"newOwner": newOwner.Hex(),
},
}
return c(ctx, ownershipEvent)
}
}

83
internal/handler/pool_deposit.go Normal file
View File

@@ -0,0 +1,83 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const poolDepositEventName = "POOL_DEPOSIT"
var (
poolDepositEvent = w3.MustNewEvent("Deposit(address indexed initiator, address indexed tokenIn, uint256 amountIn)")
poolDepositSig = w3.MustNewFunc("deposit(address, uint256)", "")
)
func HandlePoolDepositLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
initiator common.Address
tokenIn common.Address
amountIn big.Int
)
if err := poolDepositEvent.DecodeArgs(
lp.Log,
&initiator,
&tokenIn,
&amountIn,
); err != nil {
return err
}
poolDepositEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: poolDepositEventName,
Payload: map[string]any{
"initiator": initiator.Hex(),
"tokenIn": tokenIn.Hex(),
"amountIn": amountIn.String(),
},
}
return c(ctx, poolDepositEvent)
}
}
func HandlePoolDepositInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var (
tokenIn common.Address
amountIn big.Int
)
if err := poolDepositSig.DecodeArgs(w3.B(idp.InputData), &tokenIn, &amountIn); err != nil {
return err
}
poolDepositEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: poolDepositEventName,
Payload: map[string]any{
"initiator": idp.From,
"tokenIn": tokenIn.Hex(),
"amountIn": amountIn.String(),
},
}
return c(ctx, poolDepositEvent)
}
}

96
internal/handler/pool_swap.go Normal file
View File

@@ -0,0 +1,96 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const poolSwapEventName = "POOL_SWAP"
var (
poolSwapEvent = w3.MustNewEvent("Swap(address indexed initiator, address indexed tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut, uint256 fee)")
poolSwapSig = w3.MustNewFunc("withdraw(address, address, uint256)", "")
)
func HandlePoolSwapLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
initiator common.Address
tokenIn common.Address
tokenOut common.Address
amountIn big.Int
amountOut big.Int
fee big.Int
)
if err := poolSwapEvent.DecodeArgs(
lp.Log,
&initiator,
&tokenIn,
&tokenOut,
&amountIn,
&amountOut,
&fee,
); err != nil {
return err
}
poolSwapEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: poolSwapEventName,
Payload: map[string]any{
"initiator": initiator.Hex(),
"tokenIn": tokenIn.Hex(),
"tokenOut": tokenOut.Hex(),
"amountIn": amountIn.String(),
"amountOut": amountOut.String(),
"fee": fee.String(),
},
}
return c(ctx, poolSwapEvent)
}
}
func HandlePoolSwapInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var (
tokenOut common.Address
tokenIn common.Address
amountIn big.Int
)
if err := poolSwapSig.DecodeArgs(w3.B(idp.InputData), &tokenOut, &tokenIn, &amountIn); err != nil {
return err
}
poolSwapEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: poolSwapEventName,
Payload: map[string]any{
"initiator": idp.From,
"tokenIn": tokenIn.Hex(),
"tokenOut": tokenOut.Hex(),
"amountIn": amountIn.String(),
"amountOut": "0",
"fee": "0",
},
}
return c(ctx, poolSwapEvent)
}
}

75
internal/handler/quoter_price.go Normal file
View File

@@ -0,0 +1,75 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const quoterPriceEventName = "QUOTER_PRICE_INDEX_UPDATED"
var (
quoterPriceEvent = w3.MustNewEvent("PriceIndexUpdated(address _tokenAddress, uint256 _exchangeRate)")
quoterPriceToSig = w3.MustNewFunc("setPriceIndexValue(address, uint256)", "uint256")
)
func HandleQuoterPriceUpdateLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
token common.Address
exchangeRate big.Int
)
if err := quoterPriceEvent.DecodeArgs(lp.Log, &token, &exchangeRate); err != nil {
return err
}
quoterPriceEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: quoterPriceEventName,
Payload: map[string]any{
"token": token.Hex(),
"exchangeRate": exchangeRate.String(),
},
}
return c(ctx, quoterPriceEvent)
}
}
func HandleQuoterPriceUpdateInputdata() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var (
token common.Address
exchangeRate big.Int
)
if err := quoterPriceToSig.DecodeArgs(w3.B(idp.InputData), &token, &exchangeRate); err != nil {
return err
}
quoterPriceEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: quoterPriceEventName,
Payload: map[string]any{
"token": token.Hex(),
"exchangeRate": exchangeRate.String(),
},
}
return c(ctx, quoterPriceEvent)
}
}

70
internal/handler/seal.go Normal file
View File

@@ -0,0 +1,70 @@
package handler
import (
"context"
"math/big"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const sealEventName = "SEAL_STATE_CHANGE"
var (
sealEvent = w3.MustNewEvent("SealStateChange(bool indexed _final, uint256 _sealState)")
sealToSig = w3.MustNewFunc("seal(uint256)", "uint256")
)
func HandleSealStateChangeLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
final bool
sealState big.Int
)
if err := sealEvent.DecodeArgs(lp.Log, &final, &sealState); err != nil {
return err
}
sealEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: sealEventName,
Payload: map[string]any{
"final": final,
"sealState": sealState.String(),
},
}
return c(ctx, sealEvent)
}
}
func HandleSealStateChangeInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var sealState big.Int
if err := sealToSig.DecodeArgs(w3.B(idp.InputData), &sealState); err != nil {
return err
}
sealEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: sealEventName,
Payload: map[string]any{
"sealState": sealState.String(),
},
}
return c(ctx, sealEvent)
}
}

72
internal/handler/token_burn.go Normal file
View File

@@ -0,0 +1,72 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const burnEventName = "TOKEN_BURN"
var (
tokenBurnEvent = w3.MustNewEvent("Burn(address indexed _tokenBurner, uint256 _value)")
tokenBurnToSig = w3.MustNewFunc("burn(uint256)", "bool")
)
func HandleTokenBurnLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
tokenBurner common.Address
value big.Int
)
if err := tokenBurnEvent.DecodeArgs(lp.Log, &tokenBurner, &value); err != nil {
return err
}
tokenBurnEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: burnEventName,
Payload: map[string]any{
"tokenBurner": tokenBurner.Hex(),
"value": value.String(),
},
}
return c(ctx, tokenBurnEvent)
}
}
func HandleTokenBurnInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var value big.Int
if err := tokenBurnToSig.DecodeArgs(w3.B(idp.InputData), &value); err != nil {
return err
}
tokenBurnEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: burnEventName,
Payload: map[string]any{
"tokenBurner": idp.From,
"value": value.String(),
},
}
return c(ctx, tokenBurnEvent)
}
}

78
internal/handler/token_mint.go Normal file
View File

@@ -0,0 +1,78 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/w3-celo"
)
const mintEventName = "TOKEN_MINT"
var (
tokenMintEvent = w3.MustNewEvent("Mint(address indexed _tokenMinter, address indexed _beneficiary, uint256 _value)")
tokenMintToSig = w3.MustNewFunc("mintTo(address, uint256)", "bool")
)
func HandleTokenMintLog() router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
tokenMinter common.Address
to common.Address
value big.Int
)
if err := tokenMintEvent.DecodeArgs(lp.Log, &tokenMinter, &to, &value); err != nil {
return err
}
tokenMintEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: mintEventName,
Payload: map[string]any{
"tokenMinter": tokenMinter.Hex(),
"to": to.Hex(),
"value": value.String(),
},
}
return c(ctx, tokenMintEvent)
}
}
func HandleTokenMintInputData() router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
var (
to common.Address
value big.Int
)
if err := tokenMintToSig.DecodeArgs(w3.B(idp.InputData), &to, &value); err != nil {
return err
}
tokenMintEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: mintEventName,
Payload: map[string]any{
"tokenMinter": idp.From,
"to": to.Hex(),
"value": value.String(),
},
}
return c(ctx, tokenMintEvent)
}
}

155
internal/handler/token_transfer.go Normal file
View File

@@ -0,0 +1,155 @@
package handler
import (
"context"
"math/big"
"github.com/celo-org/celo-blockchain/common"
"github.com/grassrootseconomics/celo-tracker/pkg/event"
"github.com/grassrootseconomics/celo-tracker/pkg/router"
"github.com/grassrootseconomics/celoutils/v3"
"github.com/grassrootseconomics/w3-celo"
)
const transferEventName = "TOKEN_TRANSFER"
var (
tokenTransferEvent = w3.MustNewEvent("Transfer(address indexed _from, address indexed _to, uint256 _value)")
tokenTransferSig = w3.MustNewFunc("transfer(address, uint256)", "bool")
tokenTransferFromSig = w3.MustNewFunc("transferFrom(address, address, uint256)", "bool")
stables = map[string]bool{
celoutils.CUSDContractMainnet: true,
celoutils.CKESContractMainnet: true,
celoutils.USDTContractMainnet: true,
celoutils.USDCContractMainnet: true,
}
)
func HandleTokenTransferLog(hc *HandlerContainer) router.LogHandlerFunc {
return func(ctx context.Context, lp router.LogPayload, c router.Callback) error {
var (
from common.Address
to common.Address
value big.Int
)
if err := tokenTransferEvent.DecodeArgs(lp.Log, &from, &to, &value); err != nil {
return err
}
proceed, err := hc.checkStables(ctx, from.Hex(), to.Hex(), lp.Log.Address.Hex())
if err != nil {
return err
}
if !proceed {
return nil
}
tokenTransferEvent := event.Event{
Index: lp.Log.Index,
Block: lp.Log.BlockNumber,
ContractAddress: lp.Log.Address.Hex(),
Success: true,
Timestamp: lp.Timestamp,
TxHash: lp.Log.TxHash.Hex(),
TxType: transferEventName,
Payload: map[string]any{
"from": from.Hex(),
"to": to.Hex(),
"value": value.String(),
},
}
return c(ctx, tokenTransferEvent)
}
}
func HandleTokenTransferInputData(hc *HandlerContainer) router.InputDataHandlerFunc {
return func(ctx context.Context, idp router.InputDataPayload, c router.Callback) error {
tokenTransferEvent := event.Event{
Block: idp.Block,
ContractAddress: idp.ContractAddress,
Success: false,
Timestamp: idp.Timestamp,
TxHash: idp.TxHash,
TxType: transferEventName,
}
switch idp.InputData[:8] {
case "a9059cbb":
var (
to common.Address
value big.Int
)
if err := tokenTransferSig.DecodeArgs(w3.B(idp.InputData), &to, &value); err != nil {
return err
}
proceed, err := hc.checkStables(ctx, idp.From, to.Hex(), idp.ContractAddress)
if err != nil {
return err
}
if !proceed {
return nil
}
tokenTransferEvent.Payload = map[string]any{
"from": idp.From,
"to": to.Hex(),
"value": value.String(),
}
return c(ctx, tokenTransferEvent)
case "23b872dd":
var (
from common.Address
to common.Address
value big.Int
)
if err := tokenTransferFromSig.DecodeArgs(w3.B(idp.InputData), &from, &to, &value); err != nil {
return err
}
proceed, err := hc.checkStables(ctx, from.Hex(), to.Hex(), idp.ContractAddress)
if err != nil {
return err
}
if !proceed {
return nil
}
tokenTransferEvent.Payload = map[string]any{
"from": from.Hex(),
"to": to.Hex(),
"value": value.String(),
}
return c(ctx, tokenTransferEvent)
}
return nil
}
}
func (hc *HandlerContainer) checkStables(ctx context.Context, from string, to string, contractAddress string) (bool, error) {
_, ok := stables[contractAddress]
if !ok {
return true, nil
}
// TODO: Pipeline this check on Redis with a new method
fromExists, err := hc.cache.Exists(ctx, from)
if err != nil {
return false, err
}
toExists, err := hc.cache.Exists(ctx, to)
if err != nil {
return false, err
}
return fromExists || toExists, nil
}