feat(bcdc): add EncodeForSigningBatch function and related tests

Author: banasa44

binary-codec/codec.go

@@ -17,12 +17,21 @@ var (
 
 	// ErrSigningClaimFieldNotFound is returned when the 'Channel' & 'Amount' fields are both required, but were not found.
 	ErrSigningClaimFieldNotFound = errors.New("'Channel' & 'Amount' fields are both required, but were not found")
+	// ErrBatchFlagsFieldNotFound is returned when the 'flags' field is missing.
+	ErrBatchFlagsFieldNotFound = errors.New("no field `flags`")
+	// ErrBatchTxIDsFieldNotFound is returned when the 'txIDs' field is missing.
+	ErrBatchTxIDsFieldNotFound = errors.New("no field `txIDs`")
+	// ErrBatchTxIDsNotArray is returned when the 'txIDs' field is not an array.
+	ErrBatchTxIDsNotArray = errors.New("txIDs field must be an array")
+	// ErrBatchTxIDNotString is returned when a txID is not a string.
+	ErrBatchTxIDNotString = errors.New("each txID must be a string")
 )
 
 const (
 	txMultiSigPrefix          = "534D5400"
 	paymentChannelClaimPrefix = "434C4D00"
 	txSigPrefix               = "53545800"
+	batchPrefix               = "42434800"
 )
 
 // Encode converts a JSON transaction object to a hex string in the canonical binary format.
@@ -116,6 +125,55 @@ func EncodeForSigningClaim(json map[string]any) (string, error) {
 	return strings.ToUpper(paymentChannelClaimPrefix + hex.EncodeToString(channel) + hex.EncodeToString(amount)), nil
 }
 
+// EncodeForSigningBatch encodes a batch transaction into binary format in preparation for signing.
+func EncodeForSigningBatch(json map[string]any) (string, error) {
+	if json["flags"] == nil {
+		return "", ErrBatchFlagsFieldNotFound
+	}
+	if json["txIDs"] == nil {
+		return "", ErrBatchTxIDsFieldNotFound
+	}
+
+	// Extract and validate txIDs
+	txIDsInterface, ok := json["txIDs"].([]any)
+	if !ok {
+		return "", ErrBatchTxIDsNotArray
+	}
+
+	// Create UInt32 for flags
+	flagsType := &types.UInt32{}
+	flagsBytes, err := flagsType.FromJSON(json["flags"])
+	if err != nil {
+		return "", err
+	}
+
+	// Create UInt32 for txIDs length
+	txIDsLengthType := &types.UInt32{}
+	txIDsLengthBytes, err := txIDsLengthType.FromJSON(uint32(len(txIDsInterface)))
+	if err != nil {
+		return "", err
+	}
+
+	// Build the result string
+	result := batchPrefix + hex.EncodeToString(flagsBytes) + hex.EncodeToString(txIDsLengthBytes)
+
+	// Add each transaction ID
+	for _, txID := range txIDsInterface {
+		txIDStr, ok := txID.(string)
+		if !ok {
+			return "", ErrBatchTxIDNotString
+		}
+		hash256 := types.NewHash256()
+		txIDBytes, err := hash256.FromJSON(txIDStr)
+		if err != nil {
+			return "", err
+		}
+		result += hex.EncodeToString(txIDBytes)
+	}
+
+	return strings.ToUpper(result), nil
+}
+
 // removeNonSigningFields removes the fields from a JSON transaction object that should not be signed.
 func removeNonSigningFields(json map[string]any) map[string]any {
 	for k := range json {

binary-codec/codec_test.go

@@ -648,3 +648,91 @@ func TestEncodeForSigning(t *testing.T) {
 		})
 	}
 }
+
+func TestEncodeForSigningBatch(t *testing.T) {
+	tt := []struct {
+		description string
+		input       map[string]any
+		output      string
+		expectedErr error
+	}{
+		{
+			description: "pass - encode batch with multiple txIDs",
+			input: map[string]any{
+				"flags": uint32(1),
+				"txIDs": []any{
+					"ABE4871E9083DF66727045D49DEEDD3A6F166EB7F8D1E92FE868F02E76B2C5CA",
+					"795AAC88B59E95C3497609749127E69F12958BC016C600C770AEEB1474C840B4",
+				},
+			},
+			output: "4243480000000001" + // hash prefix + flags
+				"00000002" + // txIds length
+				"ABE4871E9083DF66727045D49DEEDD3A6F166EB7F8D1E92FE868F02E76B2C5CA" + // first txID
+				"795AAC88B59E95C3497609749127E69F12958BC016C600C770AEEB1474C840B4", // second txID
+			expectedErr: nil,
+		},
+		{
+			description: "pass - encode batch with zero flags",
+			input: map[string]any{
+				"flags": uint32(0),
+				"txIDs": []any{
+					"1111111111111111111111111111111111111111111111111111111111111111",
+				},
+			},
+			output:      "4243480000000000000000011111111111111111111111111111111111111111111111111111111111111111",
+			expectedErr: nil,
+		},
+		{
+			description: "fail - batch missing flags field",
+			input: map[string]any{
+				"txIDs": []any{
+					"E3FE6EA3D48F0C2B639448020EA4F03D4F4F8FFDB243A852A0F59177921B4879",
+				},
+			},
+			output:      "",
+			expectedErr: ErrBatchFlagsFieldNotFound,
+		},
+		{
+			description: "fail - batch missing txIDs field",
+			input: map[string]any{
+				"flags": uint32(12345),
+			},
+			output:      "",
+			expectedErr: ErrBatchTxIDsFieldNotFound,
+		},
+		{
+			description: "fail - batch with invalid txIDs type",
+			input: map[string]any{
+				"flags": uint32(12345),
+				"txIDs": "not_an_array",
+			},
+			output:      "",
+			expectedErr: ErrBatchTxIDsNotArray,
+		},
+		{
+			description: "fail - batch with non-string txID",
+			input: map[string]any{
+				"flags": uint32(12345),
+				"txIDs": []any{
+					123, // not a string
+				},
+			},
+			output:      "",
+			expectedErr: ErrBatchTxIDNotString,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.description, func(t *testing.T) {
+			got, err := EncodeForSigningBatch(tc.input)
+
+			if tc.expectedErr != nil {
+				require.EqualError(t, err, tc.expectedErr.Error())
+				require.Empty(t, got)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.output, got)
+			}
+		})
+	}
+}