feat: bidder node: Include shutter specific fields

p2p/gen/openapi/bidderapi/v1/bidderapi.swagger.yaml

@@ -458,6 +458,9 @@ definitions:
       positionConstraint:
         $ref: '#/definitions/bidderapiv1PositionConstraint'
         description: Position constraint for the transaction in the block.
+      shutterisedBidOption:
+        $ref: '#/definitions/bidderapiv1ShutterisedBidOption'
+        description: Shutterised bid option for the transaction in the block.
   bidderapiv1BidOptions:
     type: object
     properties:
@@ -556,6 +559,17 @@ definitions:
       - BASIS_PERCENTILE: Position is a percentile of the block size
        - BASIS_ABSOLUTE: Position is an absolute position in the block
        - BASIS_GAS_PERCENTILE: Position is a percentile of the gas used in the block
+  bidderapiv1ShutterisedBidOption:
+    type: object
+    properties:
+      identityPrefix:
+        type: string
+        description: Hex string encoding of the identity prefix of the transaction that the bidder wants to include in the block.
+        pattern: '[a-fA-F0-9]{64}'
+      encryptedTx:
+        type: string
+        description: Hex string encoding of the encrypted transaction that the bidder wants to include in the block.
+        pattern: '[a-fA-F0-9]+'
   googlerpcStatus:
     type: object
     properties:

p2p/gen/openapi/debugapi/v1/debugapi.swagger.yaml

@@ -86,7 +86,7 @@ definitions:
       `NullValue` is a singleton enumeration to represent the null value for the
       `Value` type union.
 
-      The JSON representation for `NullValue` is JSON `null`.
+       The JSON representation for `NullValue` is JSON `null`.
   v1CancelTransactionResponse:
     type: object
     example:

p2p/gen/openapi/notificationsapi/v1/notifications.swagger.yaml

@@ -123,7 +123,7 @@ definitions:
       `NullValue` is a singleton enumeration to represent the null value for the
       `Value` type union.
 
-      The JSON representation for `NullValue` is JSON `null`.
+       The JSON representation for `NullValue` is JSON `null`.
   v1Notification:
     type: object
     properties:

p2p/gen/openapi/providerapi/v1/providerapi.swagger.yaml

@@ -323,6 +323,9 @@ definitions:
       positionConstraint:
         $ref: '#/definitions/providerapiv1PositionConstraint'
         description: Position constraint for the transaction in the block.
+      shutterisedBidOption:
+        $ref: '#/definitions/providerapiv1ShutterisedBidOption'
+        description: Shutterised bid option for the transaction in the block.
   providerapiv1BidOptions:
     type: object
     properties:
@@ -369,6 +372,17 @@ definitions:
       - BASIS_PERCENTILE: Position is a percentile of the block size
        - BASIS_ABSOLUTE: Position is an absolute position in the block
        - BASIS_GAS_PERCENTILE: Position is a percentile of the gas used in the block
+  providerapiv1ShutterisedBidOption:
+    type: object
+    properties:
+      identityPrefix:
+        type: string
+        description: Hex string encoding of the identity prefix of the transaction that the bidder wants to include in the block.
+        pattern: '[a-fA-F0-9]{64}'
+      encryptedTx:
+        type: string
+        description: Hex string encoding of the encrypted transaction that the bidder wants to include in the block.
+        pattern: '[a-fA-F0-9]{64}'
   v1BidResponse:
     type: object
     example:

p2p/pkg/rpc/bidder/service.go

@@ -177,6 +177,7 @@ func (s *Service) SendBid(
 	case len(bid.RawTransactions) > 0:
 		strBuilder := new(strings.Builder)
 		for i, rawTx := range bid.RawTransactions {
+
 			rawTxnBytes, err := hex.DecodeString(strings.TrimPrefix(rawTx, "0x"))
 			if err != nil {
 				s.logger.Error("decoding raw transaction", "error", err)

p2p/pkg/rpc/bidder/service_test.go

@@ -851,6 +851,222 @@ func TestGetBidInfo(t *testing.T) {
 	})
 }
 
+func TestShutterisedBidOptions(t *testing.T) {
+	t.Parallel()
+
+	client := startServer(t)
+
+	t.Run("shutterised bid option validation", func(t *testing.T) {
+		type testCase struct {
+			name           string
+			identityPrefix string
+			encryptedTx    string
+			expectError    bool
+		}
+
+		for _, tc := range []testCase{
+			{
+				name:           "valid shutterised bid option",
+				identityPrefix: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				encryptedTx:    "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				expectError:    false,
+			},
+			{
+				name:           "invalid identity prefix - too short",
+				identityPrefix: "0x1234567890abcdef",
+				encryptedTx:    "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				expectError:    true,
+			},
+			{
+				name:           "invalid identity prefix - contains non-hex",
+				identityPrefix: "0xgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg",
+				encryptedTx:    "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				expectError:    true,
+			},
+			{
+				name:           "empty identity prefix",
+				identityPrefix: "",
+				encryptedTx:    "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				expectError:    true,
+			},
+			{
+				name:           "invalid encrypted tx - contains non-hex",
+				identityPrefix: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				encryptedTx:    "0xgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg",
+				expectError:    true,
+			},
+			{
+				name:           "empty encrypted tx",
+				identityPrefix: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				encryptedTx:    "",
+				expectError:    true,
+			},
+			{
+				name:           "both fields empty",
+				identityPrefix: "",
+				encryptedTx:    "",
+				expectError:    true,
+			},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				rcv, err := client.SendBid(context.Background(), &bidderapiv1.Bid{
+					TxHashes:            []string{"abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"},
+					Amount:              "1000000000000000000",
+					BlockNumber:         1,
+					DecayStartTimestamp: 10,
+					DecayEndTimestamp:   20,
+					BidOptions: &bidderapiv1.BidOptions{
+						Options: []*bidderapiv1.BidOption{
+							{
+								Opt: &bidderapiv1.BidOption_ShutterisedBidOption{
+									ShutterisedBidOption: &bidderapiv1.ShutterisedBidOption{
+										IdentityPrefix: tc.identityPrefix,
+										EncryptedTx:    tc.encryptedTx,
+									},
+								},
+							},
+						},
+					},
+				})
+
+				if tc.expectError {
+					// For invalid cases, we expect validation error during SendBid
+					if err != nil {
+						// Check that it's a validation error
+						if !strings.Contains(err.Error(), "validation") {
+							t.Fatalf("expected validation error, got: %v", err)
+						}
+						return
+					}
+
+					// If no error during SendBid, check if error comes during Recv()
+					_, err = rcv.Recv()
+					if err == nil {
+						t.Fatalf("expected validation error but got none")
+					}
+					if !strings.Contains(err.Error(), "validation") {
+						t.Fatalf("expected validation error during recv, got: %v", err)
+					}
+					return
+				}
+
+				// For valid cases, we expect no error during SendBid
+				if err != nil {
+					t.Fatalf("unexpected error for valid shutterised bid option: %v", err)
+				}
+
+				// Verify we get preconfs
+				count := 0
+				for {
+					_, err := rcv.Recv()
+					if err != nil {
+						if errors.Is(err, io.EOF) {
+							break
+						}
+						t.Fatalf("error receiving preconfs: %v", err)
+					}
+					count++
+				}
+				if count != 2 {
+					t.Fatalf("expected 2 preconfs, got %v", count)
+				}
+			})
+		}
+	})
+
+	t.Run("multiple shutterised bid options", func(t *testing.T) {
+		rcv, err := client.SendBid(context.Background(), &bidderapiv1.Bid{
+			TxHashes: []string{
+				common.HexToHash("0x0000ab").Hex()[2:],
+				common.HexToHash("0x0000cd").Hex()[2:],
+			},
+			Amount:              "1000000000000000000",
+			BlockNumber:         1,
+			DecayStartTimestamp: 10,
+			DecayEndTimestamp:   20,
+			BidOptions: &bidderapiv1.BidOptions{
+				Options: []*bidderapiv1.BidOption{
+					{
+						Opt: &bidderapiv1.BidOption_ShutterisedBidOption{
+							ShutterisedBidOption: &bidderapiv1.ShutterisedBidOption{
+								IdentityPrefix: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+								EncryptedTx:    "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+							},
+						},
+					},
+					{
+						Opt: &bidderapiv1.BidOption_ShutterisedBidOption{
+							ShutterisedBidOption: &bidderapiv1.ShutterisedBidOption{
+								IdentityPrefix: "fedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321",
+								EncryptedTx:    "0987654321fedcba0987654321fedcba0987654321fedcba0987654321fedcba",
+							},
+						},
+					},
+				},
+			},
+		})
+		if err != nil {
+			t.Fatalf("error sending bid with multiple shutterised options: %v", err)
+		}
+
+		count := 0
+		for {
+			_, err := rcv.Recv()
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					break
+				}
+				t.Fatalf("error receiving preconfs: %v", err)
+			}
+			count++
+		}
+		if count != 2 {
+			t.Fatalf("expected 2 preconfs, got %v", count)
+		}
+	})
+
+	t.Run("mixed bid options with one invalid shutterised option", func(t *testing.T) {
+		rcv, err := client.SendBid(context.Background(), &bidderapiv1.Bid{
+			TxHashes: []string{
+				common.HexToHash("0x0000ab").Hex()[2:],
+				common.HexToHash("0x0000cd").Hex()[2:],
+			},
+			Amount:              "1000000000000000000",
+			BlockNumber:         1,
+			DecayStartTimestamp: 10,
+			DecayEndTimestamp:   20,
+			BidOptions: &bidderapiv1.BidOptions{
+				Options: []*bidderapiv1.BidOption{
+					{
+						Opt: &bidderapiv1.BidOption_ShutterisedBidOption{
+							ShutterisedBidOption: &bidderapiv1.ShutterisedBidOption{
+								IdentityPrefix: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+								EncryptedTx:    "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+							},
+						},
+					},
+					{
+						Opt: &bidderapiv1.BidOption_ShutterisedBidOption{
+							ShutterisedBidOption: &bidderapiv1.ShutterisedBidOption{
+								IdentityPrefix: "",
+								EncryptedTx:    "0x0987654321fedcba0987654321fedcba0987654321fedcba0987654321fedcba",
+							},
+						},
+					},
+				},
+			},
+		})
+		if err != nil {
+			t.Fatalf("error sending bid: %v", err)
+		}
+
+		_, err = rcv.Recv()
+		if err == nil || !strings.Contains(err.Error(), "bid_options.options[1].shutterised_bid_option.identity_prefix: identity_prefix must be a valid 32 bytes hex string. [identity_prefix]") {
+			t.Fatalf("expected error about invalid shutterised option, got %v", err)
+		}
+	})
+}
+
 type dmTestSub struct{ ch chan error }
 
 func (s *dmTestSub) Unsubscribe()      {}

p2p/pkg/rpc/provider/service.go

@@ -145,6 +145,17 @@ func (s *Service) ProcessBid(
 					},
 				}
 				opts.Options = append(opts.Options, opt)
+			case bOpt.GetShutterisedBidOption() != nil:
+				c := bOpt.GetShutterisedBidOption()
+				opt := &providerapiv1.BidOption{
+					Opt: &providerapiv1.BidOption_ShutterisedBidOption{
+						ShutterisedBidOption: &providerapiv1.ShutterisedBidOption{
+							IdentityPrefix: c.GetIdentityPrefix(),
+							EncryptedTx:    c.GetEncryptedTx(),
+						},
+					},
+				}
+				opts.Options = append(opts.Options, opt)
 			}
 		}
 	}