feat(wallet)_: add Approve transaction type

services/wallet/activity/activity.go

@@ -57,9 +57,9 @@ type Entry struct {
 	activityType    Type
 	activityStatus  Status
 	amountOut       *hexutil.Big // Used for activityType SendAT, SwapAT, BridgeAT
-	amountIn        *hexutil.Big // Used for activityType ReceiveAT, BuyAT, SwapAT, BridgeAT
+	amountIn        *hexutil.Big // Used for activityType ReceiveAT, BuyAT, SwapAT, BridgeAT, ApproveAT
 	tokenOut        *Token       // Used for activityType SendAT, SwapAT, BridgeAT
-	tokenIn         *Token       // Used for activityType ReceiveAT, BuyAT, SwapAT, BridgeAT
+	tokenIn         *Token       // Used for activityType ReceiveAT, BuyAT, SwapAT, BridgeAT, ApproveAT
 	symbolOut       *string
 	symbolIn        *string
 	sender          *eth.Address
@@ -260,6 +260,8 @@ func multiTransactionTypeToActivityType(mtType transfer.MultiTransactionType) Ty
 		return SwapAT
 	} else if mtType == transfer.MultiTransactionBridge {
 		return BridgeAT
+	} else if mtType == transfer.MultiTransactionApprove {
+		return ApproveAT
 	}
 	panic("unknown multi transaction type")
 }
@@ -321,6 +323,8 @@ func activityTypesToMultiTransactionTypes(trTypes []Type) []transfer.MultiTransa
 			mtType = transfer.MultiTransactionSwap
 		} else if t == BridgeAT {
 			mtType = transfer.MultiTransactionBridge
+		} else if t == ApproveAT {
+			mtType = transfer.MultiTransactionApprove
 		} else {
 			continue
 		}
@@ -648,7 +652,7 @@ func getActivityEntries(ctx context.Context, deps FilterDependencies, addresses
 
 			mtInAmount, mtOutAmount := getMtInAndOutAmounts(dbMtFromAmount, dbMtToAmount)
 
-			// Extract activity type: SendAT/SwapAT/BridgeAT
+			// Extract activity type: SendAT/SwapAT/BridgeAT/ApproveAT
 			activityType := multiTransactionTypeToActivityType(transfer.MultiTransactionType(dbMtType.Byte))
 
 			if outChainIDDB.Valid && outChainIDDB.Int64 != 0 {

services/wallet/activity/activity_test.go

@@ -606,7 +606,7 @@ func TestGetActivityEntriesCheckOffsetAndLimit(t *testing.T) {
 	}, entries[0])
 }
 
-func countTypes(entries []Entry) (sendCount, receiveCount, contractCount, mintCount, swapCount, buyCount, bridgeCount int) {
+func countTypes(entries []Entry) (sendCount, receiveCount, contractCount, mintCount, swapCount, buyCount, bridgeCount, approveCount int) {
 	for _, entry := range entries {
 		switch entry.activityType {
 		case SendAT:
@@ -623,6 +623,8 @@ func countTypes(entries []Entry) (sendCount, receiveCount, contractCount, mintCo
 			contractCount++
 		case MintAT:
 			mintCount++
+		case ApproveAT:
+			approveCount++
 		}
 	}
 	return
@@ -634,14 +636,15 @@ func TestGetActivityEntriesFilterByType(t *testing.T) {
 
 	// Adds 4 extractable transactions
 	td, tdFromAdds, tdToAddrs := fillTestData(t, deps.db)
-	// Add 5 extractable transactions: one MultiTransactionSwap, two MultiTransactionBridge and two MultiTransactionSend
-	multiTxs := make([]transfer.MultiTransaction, 5)
+	// Add 6 extractable transactions: one MultiTransactionSwap, two MultiTransactionBridge, two MultiTransactionSend and one MultiTransactionApprove
+	multiTxs := make([]transfer.MultiTransaction, 6)
 	trs, fromAddrs, toAddrs := transfer.GenerateTestTransfers(t, deps.db, td.nextIndex, len(multiTxs)*2)
 	multiTxs[0] = transfer.GenerateTestBridgeMultiTransaction(trs[0], trs[1])
 	multiTxs[1] = transfer.GenerateTestSwapMultiTransaction(trs[2], testutils.SntSymbol, 100) // trs[3]
 	multiTxs[2] = transfer.GenerateTestSendMultiTransaction(trs[4])                           // trs[5]
 	multiTxs[3] = transfer.GenerateTestBridgeMultiTransaction(trs[6], trs[7])
-	multiTxs[4] = transfer.GenerateTestSendMultiTransaction(trs[8]) // trs[9]
+	multiTxs[4] = transfer.GenerateTestSendMultiTransaction(trs[8])     // trs[9]
+	multiTxs[5] = transfer.GenerateTestApproveMultiTransaction(trs[10]) // trs[11]
 
 	var lastMT common.MultiTransactionIDType
 	for i := range trs {
@@ -684,10 +687,10 @@ func TestGetActivityEntriesFilterByType(t *testing.T) {
 
 	filter.Types = allActivityTypesFilter()
 	// Set tr1 to Receive and pendingTr to Send; rest of two MT remain default Send
-	addresses := []eth.Address{td.tr1.To, td.pendingTr.From, td.multiTx1.FromAddress, td.multiTx2.FromAddress, trs[0].From, trs[2].From, trs[4].From, trs[6].From, trs[8].From, trsSpecial[0].To, trsSpecial[1].To, trsSpecial[2].From}
+	addresses := []eth.Address{td.tr1.To, td.pendingTr.From, td.multiTx1.FromAddress, td.multiTx2.FromAddress, trs[0].From, trs[2].From, trs[4].From, trs[6].From, trs[8].From, trs[10].From, trsSpecial[0].To, trsSpecial[1].To, trsSpecial[2].From}
 	entries, err := getActivityEntries(context.Background(), deps, addresses, false, []common.ChainID{}, filter, 0, 15)
 	require.NoError(t, err)
-	require.Equal(t, 12, len(entries))
+	require.Equal(t, 13, len(entries))
 
 	filter.Types = []Type{SendAT, SwapAT}
 	entries, err = getActivityEntries(context.Background(), deps, addresses, false, []common.ChainID{}, filter, 0, 15)
@@ -696,53 +699,71 @@ func TestGetActivityEntriesFilterByType(t *testing.T) {
 	// 3 from td Send + 2 trs MT Send + 1 (swap)
 	require.Equal(t, 6, len(entries))
 
-	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount := countTypes(entries)
+	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount, approveCount := countTypes(entries)
 
 	require.Equal(t, 5, sendCount)
 	require.Equal(t, 0, receiveCount)
 	require.Equal(t, 0, contractCount)
 	require.Equal(t, 0, mintCount)
 	require.Equal(t, 1, swapCount)
 	require.Equal(t, 0, bridgeCount)
+	require.Equal(t, 0, approveCount)
 
 	filter.Types = []Type{BridgeAT, ReceiveAT}
 	entries, err = getActivityEntries(context.Background(), deps, addresses, false, []common.ChainID{}, filter, 0, 15)
 	require.NoError(t, err)
 	require.Equal(t, 3, len(entries))
 
-	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount = countTypes(entries)
+	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount, approveCount = countTypes(entries)
 	require.Equal(t, 0, sendCount)
 	require.Equal(t, 1, receiveCount)
 	require.Equal(t, 0, contractCount)
 	require.Equal(t, 0, mintCount)
 	require.Equal(t, 0, swapCount)
 	require.Equal(t, 2, bridgeCount)
+	require.Equal(t, 0, approveCount)
 
 	filter.Types = []Type{MintAT}
 	entries, err = getActivityEntries(context.Background(), deps, addresses, false, []common.ChainID{}, filter, 0, 15)
 	require.NoError(t, err)
 	require.Equal(t, 2, len(entries))
 
-	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount = countTypes(entries)
+	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount, approveCount = countTypes(entries)
 	require.Equal(t, 0, sendCount)
 	require.Equal(t, 0, receiveCount)
 	require.Equal(t, 0, contractCount)
 	require.Equal(t, 2, mintCount)
 	require.Equal(t, 0, swapCount)
 	require.Equal(t, 0, bridgeCount)
+	require.Equal(t, 0, approveCount)
 
 	filter.Types = []Type{ContractDeploymentAT}
 	entries, err = getActivityEntries(context.Background(), deps, addresses, false, []common.ChainID{}, filter, 0, 15)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(entries))
 
-	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount = countTypes(entries)
+	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount, approveCount = countTypes(entries)
 	require.Equal(t, 0, sendCount)
 	require.Equal(t, 0, receiveCount)
 	require.Equal(t, 1, contractCount)
 	require.Equal(t, 0, mintCount)
 	require.Equal(t, 0, swapCount)
 	require.Equal(t, 0, bridgeCount)
+	require.Equal(t, 0, approveCount)
+
+	filter.Types = []Type{ApproveAT}
+	entries, err = getActivityEntries(context.Background(), deps, addresses, false, []common.ChainID{}, filter, 0, 15)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(entries))
+
+	sendCount, receiveCount, contractCount, mintCount, swapCount, _, bridgeCount, approveCount = countTypes(entries)
+	require.Equal(t, 0, sendCount)
+	require.Equal(t, 0, receiveCount)
+	require.Equal(t, 0, contractCount)
+	require.Equal(t, 0, mintCount)
+	require.Equal(t, 0, swapCount)
+	require.Equal(t, 0, bridgeCount)
+	require.Equal(t, 1, approveCount)
 
 	// Filter with all addresses regression
 	filter.Types = []Type{SendAT}

services/wallet/activity/filter.go

@@ -41,6 +41,7 @@ const (
 	BridgeAT
 	ContractDeploymentAT
 	MintAT
+	ApproveAT
 )
 
 func allActivityTypesFilter() []Type {

services/wallet/transfer/multi_transaction_db.go

@@ -19,6 +19,7 @@ const (
 	MultiTransactionDBSend        = iota
 	MultiTransactionDBSwap
 	MultiTransactionDBBridge
+	MultiTransactionDBApprove
 )
 
 func mtDBTypeToMTType(mtDBType MultiTransactionDBType) MultiTransactionType {

services/wallet/transfer/testutils.go

@@ -148,6 +148,20 @@ func GenerateTestBridgeMultiTransaction(fromTr, toTr TestTransfer) MultiTransact
 	}
 }
 
+func GenerateTestApproveMultiTransaction(tr TestTransfer) MultiTransaction {
+	return MultiTransaction{
+		ID:          multiTransactionIDGenerator(),
+		Type:        MultiTransactionApprove,
+		FromAddress: tr.From,
+		ToAddress:   tr.To,
+		FromAsset:   tr.Token.Symbol,
+		ToAsset:     tr.Token.Symbol,
+		FromAmount:  (*hexutil.Big)(big.NewInt(tr.Value)),
+		ToAmount:    (*hexutil.Big)(big.NewInt(0)),
+		Timestamp:   uint64(tr.Timestamp),
+	}
+}
+
 // GenerateTestTransfers will generate transaction based on the TestTokens index and roll over if there are more than
 // len(TestTokens) transactions
 func GenerateTestTransfers(tb testing.TB, db *sql.DB, firstStartIndex int, count int) (result []TestTransfer, fromAddresses, toAddresses []eth_common.Address) {

services/wallet/transfer/transaction_manager.go

@@ -84,6 +84,7 @@ const (
 	MultiTransactionSend = iota
 	MultiTransactionSwap
 	MultiTransactionBridge
+	MultiTransactionApprove
 	MultiTransactionTypeInvalid = 255
 )