Merge branch 'develop' into feat/index-backward-let

Stefan-Ethernal · Stefan-Ethernal · commit 04f3b2e70113 · 2025-12-17T14:45:45.000+01:00
diff --git a/.github/test_e2e_cdk_erigon_args_base.json b/.github/test_e2e_cdk_erigon_args_base.json
@@ -18,7 +18,7 @@
     "zkevm_use_real_verifier": false,
     "sp1_prover_key": "",
     "sequencer_type": "erigon",
-    "cdk_erigon_node_image": "hermeznetwork/cdk-erigon:v2.63.0-rc4",
+    "cdk_erigon_image": "europe-west2-docker.pkg.dev/prj-polygonlabs-devtools-dev/public/cdk-erigon:v2.65.0-RC1",
     "enable_normalcy": true,
     "erigon_strict_mode": false,
     "gas_token_enabled": false,
diff --git a/.github/workflows/test-e2e.yml b/.github/workflows/test-e2e.yml
@@ -54,7 +54,7 @@ jobs:
             fi
           else
             # For push/workflow_dispatch, use the fixed commit
-            COMMIT="413f956c9dde7084af4a39e3d082546ef8bb4a79"
+            COMMIT="b959a5f2b7e8247ae09e16fd9f51c1e23a1ab5ee"
             echo "Using fixed kurtosis-cdk commit: ${COMMIT}"
           fi
           echo "commit=${COMMIT}" >> $GITHUB_OUTPUT
diff --git a/bridgeservice/bridge_test.go b/bridgeservice/bridge_test.go
@@ -535,6 +535,8 @@ func TestGetBridgesHandler(t *testing.T) {
 				Amount:             common.Big0,
 				DepositCount:       0,
 				Metadata:           []byte("metadata"),
+				TxnSender:          common.HexToAddress("0x5555555555555555555555555555555555555555"),
+				ToAddress:          common.HexToAddress("0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"),
 			},
 		}
 
@@ -567,6 +569,11 @@ func TestGetBridgesHandler(t *testing.T) {
 
 		require.Equal(t, bridgeResponses, response.Bridges)
 		require.Equal(t, len(expectedBridges), response.Count)
+
+		// Verify to_address is present in the response
+		require.NotNil(t, response.Bridges)
+		require.Len(t, response.Bridges, 1)
+		require.Equal(t, bridgetypes.Address("0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"), response.Bridges[0].ToAddress)
 	})
 
 	t.Run("GetBridges for L1 network error", func(t *testing.T) {
diff --git a/bridgeservice/docs/docs.go b/bridgeservice/docs/docs.go
@@ -801,6 +801,11 @@ const docTemplate = `{
                     "type": "integer",
                     "example": 10
                 },
+                "to_address": {
+                    "description": "Address of the contract that was the recipient of the transaction. This may differ from the bridge contract address.",
+                    "type": "string",
+                    "example": "0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"
+                },
                 "tx_hash": {
                     "description": "Hash of the transaction that included the bridge event",
                     "type": "string",
diff --git a/bridgeservice/docs/swagger.json b/bridgeservice/docs/swagger.json
@@ -794,6 +794,11 @@
                     "type": "integer",
                     "example": 10
                 },
+                "to_address": {
+                    "description": "Address of the contract that was the recipient of the transaction. This may differ from the bridge contract address.",
+                    "type": "string",
+                    "example": "0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"
+                },
                 "tx_hash": {
                     "description": "Hash of the transaction that included the bridge event",
                     "type": "string",
diff --git a/bridgeservice/docs/swagger.yaml b/bridgeservice/docs/swagger.yaml
@@ -80,6 +80,11 @@ definitions:
         description: ID of the network where the bridge transaction originated
         example: 10
         type: integer
+      to_address:
+        description: Address of the contract that was the recipient of the transaction.
+          This may differ from the bridge contract address.
+        example: 0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0
+        type: string
       tx_hash:
         description: Hash of the transaction that included the bridge event
         example: 0xdef4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef
diff --git a/bridgeservice/types/types.go b/bridgeservice/types/types.go
@@ -140,6 +140,9 @@ type BridgeResponse struct {
 
 	// Address of the transaction sender who initiated the bridge transaction
 	TxnSender Address `json:"txn_sender" example:"0xabc1234567890abcdef1234567890abcdef12345"`
+
+	// Address of the contract that was the recipient of the transaction. This may differ from the bridge contract address.
+	ToAddress Address `json:"to_address" example:"0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"`
 }
 
 // ClaimsResult contains the list of claim records and the total count
diff --git a/bridgeservice/utils.go b/bridgeservice/utils.go
@@ -144,6 +144,7 @@ func NewBridgeResponse(bridge *bridgesync.Bridge, networkID uint32,
 		DepositCount:       bridge.DepositCount,
 		BridgeHash:         bridgetypes.Hash(bridge.Hash().Hex()),
 		TxnSender:          bridgetypes.Address(bridge.TxnSender.Hex()),
+		ToAddress:          bridgetypes.Address(bridge.ToAddress.Hex()),
 	}
 }
 
diff --git a/bridgesync/backfill_tx_sender.go b/bridgesync/backfill_tx_sender.go
@@ -337,7 +337,8 @@ func (b *BackfillTxnSender) extractData(ctx context.Context,
 		return common.Address{}, common.Address{}, ctx.Err()
 	default:
 	}
-	return ExtractTxnSenderAndFrom(ctx, b.client, b.bridgeAddr, txHash, logEvent, b.log)
+	txnSender, fromAddr, _, err = ExtractTxnAddresses(ctx, b.client, b.bridgeAddr, txHash, logEvent, b.log)
+	return txnSender, fromAddr, err
 }
 
 // bulkUpdate performs a bulk update of multiple records
@@ -370,7 +371,7 @@ func (b *BackfillTxnSender) bulkUpdate(
 
 	stmt, err := tx.PrepareContext(dbCtx, fmt.Sprintf(`
 		UPDATE %s
-		SET 
+		SET
 			txn_sender = COALESCE(NULLIF(txn_sender, ''), ?),
 			from_address = COALESCE(NULLIF(from_address, ''), ?)
 		WHERE block_num = ? AND block_pos = ?;
diff --git a/bridgesync/downloader.go b/bridgesync/downloader.go
@@ -144,6 +144,13 @@ func (t *Transaction) From() common.Address {
 	return common.HexToAddress(t.FromRaw)
 }
 
+func (t *Transaction) ToAddress() common.Address {
+	if t.To == "" {
+		return common.Address{}
+	}
+	return common.HexToAddress(t.To)
+}
+
 func RPCTransactionByHash(client aggkittypes.EthClienter,
 	txHash common.Hash) (*Transaction, error) {
 	// Use client.Call to fetch transaction details using eth_getTransactionByHash
@@ -155,33 +162,25 @@ func RPCTransactionByHash(client aggkittypes.EthClienter,
 	return &tx, nil
 }
 
-func extractTxnSender(
-	client aggkittypes.EthClienter,
-	txHash common.Hash) (common.Address, error) {
-	tx, err := RPCTransactionByHash(client, txHash)
-	if err != nil {
-		return common.Address{}, fmt.Errorf("failed to get transaction by hash for %s: %w", txHash.Hex(), err)
-	}
-	return tx.From(), nil
-}
-
-// ExtractTxnSenderAndFrom extracts the txn_sender and from address from the transaction trace.
-// Return txnSender (same for all events in the same transaction) and fromAddr (specific for the event)
-func ExtractTxnSenderAndFrom(ctx context.Context,
+// ExtractTxnAddresses extracts the txn_sender, from address, and to address from the transaction trace.
+func ExtractTxnAddresses(ctx context.Context,
 	client aggkittypes.EthClienter,
 	bridgeAddr common.Address,
 	txHash common.Hash,
 	logEvent *agglayerbridge.AgglayerbridgeBridgeEvent,
-	logger *logger.Logger) (txnSender common.Address, fromAddr common.Address, err error) {
+	logger *logger.Logger) (txnSender common.Address, fromAddr common.Address, toAddr common.Address, err error) {
 	// If event is a message, fromAddr is log.origin_address
 	// so we only need the txn_sender that can be obtained from hash_receipt
+	// and toAddr from the transaction receipt (same source as txn_sender)
 	if logEvent.LeafType == bridgeLeafTypeMessage {
-		txnSender, err = extractTxnSender(client, txHash)
+		tx, err := RPCTransactionByHash(client, txHash)
 		if err != nil {
-			return common.Address{}, common.Address{},
-				fmt.Errorf("extractTxnSenderAndFrom: failed to extract txn sender from tx_hash:%s: %w", txHash.Hex(), err)
+			return common.Address{}, common.Address{}, common.Address{},
+				fmt.Errorf("extractTxnAddresses: failed to extract txn sender from tx_hash:%s: %w", txHash.Hex(), err)
 		}
-		return txnSender, logEvent.OriginAddress, nil
+		txnSender = tx.From()
+		toAddr = tx.ToAddress()
+		return txnSender, logEvent.OriginAddress, toAddr, nil
 	}
 	foundCalls, rootCall, err := extractCallData(client, bridgeAddr, txHash, logger, func(c Call) (bool, error) {
 		if logEvent.LeafType == bridgeLeafTypeAsset {
@@ -190,18 +189,19 @@ func ExtractTxnSenderAndFrom(ctx context.Context,
 		return false, nil
 	})
 	if err != nil {
-		return common.Address{}, common.Address{},
-			fmt.Errorf("extractTxnSenderAndFrom:failed to extract bridge event data (tx hash: %s): %w", txHash, err)
+		return common.Address{}, common.Address{}, common.Address{},
+			fmt.Errorf("extractTxnAddresses:failed to extract bridge event data (tx hash: %s): %w", txHash, err)
 	}
 	txnSender = rootCall.From
+	toAddr = rootCall.To
 	fromAddr, err = ExtractFromAddrFromCalls(foundCalls, logEvent)
 	if err != nil {
-		return common.Address{}, common.Address{},
-			fmt.Errorf("extractTxnSenderAndFrom: failed to extract fromAddr from tx_hash:%s calls: %w",
+		return common.Address{}, common.Address{}, common.Address{},
+			fmt.Errorf("extractTxnAddresses: failed to extract fromAddr from tx_hash:%s calls: %w",
 				txHash.Hex(), err)
 	}
 
-	return txnSender, fromAddr, nil
+	return txnSender, fromAddr, toAddr, nil
 }
 
 type bridgeCallParams struct {
@@ -360,7 +360,7 @@ func buildBridgeEventHandler(
 			"DestinationNetwork: %d, DestinationAddress: %s, DepositCount: %d, Amount: %s, ",
 			bridgeEvent.LeafType, bridgeEvent.OriginNetwork, bridgeEvent.OriginAddress.Hex(), bridgeEvent.DestinationNetwork,
 			bridgeEvent.DestinationAddress.Hex(), bridgeEvent.DepositCount, bridgeEvent.Amount.String())
-		txnSender, fromAddress, err := ExtractTxnSenderAndFrom(ctx, client, bridgeAddr, l.TxHash,
+		txnSender, fromAddress, toAddress, err := ExtractTxnAddresses(ctx, client, bridgeAddr, l.TxHash,
 			bridgeEvent, logger)
 		if err != nil {
 			return fmt.Errorf("failed to extract bridge event data (tx hash: %s): %w", l.TxHash, err)
@@ -381,6 +381,7 @@ func buildBridgeEventHandler(
 			Metadata:           bridgeEvent.Metadata,
 			DepositCount:       bridgeEvent.DepositCount,
 			TxnSender:          txnSender,
+			ToAddress:          toAddress,
 		}})
 		return nil
 	}
diff --git a/bridgesync/downloader_test.go b/bridgesync/downloader_test.go
@@ -28,7 +28,7 @@ import (
 // mainnet:
 // case https://etherscan.io/tx/0x8db8e288d25102b64d8a37ad05769817d1b43f0384dd05da075d24d2cee9cb65 (bn: 19566985) -> fix
 // case: https://etherscan.io/tx/0x0b276867aa22d1c162c2700d35c500a124a6a953c7b24931a1d3efc63f7cd4ab  (bn: 22770713)
-func TestExtractTxnSenderAndFromExploratory(t *testing.T) {
+func TestExtractTxnAddressesExploratory(t *testing.T) {
 	t.Skip("Skipping exploratory test")
 	ctx := t.Context()
 	l1url := os.Getenv("L1URL")
@@ -1053,7 +1053,7 @@ func TestTxnSenderField(t *testing.T) {
 	}
 }
 
-func TestExtractTxnSenderAndFrom(t *testing.T) {
+func TestExtractTxnAddresses(t *testing.T) {
 	bridgeAddr := common.HexToAddress("0x10")
 	txHash := common.HexToHash("0xabcde12345abcde12345abcde12345abcde12345abcde12345abcde12345abcd")
 
@@ -1066,6 +1066,7 @@ func TestExtractTxnSenderAndFrom(t *testing.T) {
 		responseTransactionHashError error
 		expectedTxnSender            common.Address
 		expectedFrom                 common.Address
+		expectedTo                   common.Address
 		expectErr                    string
 	}{
 		{
@@ -1079,6 +1080,23 @@ func TestExtractTxnSenderAndFrom(t *testing.T) {
 			responseTransactionHashError: fmt.Errorf("RPC error"),
 			expectErr:                    "RPC error",
 		},
+		{
+			name: "messageLeaf: successful extraction with to address",
+			logEvent: &agglayerbridge.AgglayerbridgeBridgeEvent{
+				LeafType:           bridgeLeafTypeMessage,
+				OriginAddress:      common.HexToAddress("0x40"),
+				DestinationNetwork: 1,
+				DestinationAddress: common.HexToAddress("0x30"),
+				Amount:             big.NewInt(100),
+			},
+			responseTransactionHash: &Transaction{
+				FromRaw: "0x1111111111111111111111111111111111111111",
+				To:      "0x2222222222222222222222222222222222222222",
+			},
+			expectedTxnSender: common.HexToAddress("0x1111111111111111111111111111111111111111"),
+			expectedFrom:      common.HexToAddress("0x40"),
+			expectedTo:        common.HexToAddress("0x2222222222222222222222222222222222222222"),
+		},
 		{
 			name: "assetLeaf: error can't find From from calls",
 			logEvent: &agglayerbridge.AgglayerbridgeBridgeEvent{
@@ -1103,6 +1121,30 @@ func TestExtractTxnSenderAndFrom(t *testing.T) {
 			},
 			expectErr: "failed to extract",
 		},
+		{
+			name: "assetLeaf: successful extraction with to address from rootCall",
+			logEvent: &agglayerbridge.AgglayerbridgeBridgeEvent{
+				LeafType:           bridgeLeafTypeAsset,
+				OriginAddress:      common.HexToAddress("0x50"),
+				DestinationNetwork: 1,
+				DestinationAddress: common.HexToAddress("0x30"),
+				Amount:             big.NewInt(100),
+			},
+			responseDebugTrace: &Call{
+				From: common.HexToAddress("0x3333333333333333333333333333333333333333"),
+				To:   common.HexToAddress("0x4444444444444444444444444444444444444444"),
+				Calls: []Call{
+					{
+						To:    bridgeAddr,
+						From:  common.HexToAddress("0x50"),
+						Input: append(BridgeAssetMethodID, make([]byte, 100)...),
+					},
+				},
+			},
+			expectedTxnSender: common.HexToAddress("0x3333333333333333333333333333333333333333"),
+			expectedFrom:      common.HexToAddress("0x50"),
+			expectedTo:        common.HexToAddress("0x4444444444444444444444444444444444444444"),
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1128,14 +1170,15 @@ func TestExtractTxnSenderAndFrom(t *testing.T) {
 				}).Return(nil).
 				Maybe()
 
-			txnSender, from, err := ExtractTxnSenderAndFrom(ctx, ethClient,
+			txnSender, from, to, err := ExtractTxnAddresses(ctx, ethClient,
 				bridgeAddr, txHash, tt.logEvent, logger)
 			if tt.expectErr != "" {
 				require.ErrorContains(t, err, tt.expectErr)
 			} else {
 				require.NoError(t, err)
 				require.Equal(t, tt.expectedTxnSender, txnSender)
 				require.Equal(t, tt.expectedFrom, from)
+				require.Equal(t, tt.expectedTo, to)
 			}
 		})
 	}
diff --git a/bridgesync/e2e_test.go b/bridgesync/e2e_test.go
@@ -78,6 +78,12 @@ func TestBridgeEventE2E(t *testing.T) {
 		bridge.BlockTimestamp = block.Time()
 		require.NoError(t, err)
 		require.Equal(t, receipt.Status, types.ReceiptStatusSuccessful)
+		// Extract ToAddress from the transaction
+		txDetails, _, err := simulatedClient.TransactionByHash(ctx, tx.Hash())
+		require.NoError(t, err)
+		if txDetails.To() != nil {
+			bridge.ToAddress = *txDetails.To()
+		}
 		expectedBridges = append(expectedBridges, bridge)
 		expectedRoot, err := l1Setup.BridgeContract.GetRoot(nil)
 		require.NoError(t, err)
diff --git a/bridgesync/migrations/bridgesync0012.sql b/bridgesync/migrations/bridgesync0012.sql
@@ -3,6 +3,7 @@ DROP TRIGGER IF EXISTS archive_bridge_before_delete;
 DROP TABLE IF EXISTS bridge_archive;
 DROP TABLE IF EXISTS backward_let;
 ALTER TABLE bridge DROP COLUMN source;
+ALTER TABLE bridge DROP COLUMN to_address;
 
 -- +migrate Up
 CREATE TABLE IF NOT EXISTS backward_let (
@@ -79,4 +80,5 @@ BEGIN
     );
 END;
 
-ALTER TABLE bridge ADD COLUMN source TEXT;
+ALTER TABLE bridge ADD COLUMN source TEXT;
+ALTER TABLE bridge ADD COLUMN to_address VARCHAR;
diff --git a/bridgesync/migrations/migrations.go b/bridgesync/migrations/migrations.go
@@ -45,6 +45,9 @@ func init() {
 	})
 }
 
+//go:embed bridgesync0012.sql
+var mig0012 string
+
 func RunMigrations(dbPath string) error {
 	// Pre-calculate total length
 	total := len(migrations) + len(treemigrations.Migrations)
diff --git a/bridgesync/processor.go b/bridgesync/processor.go
@@ -146,6 +146,7 @@ type Bridge struct {
 	DepositCount       uint32         `meddler:"deposit_count"`
 	TxnSender          common.Address `meddler:"txn_sender,address"`
 	Source             BridgeSource   `meddler:"source"`
+	ToAddress          common.Address `meddler:"to_address,address"`
 }
 
 func (b *Bridge) String() string {
@@ -156,11 +157,11 @@ func (b *Bridge) String() string {
 	return fmt.Sprintf("Bridge{BlockNum: %d, BlockPos: %d, FromAddress: %s, TxHash: %s, "+
 		"BlockTimestamp: %d, LeafType: %d, OriginNetwork: %d, OriginAddress: %s, "+
 		"DestinationNetwork: %d, DestinationAddress: %s, Amount: %s, Metadata: %x, "+
-		"DepositCount: %d, TxnSender: %s, Source: %s}",
+		"DepositCount: %d, TxnSender: %s, Source: %s, ToAddress: %s}",
 		b.BlockNum, b.BlockPos, b.FromAddress.String(), b.TxHash.String(),
 		b.BlockTimestamp, b.LeafType, b.OriginNetwork, b.OriginAddress.String(),
 		b.DestinationNetwork, b.DestinationAddress.String(), amountStr, b.Metadata,
-		b.DepositCount, b.TxnSender.String(), b.Source)
+		b.DepositCount, b.TxnSender.String(), b.Source, b.ToAddress.String())
 }
 
 // Hash returns the hash of the bridge event as expected by the exit tree
diff --git a/docs/assets/swagger/bridge_service/swagger.json b/docs/assets/swagger/bridge_service/swagger.json
@@ -794,6 +794,11 @@
                     "type": "integer",
                     "example": 10
                 },
+                "to_address": {
+                    "description": "Address of the contract that was the recipient of the transaction. This may differ from the bridge contract address.",
+                    "type": "string",
+                    "example": "0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"
+                },
                 "tx_hash": {
                     "description": "Hash of the transaction that included the bridge event",
                     "type": "string",

Original file line number	Diff line number	Diff line change
`@@ -140,6 +140,9 @@ type BridgeResponse struct {`
`140`	`140`
`141`	`141`	`// Address of the transaction sender who initiated the bridge transaction`
`142`	`142`	TxnSender Address `json:"txn_sender" example:"0xabc1234567890abcdef1234567890abcdef12345"`
	`143`	`+`
	`144`	`+ // Address of the contract that was the recipient of the transaction. This may differ from the bridge contract address.`
	`145`	+ ToAddress Address `json:"to_address" example:"0xF9D64d54D32EE2BDceAAbFA60C4C438E224427d0"`
`143`	`146`	`}`
`144`	`147`
`145`	`148`	`// ClaimsResult contains the list of claim records and the total count`
Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ func NewBridgeResponse(bridge *bridgesync.Bridge, networkID uint32,`
`144`	`144`	`DepositCount: bridge.DepositCount,`
`145`	`145`	`BridgeHash: bridgetypes.Hash(bridge.Hash().Hex()),`
`146`	`146`	`TxnSender: bridgetypes.Address(bridge.TxnSender.Hex()),`
	`147`	`+ ToAddress: bridgetypes.Address(bridge.ToAddress.Hex()),`
`147`	`148`	`}`
`148`	`149`	`}`
`149`	`150`