الأبحاث · جولةُ البرمجة الأولى
CB-3-07 — API وتكامل · Go · عالٍ
جولةُ البرمجة الأولى · 2026-10-29 · GAIBRA v2.32.03 · واجبُ التشغيل
| الترتيب | المتنافس | الرمز أمام المحكّم | الكلمات | الاختبارات | Opus | Grok | المجموع | الصدق (Opus · Grok) |
|---|---|---|---|---|---|---|---|---|
| 1 | GAIBRA | ب | 3,267 | 14/14 | 95.0 | 96.0 | 95.5 | 11 · 12 |
| 2 | Claude Sonnet | هـ | 1,835 | 14/14 | 90.0 | 91.0 | 90.5 | 11 · 11 |
| 3 | ChatGPT | ج | 1,694 | 14/14 | 81.0 | 88.0 | 84.5 | 9 · 10 |
| 4 | DeepSeek | أ | 1,686 | 14/14 | 74.0 | 88.0 | 81.0 | 7 · 10 |
| 5 | Gemini | د | 1,069 | 14/14 | 65.0 | 70.0 | 67.5 | 4 · 7 |
نصُّ السيناريو كما كتبه المولّد
نستقبل إشعارات نجاح/فشل الدفع من بوابتين: «مدى-بي» (JSON جسم الصفحة، توقيع HMAC-SHA256 في ترويسة X-Mada-Signature بصيغة sha256=<hex>) و«باي-لاين» (التوقيع في الحقل sign داخل الجسم نفسه، وهو HMAC-SHA256 لقيم الحقول المرتبة أبجدياً بفاصل \&، بمفتاح مختلف). المشكلة: البوابتان تستخدمان أسماء حقول مختلفة، وحالات مختلفة، وتعيدان إرسال نفس الإشعار (retry) حتى نرد 200، فوصلتنا تحويلات مكررة في التسوية.
المطلوب حزمة واحدة بملف واحد main.go تقوم بما يلي، بدون أي شبكة فعلية (الطلبات الواردة تُمرَّر كسلاسل نصية جاهزة لدوالك، والمفاتيح ثابتة في نص الملف):
ParseMadaPay(body string, signatureHex string, secret string) (PaymentEvent, error) — تتحقق من HMAC للجسم كاملاً، وترفض بخطأ واضح عند عدم التطابق.
ParsePayLine(body string, secret string) (PaymentEvent, error) — تحسب التوقيع من الحقول المرتبة أبجدياً (باستثناء حقل sign نفسه)، وتتحقق.
هيكل موحّد:
go
type PaymentEvent struct {
  Provider string // "mada\_pay" | "payline"
  EventID string // معرّف فريد عند كل مزود
  Status string // "succeeded" | "failed" — يجب توحيد الحالات ("SUCCESS","paid","completed" → succeeded)
  AmountCents int64
  Currency string // ISO 4217 upper-case
  Reference string // رقم طلبنا عند المزود
  OccurredAt time.Time // بصيغة UTC
}
Dedupe(events \[]PaymentEvent) \[]PaymentEvent — تعيد قائمة بدون تكرار: المفتاح هو Provider + ":" + EventID، وعند التكرار يُبقى أول ظهور فقط مع الحفاظ على الترتيب.
أخطاء التحويل: مبالغ سالبة أو صفر تُرفض، عملة غير معروفة تُرفض، OccurredAt بصيغة غير صالحة تُرفض — كلها بأخطاء مميزة القيمة (sentinel errors).
بيانات تجريبية مضمّنة في main تُظهر: إشعارا نجاح من المزودين لنفس الطلب (منصوعين يدوياً بمفاتيح ثابتة في الملف)، إشعار payline مكرر، وإشعار بتوقيع تالف — مع طباعة الأحداث الموحدة النهائية. حتمي بالكامل، لا time.Now، لا قراءة من ملفات أو الشبكة، مكتبة قياسية فقط (crypto/hmac, crypto/sha256, encoding/hex, encoding/json, sort, strings, time).
الردودُ الخمسة كما وصلت المحكّمين
بGAIBRA
// main.go
// Package main normalizes signed payment notifications from the Mada-Pay and
// PayLine gateways into one PaymentEvent model and removes retried duplicates.
package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"
)
// Provider identifiers stored in PaymentEvent.Provider.
const (
	ProviderMadaPay = "mada\_pay"
	ProviderPayLine = "payline"
)
// Canonical statuses stored in PaymentEvent.Status.
const (
	StatusSucceeded = "succeeded"
	StatusFailed = "failed"
)
const (
	madaPaySignaturePrefix = "sha256="
	payLineSignatureField = "sign"
	payLineValueSeparator = "\&"
	dedupeKeySeparator = ":"
	maxNotificationBytes = 64 \* 1024
)
// PayLine body keys (assumed contract; replace with the provider's documented names).
const (
	payLineFieldEventID = "event\_id"
	payLineFieldState = "state"
	payLineFieldAmount = "amount\_minor"
	payLineFieldCurrency = "currency\_code"
	payLineFieldReference = "order\_no"
	payLineFieldTimestamp = "timestamp"
)
// Logical field names used in error messages.
const (
	fieldNameEventID = "event id"
	fieldNameStatus = "status"
	fieldNameAmount = "amount"
	fieldNameCurrency = "currency"
	fieldNameReference = "reference"
	fieldNameOccurredAt = "occurred at"
)
// Demo-only secrets, fixed in the file as requested. Production code must load
// secrets from a secret store and never commit them.
const (
	demoMadaPaySecret = "demo-mada-pay-secret-not-for-production"
	demoPayLineSecret = "demo-payline-secret-not-for-production"
)
// Sentinel errors. Callers branch on them with errors.Is.
var (
	ErrEmptySecret = errors.New("payment: empty signing secret")
	ErrPayloadTooLarge = errors.New("payment: notification body too large")
	ErrMalformedPayload = errors.New("payment: malformed notification payload")
	ErrInvalidSignature = errors.New("payment: signature verification failed")
	ErrMissingField = errors.New("payment: required field missing")
	ErrUnknownStatus = errors.New("payment: unknown payment status")
	ErrInvalidAmount = errors.New("payment: amount must be a positive integer in minor units")
	ErrUnknownCurrency = errors.New("payment: unknown currency")
	ErrInvalidTimestamp = errors.New("payment: invalid occurred-at timestamp")
)
// knownCurrencies is the ISO 4217 allow-list accepted by this service.
var knownCurrencies = map\[string]struct{}{
	"SAR": {}, "AED": {}, "BHD": {}, "KWD": {}, "OMR": {}, "QAR": {},
	"JOD": {}, "EGP": {}, "USD": {}, "EUR": {}, "GBP": {},
}
// statusAliases maps lower-cased provider statuses to canonical statuses.
var statusAliases = map\[string]string{
	"success": StatusSucceeded,
	"succeeded": StatusSucceeded,
	"paid": StatusSucceeded,
	"completed": StatusSucceeded,
	"failed": StatusFailed,
	"failure": StatusFailed,
	"declined": StatusFailed,
	"rejected": StatusFailed,
}
// PaymentEvent is the provider-independent payment notification.
type PaymentEvent struct {
	Provider string // "mada\_pay" | "payline"
	EventID string // unique per provider
	Status string // "succeeded" | "failed"
	AmountCents int64 // minor units, always > 0
	Currency string // ISO 4217 upper-case
	Reference string // our order number as known to the provider
	OccurredAt time.Time // UTC
}
// madaPayNotification is the assumed Mada-Pay body shape.
type madaPayNotification struct {
	ID string `json:"id"`
	Status string `json:"status"`
	Amount json.Number `json:"amount"`
	Currency string `json:"currency"`
	MerchantReference string `json:"merchant\_reference"`
	CreatedAt string `json:"created\_at"`
}
// rawNotification carries provider values before validation and normalization.
type rawNotification struct {
	Provider string
	EventID string
	Status string
	Amount string
	Currency string
	Reference string
	OccurredAt string
}
// ParseMadaPay verifies the HMAC-SHA256 of the whole raw body against
// signatureHex (with or without the "sha256=" prefix), then normalizes it.
// It returns ErrInvalidSignature on mismatch and other sentinels on bad data.
func ParseMadaPay(body string, signatureHex string, secret string) (PaymentEvent, error) {
	if err := validateNotificationInput(body, secret); err != nil {
	 return PaymentEvent{}, err
	}
	if err := verifyMadaPaySignature(body, signatureHex, secret); err != nil {
	 return PaymentEvent{}, err
	}
	var notification madaPayNotification
	if err := json.Unmarshal(\[]byte(body), \¬ification); err != nil {
	 return PaymentEvent{}, fmt.Errorf("%w: %s: %v", ErrMalformedPayload, ProviderMadaPay, err)
	}
	return normalizeNotification(rawNotification{
	 Provider: ProviderMadaPay,
	 EventID: notification.ID,
	 Status: notification.Status,
	 Amount: notification.Amount.String(),
	 Currency: notification.Currency,
	 Reference: notification.MerchantReference,
	 OccurredAt: notification.CreatedAt,
	})
}
// ParsePayLine verifies the "sign" field, computed as HMAC-SHA256 over the
// values of all other fields sorted by key and joined with "\&", then normalizes it.
// Values containing "\&", null values and nested objects/arrays are rejected
// with ErrMalformedPayload because they make the signed string ambiguous.
func ParsePayLine(body string, secret string) (PaymentEvent, error) {
	if err := validateNotificationInput(body, secret); err != nil {
	 return PaymentEvent{}, err
	}
	fields, err := decodeFlatJSONObject(ProviderPayLine, body)
	if err != nil {
	 return PaymentEvent{}, err
	}
	if err := verifyPayLineSignature(fields, secret); err != nil {
	 return PaymentEvent{}, err
	}
	raw, err := payLineRawNotification(fields)
	if err != nil {
	 return PaymentEvent{}, err
	}
	return normalizeNotification(raw)
}
// Dedupe returns events without duplicates keyed by Provider + ":" + EventID,
// keeping the first occurrence and the original order. It never returns nil.
func Dedupe(events \[]PaymentEvent) \[]PaymentEvent {
	unique := make(\[]PaymentEvent, 0, len(events))
	seen := make(map\[string]struct{}, len(events))
	for \_, event := range events {
	 key := dedupeKey(event)
	 if \_, duplicate := seen\[key]; duplicate {
	 continue
	 }
	 seen\[key] = struct{}{}
	 unique = append(unique, event)
	}
	return unique
}
func dedupeKey(event PaymentEvent) string {
	return event.Provider + dedupeKeySeparator + event.EventID
}
func validateNotificationInput(body string, secret string) error {
	if secret == "" {
	 return ErrEmptySecret
	}
	if len(body) > maxNotificationBytes {
	 return fmt.Errorf("%w: %d bytes exceeds %d", ErrPayloadTooLarge, len(body), maxNotificationBytes)
	}
	if strings.TrimSpace(body) == "" {
	 return fmt.Errorf("%w: empty body", ErrMalformedPayload)
	}
	return nil
}
func computeHMACSHA256(message \[]byte, secret string) \[]byte {
	mac := hmac.New(sha256.New, \[]byte(secret))
	// hash.Hash.Write is documented to never return an error.
	mac.Write(message)
	return mac.Sum(nil)
}
func decodeHexDigest(provider string, signatureHex string) (\[]byte, error) {
	digest, err := hex.DecodeString(strings.TrimSpace(signatureHex))
	if err != nil || len(digest) != sha256.Size {
	 return nil, fmt.Errorf("%w: %s: signature is not a %d-byte hex digest", ErrInvalidSignature, provider, sha256.Size)
	}
	return digest, nil
}
func verifyMadaPaySignature(body string, signatureHeader string, secret string) error {
	signatureHex := strings.TrimPrefix(strings.TrimSpace(signatureHeader), madaPaySignaturePrefix)
	provided, err := decodeHexDigest(ProviderMadaPay, signatureHex)
	if err != nil {
	 return err
	}
	if !hmac.Equal(provided, computeHMACSHA256(\[]byte(body), secret)) {
	 return fmt.Errorf("%w: %s: digest mismatch", ErrInvalidSignature, ProviderMadaPay)
	}
	return nil
}
func decodeFlatJSONObject(provider string, body string) (map\[string]json.RawMessage, error) {
	var fields map\[string]json.RawMessage
	if err := json.Unmarshal(\[]byte(body), \&fields); err != nil {
	 return nil, fmt.Errorf("%w: %s: %v", ErrMalformedPayload, provider, err)
	}
	if fields == nil {
	 return nil, fmt.Errorf("%w: %s: body must be a JSON object", ErrMalformedPayload, provider)
	}
	return fields, nil
}
func verifyPayLineSignature(fields map\[string]json.RawMessage, secret string) error {
	provided, err := payLineProvidedSignature(fields)
	if err != nil {
	 return err
	}
	canonical, err := payLineCanonicalString(fields)
	if err != nil {
	 return err
	}
	if !hmac.Equal(provided, computeHMACSHA256(\[]byte(canonical), secret)) {
	 return fmt.Errorf("%w: %s: digest mismatch", ErrInvalidSignature, ProviderPayLine)
	}
	return nil
}
func payLineProvidedSignature(fields map\[string]json.RawMessage) (\[]byte, error) {
	raw, ok := fields\[payLineSignatureField]
	if !ok {
	 return nil, fmt.Errorf("%w: %s: missing %q field", ErrInvalidSignature, ProviderPayLine, payLineSignatureField)
	}
	var signatureHex string
	if err := json.Unmarshal(raw, \&signatureHex); err != nil {
	 return nil, fmt.Errorf("%w: %s: %q must be a JSON string", ErrInvalidSignature, ProviderPayLine, payLineSignatureField)
	}
	return decodeHexDigest(ProviderPayLine, signatureHex)
}
// payLineCanonicalString builds value1\&value2\&... ordered by byte-wise key order, excluding "sign".
func payLineCanonicalString(fields map\[string]json.RawMessage) (string, error) {
	keys := make(\[]string, 0, len(fields))
	for key := range fields {
	 if key != payLineSignatureField {
	 keys = append(keys, key)
	 }
	}
	sort.Strings(keys)
	values := make(\[]string, 0, len(keys))
	for \_, key := range keys {
	 value, err := canonicalPayLineValue(fields\[key])
	 if err != nil {
	 return "", fmt.Errorf("%s field %q: %w", ProviderPayLine, key, err)
	 }
	 if strings.Contains(value, payLineValueSeparator) {
	 return "", fmt.Errorf("%w: %s field %q contains the separator %q", ErrMalformedPayload, ProviderPayLine, key, payLineValueSeparator)
	 }
	 values = append(values, value)
	}
	return strings.Join(values, payLineValueSeparator), nil
}
// canonicalPayLineValue returns strings unquoted and numbers/booleans as their raw literal.
func canonicalPayLineValue(raw json.RawMessage) (string, error) {
	literal := strings.TrimSpace(string(raw))
	switch {
	case literal == "" || literal == "null":
	 return "", fmt.Errorf("%w: null or empty value cannot be signed", ErrMalformedPayload)
	case literal\[0] == '"':
	 var value string
	 if err := json.Unmarshal(raw, \&value); err != nil {
	 return "", fmt.Errorf("%w: %v", ErrMalformedPayload, err)
	 }
	 return value, nil
	case literal\[0] == '{' || literal\[0] == '\[':
	 return "", fmt.Errorf("%w: nested objects and arrays cannot be signed", ErrMalformedPayload)
	default:
	 return literal, nil
	}
}
func payLineFieldValue(fields map\[string]json.RawMessage, key string) (string, error) {
	raw, ok := fields\[key]
	if !ok {
	 return "", nil
	}
	return canonicalPayLineValue(raw)
}
func payLineRawNotification(fields map\[string]json.RawMessage) (rawNotification, error) {
	keys := \[]string{payLineFieldEventID, payLineFieldState, payLineFieldAmount,
	 payLineFieldCurrency, payLineFieldReference, payLineFieldTimestamp}
	values := make(map\[string]string, len(keys))
	for \_, key := range keys {
	 value, err := payLineFieldValue(fields, key)
	 if err != nil {
	 return rawNotification{}, fmt.Errorf("%s field %q: %w", ProviderPayLine, key, err)
	 }
	 values\[key] = value
	}
	return rawNotification{
	 Provider: ProviderPayLine,
	 EventID: values\[payLineFieldEventID],
	 Status: values\[payLineFieldState],
	 Amount: values\[payLineFieldAmount],
	 Currency: values\[payLineFieldCurrency],
	 Reference: values\[payLineFieldReference],
	 OccurredAt: values\[payLineFieldTimestamp],
	}, nil
}
func normalizeNotification(raw rawNotification) (PaymentEvent, error) {
	eventID, err := requireField(raw.Provider, fieldNameEventID, raw.EventID)
	if err != nil {
	 return PaymentEvent{}, err
	}
	status, err := normalizeStatus(raw.Provider, raw.Status)
	if err != nil {
	 return PaymentEvent{}, err
	}
	amount, err := normalizeAmount(raw.Provider, raw.Amount)
	if err != nil {
	 return PaymentEvent{}, err
	}
	currency, err := normalizeCurrency(raw.Provider, raw.Currency)
	if err != nil {
	 return PaymentEvent{}, err
	}
	reference, err := requireField(raw.Provider, fieldNameReference, raw.Reference)
	if err != nil {
	 return PaymentEvent{}, err
	}
	occurredAt, err := normalizeTimestamp(raw.Provider, raw.OccurredAt)
	if err != nil {
	 return PaymentEvent{}, err
	}
	return PaymentEvent{
	 Provider: raw.Provider,
	 EventID: eventID,
	 Status: status,
	 AmountCents: amount,
	 Currency: currency,
	 Reference: reference,
	 OccurredAt: occurredAt,
	}, nil
}
func requireField(provider string, fieldName string, value string) (string, error) {
	trimmed := strings.TrimSpace(value)
	if trimmed == "" {
	 return "", fmt.Errorf("%w: %s: %s", ErrMissingField, provider, fieldName)
	}
	return trimmed, nil
}
func normalizeStatus(provider string, rawStatus string) (string, error) {
	trimmed, err := requireField(provider, fieldNameStatus, rawStatus)
	if err != nil {
	 return "", err
	}
	status, ok := statusAliases\[strings.ToLower(trimmed)]
	if !ok {
	 return "", fmt.Errorf("%w: %s: %q", ErrUnknownStatus, provider, trimmed)
	}
	return status, nil
}
func normalizeAmount(provider string, rawAmount string) (int64, error) {
	trimmed, err := requireField(provider, fieldNameAmount, rawAmount)
	if err != nil {
	 return 0, err
	}
	amount, err := json.Number(trimmed).Int64()
	if err != nil {
	 return 0, fmt.Errorf("%w: %s: %q is not an integer in minor units", ErrInvalidAmount, provider, trimmed)
	}
	if amount <= 0 {
	 return 0, fmt.Errorf("%w: %s: %d", ErrInvalidAmount, provider, amount)
	}
	return amount, nil
}
func normalizeCurrency(provider string, rawCurrency string) (string, error) {
	trimmed, err := requireField(provider, fieldNameCurrency, rawCurrency)
	if err != nil {
	 return "", err
	}
	currency := strings.ToUpper(trimmed)
	if \_, ok := knownCurrencies\[currency]; !ok {
	 return "", fmt.Errorf("%w: %s: %q", ErrUnknownCurrency, provider, trimmed)
	}
	return currency, nil
}
func normalizeTimestamp(provider string, rawTimestamp string) (time.Time, error) {
	trimmed, err := requireField(provider, fieldNameOccurredAt, rawTimestamp)
	if err != nil {
	 return time.Time{}, err
	}
	parsed, err := time.Parse(time.RFC3339, trimmed)
	if err != nil {
	 return time.Time{}, fmt.Errorf("%w: %s: %q is not RFC 3339 with offset", ErrInvalidTimestamp, provider, trimmed)
	}
	return parsed.UTC(), nil
}
// madaPaySignatureHeader builds the X-Mada-Signature value; used for demo fixtures.
func madaPaySignatureHeader(body string, secret string) string {
	return madaPaySignaturePrefix + hex.EncodeToString(computeHMACSHA256(\[]byte(body), secret))
}
// signPayLineBody adds a "sign" field using the same canonical rule as ParsePayLine.
func signPayLineBody(body string, secret string) (string, error) {
	if err := validateNotificationInput(body, secret); err != nil {
	 return "", err
	}
	fields, err := decodeFlatJSONObject(ProviderPayLine, body)
	if err != nil {
	 return "", err
	}
	delete(fields, payLineSignatureField)
	canonical, err := payLineCanonicalString(fields)
	if err != nil {
	 return "", err
	}
	encodedSignature, err := json.Marshal(hex.EncodeToString(computeHMACSHA256(\[]byte(canonical), secret)))
	if err != nil {
	 return "", fmt.Errorf("encode payline signature: %w", err)
	}
	fields\[payLineSignatureField] = json.RawMessage(encodedSignature)
	signed, err := json.Marshal(fields)
	if err != nil {
	 return "", fmt.Errorf("encode signed payline body: %w", err)
	}
	return string(signed), nil
}
type demoCase struct {
	label string
	provider string
	body string
	madaSignature string
	wantErr error
}
const (
	demoExpectedAccepted = 4
	demoExpectedUnique = 3
	demoExpectedRejected = 5
)
func buildDemoCases() (\[]demoCase, error) {
	const madaSuccess = `{"id":"mp\_evt\_1001","status":"SUCCESS","amount":15000,"currency":"sar","merchant\_reference":"ORD-2026-0042","created\_at":"2026-10-28T21:15:30+03:00"}`
	const madaDeclined = `{"id":"mp\_evt\_1004","status":"declined","amount":4200,"currency":"SAR","merchant\_reference":"ORD-2026-0044","created\_at":"2026-10-28T23:05:00+03:00"}`
	const madaNegative = `{"id":"mp\_evt\_1002","status":"paid","amount":-500,"currency":"SAR","merchant\_reference":"ORD-2026-0045","created\_at":"2026-10-28T22:00:00+03:00"}`
	const madaBadTime = `{"id":"mp\_evt\_1003","status":"completed","amount":9900,"currency":"SAR","merchant\_reference":"ORD-2026-0043","created\_at":"28/10/2026 21:15"}`
	madaSuccessSignature := madaPaySignatureHeader(madaSuccess, demoMadaPaySecret)
	madaTampered := strings.Replace(madaSuccess, `"amount":15000`, `"amount":1500000`, 1)
	payLineSuccess, err := signPayLineBody(`{"event\_id":"pl\_7f3a","state":"completed","amount\_minor":15000,"currency\_code":"SAR","order\_no":"ORD-2026-0042","timestamp":"2026-10-28T18:16:02Z"}`, demoPayLineSecret)
	if err != nil {
	 return nil, err
	}
	payLineUnknownCurrency, err := signPayLineBody(`{"event\_id":"pl\_7f3b","state":"paid","amount\_minor":7000,"currency\_code":"XYZ","order\_no":"ORD-2026-0046","timestamp":"2026-10-28T19:00:00Z"}`, demoPayLineSecret)
	if err != nil {
	 return nil, err
	}
	payLineZeroAmount, err := signPayLineBody(`{"event\_id":"pl\_7f3c","state":"paid","amount\_minor":0,"currency\_code":"SAR","order\_no":"ORD-2026-0047","timestamp":"2026-10-28T19:30:00Z"}`, demoPayLineSecret)
	if err != nil {
	 return nil, err
	}
	return \[]demoCase{
	 {label: "mada\_pay success ORD-2026-0042", provider: ProviderMadaPay, body: madaSuccess, madaSignature: madaSuccessSignature},
	 {label: "payline success ORD-2026-0042", provider: ProviderPayLine, body: payLineSuccess},
	 {label: "payline retry (same event)", provider: ProviderPayLine, body: payLineSuccess},
	 {label: "mada\_pay declined ORD-2026-0044", provider: ProviderMadaPay, body: madaDeclined, madaSignature: madaPaySignatureHeader(madaDeclined, demoMadaPaySecret)},
	 {label: "mada\_pay tampered amount", provider: ProviderMadaPay, body: madaTampered, madaSignature: madaSuccessSignature, wantErr: ErrInvalidSignature},
	 {label: "mada\_pay negative amount", provider: ProviderMadaPay, body: madaNegative, madaSignature: madaPaySignatureHeader(madaNegative, demoMadaPaySecret), wantErr: ErrInvalidAmount},
	 {label: "mada\_pay bad timestamp", provider: ProviderMadaPay, body: madaBadTime, madaSignature: madaPaySignatureHeader(madaBadTime, demoMadaPaySecret), wantErr: ErrInvalidTimestamp},
	 {label: "payline unknown currency", provider: ProviderPayLine, body: payLineUnknownCurrency, wantErr: ErrUnknownCurrency},
	 {label: "payline zero amount", provider: ProviderPayLine, body: payLineZeroAmount, wantErr: ErrInvalidAmount},
	}, nil
}
func parseDemoCase(c demoCase) (PaymentEvent, error) {
	switch c.provider {
	case ProviderMadaPay:
	 return ParseMadaPay(c.body, c.madaSignature, demoMadaPaySecret)
	case ProviderPayLine:
	 return ParsePayLine(c.body, demoPayLineSecret)
	default:
	 return PaymentEvent{}, fmt.Errorf("demo: unsupported provider %q", c.provider)
	}
}
func checkDemoResult(accepted \[]PaymentEvent, unique \[]PaymentEvent, rejected int) error {
	if len(accepted) != demoExpectedAccepted || len(unique) != demoExpectedUnique || rejected != demoExpectedRejected {
	 return fmt.Errorf("demo check failed: accepted=%d unique=%d rejected=%d", len(accepted), len(unique), rejected)
	}
	first := unique\[0]
	wantTime := time.Date(2026, time.October, 28, 18, 15, 30, 0, time.UTC)
	if first.Provider != ProviderMadaPay || first.Status != StatusSucceeded || first.Currency != "SAR" ||
	 first.AmountCents != 15000 || !first.OccurredAt.Equal(wantTime) {
	 return fmt.Errorf("demo check failed: unexpected first event %+v", first)
	}
	if unique\[1].Provider != ProviderPayLine || unique\[1].EventID != "pl\_7f3a" {
	 return fmt.Errorf("demo check failed: unexpected second event %+v", unique\[1])
	}
	if unique\[2].Status != StatusFailed {
	 return fmt.Errorf("demo check failed: declined was not normalized to failed: %+v", unique\[2])
	}
	return nil
}
func run() error {
	cases, err := buildDemoCases()
	if err != nil {
	 return fmt.Errorf("build demo cases: %w", err)
	}
	accepted := make(\[]PaymentEvent, 0, len(cases))
	rejected := 0
	for \_, c := range cases {
	 event, parseErr := parseDemoCase(c)
	 if c.wantErr != nil {
	 if !errors.Is(parseErr, c.wantErr) {
	 return fmt.Errorf("demo check failed for %s: want %v, got %v", c.label, c.wantErr, parseErr)
	 }
	 rejected++
	 fmt.Printf("REJECTED %-32s %v\\n", c.label, parseErr)
	 continue
	 }
	 if parseErr != nil {
	 return fmt.Errorf("demo check failed for %s: %w", c.label, parseErr)
	 }
	 accepted = append(accepted, event)
	 fmt.Printf("ACCEPTED %-32s %s\\n", c.label, dedupeKey(event))
	}
	unique := Dedupe(accepted)
	if err := checkDemoResult(accepted, unique, rejected); err != nil {
	 return err
	}
	fmt.Println("Unified payment events:")
	for \_, e := range unique {
	 fmt.Printf("%-8s %-11s %-9s %7d %s %-13s %s\\n",
	 e.Provider, e.EventID, e.Status, e.AmountCents, e.Currency, e.Reference, e.OccurredAt.Format(time.RFC3339))
	}
	return nil
}
func main() {
	if err := run(); err != nil {
	 panic(err)
	}
}
الشرح
أخطر ما في مخطّط «باي-لاين» ليس اختلافَ أسماء الحقول، بل أنّ التوقيع يغطّي القيم وحدها مفصولةً بـ \&. معنى ذلك أنّ مهاجماً يستطيع نقلَ الحدّ بين حقلين متجاورين دون أن يتغيّر النصّ الموقَّع. فلو كانت قيمةُ حقلٍ x\&y وما يليه z، فإعادةُ كتابتهما x وy\&z تُبقي السلسلة نفسها x\&y\&z، ويمرّ التوقيعُ سليماً على جسمٍ مختلف. لهذا يرفض payLineCanonicalString أيَّ قيمةٍ تحوي الفاصل. وما دامت القيمُ خاليةً منه، فعددُ المقاطع يساوي عددَ المفاتيح، ولا يمكن إضافةُ حقلٍ أو حذفُه دون كسر التوقيع. وللسبب ذاته تُقرأ حقولُ «باي-لاين» من الخريطة الموقَّعة نفسِها بمطابقةٍ حرفيّةٍ للمفاتيح، لا بفكّ JSON إلى struct. فـ encoding/json يطابق أسماءَ الحقول دون تمييزٍ لحالة الأحرف، وهذا يفتح فجوةً بين ما وُقِّع وما قُرئ.
الثمنُ واضح: مرجعُ طلبٍ مشروعٌ يحتوي \& سيُرفض بـ ErrMalformedPayload. وأراه ثمناً مقبولاً مقابل إغلاق ثغرةٍ تمسّ المبالغ.
في «مدى-بي» الأمرُ أبسط، لأنّ التوقيع يغطّي الجسمَ الخامَ كاملاً، فيُتحقَّق منه قبل أيّ تحليل. لا تُلمَس بيانةٌ غيرُ موثَّقة، وتُقارَن البصمتان بـ hmac.Equal في زمنٍ ثابتٍ يمنع تسريبَ التوقيع عبر التوقيت. تقبل الدالّةُ التوقيعَ بالبادئة sha256= أو بدونها، ويُرفض كلُّ ما ليس 32 بايتاً بالضبط. ويترتّب على ذلك شرطٌ عمليّ: يجب أن يصل إلى ParseMadaPay الجسمُ بالبايتات التي وصلت عبر الشبكة. أيُّ middleware يعيد تنسيقَ الـ JSON سيُفشل كلَّ التواقيع.
بقيّةُ القرارات تتبع المنطقَ نفسَه. الأخطاءُ sentinel تُغلَّف بـ %w، فيتفرّع عليها المستدعي بـ errors.Is ويقرّر: توقيعٌ تالفٌ يُردّ عليه بـ 401 ويُسجَّل كمحاولة اختراق، أمّا عملةٌ مجهولةٌ فتحتاج تدخّلاً بشريّاً. الحالاتُ غيرُ المعروفة مثل pending أو refunded تُرفض بـ ErrUnknownStatus ولا تُخمَّن، لأنّ تحويلَ حالةٍ مجهولةٍ إلى succeeded أسوأُ من رفضها. الوقتُ يُقبل بصيغة RFC 3339 مع إزاحةٍ صريحة فقط، ثمّ يُحوَّل إلى UTC، فتصير 21:15:30+03:00 في المثال 18:15:30Z. أمّا Dedupe فتستعمل map بسعةٍ محجوزةٍ مسبقاً، فتعمل بزمنٍ خطّيّ دون إعادة تخصيص. والدوالُّ كلُّها بلا حالةٍ مشتركة، فهي آمنةٌ للاستدعاء المتزامن من عدّة goroutines.
هناك عقدٌ لم أره فاضطررتُ لافتراضه، وهذه حدوده:
الحقل الموحّد «مدى-بي» (مفترَض) «باي-لاين» (مفترَض)
EventID id event\_id
Status status state
AmountCents amount (هللات صحيحة) amount\_minor
Currency currency currency\_code
Reference merchant\_reference order\_no
OccurredAt created\_at timestamp
لم تذكر أسماءَ الحقول الفعليّة. افترضتُ أيضاً أنّ المبالغ تصل بالوحدة الصغرى، وأنّ ترتيبَ المفاتيح بايتيٌّ تصاعديّ، وأنّ قيمةَ null لا تُوقَّع. أرسل لي مثالاً حقيقيّاً موقَّعاً من كلّ بوابة، وسأضبط الثوابتَ وقاعدةَ التوقيع عليه هنا. ولو تبيّن أنّ «باي-لاين» ترسل المبلغ عشريّاً مثل "150.00"، فسيلزم جدولُ منازلٍ عشريّةٍ لكلّ عملة، لأنّ KWD وBHD تستعملان ثلاثَ منازل.
وأهمُّ تنبيهٍ يتعلّق بالمشكلة التي بدأتَ منها:
مهمّ
Dedupe تزيل التكرار داخل الدفعة الواحدة في الذاكرة فقط؛ لن توقف التحويلات المكرّرة في التسوية إن وصلت الإعادةُ بعد إعادة تشغيل الخدمة أو إلى نسخةٍ أخرى منها. الحلُّ الجذريّ قيدُ تفرّدٍ في قاعدة البيانات على (provider, event\_id) مع إدراجٍ يتجاهل التعارض، ثمّ الردّ بـ 200 حتى على المكرّر. لم أُدرجه لأنّ طلبك ينصّ على «بدون أي شبكة فعلية» و«لا قراءة من ملفات». وللسبب نفسه («لا time.Now») لا يوجد فحصٌ لحداثة الإشعار ضدّ إعادة الإرسال الخبيثة.
بعد هذا التنبيه تبقى ملاحظةٌ تخصّ التسوية تحديداً. نجاحُ الطلب ORD-2026-0042 من البوابتين معاً يُنتج حدثين يحتفظ بهما Dedupe كلاهما، لأنّ المفتاح الذي حدّدتَه Provider:EventID يختلف بينهما. هذا ليس تكراراً تقنيّاً، بل احتمالُ أنّ العميل دفع مرّتين فعلاً، والصوابُ أن يُعالَج كاستردادٍ لا أن يُحذف بصمت.
المفتاحان ثابتان في الملف لأنّك طلبتَ ذلك للعرض. وأضفتُ fmt وerrors إلى القائمة التي ذكرتَها، لأنّ الطباعةَ وerrors.Is تحتاجانهما، وكلاهما من المكتبة القياسيّة.
لم أشغّل هذا الكود. لكنّ run لا تكتفي بالطباعة. فهي تتحقّق بنفسها من النتيجة، وتنهي البرنامج بـ panic إن اختلف شيءٌ عمّا يلي:
كلُّ حالةٍ مرفوضة رُفضت بخطئها المحدّد عبر errors.Is.
عددُ الأحداث المقبولة 4، والفريدة بعد Dedupe 3، والمرفوضة 5.
الحدثُ الأوّل من «مدى-بي» بحالة succeeded وعملة SAR ومبلغ 15000 ووقت 2026-10-28T18:15:30Z.
الثاني هو pl\_7f3a.
الثالث تحوّلت حالتُه من declined إلى failed.
الدليلُ إذن هو تشغيلُك لأمرٍ واحد، لا كلامي.
طريقة الاستخدام
شغّل الملف بالأمر go run main.go. تتبّعتُ الكود يدويّاً على البيانات المضمّنة، ولم أشغّله. وفق هذا التتبّع يجب أن يظهر ما يلي:
قبول إشعار «مدى-بي» الناجح، ثمّ إشعار «باي-لاين» الناجح، ثمّ إعادته بالمفتاح نفسه payline:pl\_7f3a.
قبول إشعار الرفض mp\_evt\_1004.
رفض خمس حالات بالترتيب: التوقيع التالف بـ ErrInvalidSignature، والمبلغ السالب بـ ErrInvalidAmount، والوقت 28/10/2026 21:15 بـ ErrInvalidTimestamp، والعملة XYZ بـ ErrUnknownCurrency، والمبلغ الصفريّ بـ ErrInvalidAmount.
ثمّ تُطبع الأحداث الموحّدة:
Unified payment events:
mada\_pay mp\_evt\_1001 succeeded 15000 SAR ORD-2026-0042 2026-10-28T18:15:30Z
payline pl\_7f3a succeeded 15000 SAR ORD-2026-0042 2026-10-28T18:16:02Z
mada\_pay mp\_evt\_1004 failed 4200 SAR ORD-2026-0044 2026-10-28T20:05:00Z
إعادةُ «باي-لاين» اختفت كما يجب. لكنّ السطرين الأوّلين لا يزالان يحملان الطلب ORD-2026-0042 نفسه. هذه هي حالة الدفع المزدوج التي أشرتُ إليها، وتحتاج معالجةً منفصلة.
عند الدمج في الـ handler الحقيقيّ:
مرّر الجسمَ الخام كما قرأته من الطلب إلى ParseMadaPay أو ParsePayLine، بعد قصّه بـ http.MaxBytesReader عند الحدّ نفسه 64 \* 1024.
إن طابق الخطأ ErrInvalidSignature فردّ بـ 401.
إن طابق ErrUnknownCurrency أو ErrUnknownStatus فردّ بـ 422 وأرسل الحالة إلى مراجعةٍ بشريّة.
خطوتك التالية: أنشئ قيد التفرّد على (provider, event\_id) في جدول الإشعارات، واجعل الإدراج يتجاهل التعارض ثمّ يردّ بـ 200. بذلك تتوقّف التحويلاتُ المكرّرة في التسوية حتى عبر إعادة التشغيل وتعدّد النسخ. وأرسل لي عيّنةً موقّعةً حقيقيّةً من كلّ بوابة لأضبط عليها أسماءَ الحقول وقاعدةَ التوقيع المفترضة.
هـClaude Sonnet
سأكتب main.go ثم أشغّله للتأكد من المخرجات.
main.go جاهز، وقد شغّلته بعد فحص gofmt وgo vet (نظيفان). النتيجة حتمية: من 3 إشعارات مقبولة بقي حدثان فقط، وأُسقط الإشعار المكرر من باي-لاين، ورُفض الإشعار ذو التوقيع التالف بـ ErrBadSignature.
التوقيعان: مدى-بي يُتحقق منه على الجسم الخام كاملاً قبل أي تحليل JSON، وتُقبل ترويسة sha256=<hex> أو الـ hex وحده. باي-لاين يُحسب توقيعه من قيم الحقول (عدا sign) مرتبةً حسب اسم الحقل ومفصولة بـ \&، والمقارنة في الحالتين بـ hmac.Equal.
افتراضات صغيرة في الحقول (غيّرها إن كانت وثائق المزودين تقول غير ذلك):
مدى-بي: المبلغ بأصغر وحدة (هللة) والوقت بصيغة RFC3339 (يُحوَّل إلى UTC).
باي-لاين: المبلغ نص عشري مثل "150.75" يُحوَّل بدون أرقام عائمة، والوقت ts بالثواني.
الحالات: SUCCESS/paid/completed/approved تصبح succeeded، وfailed/declined/rejected/error تصبح failed، وأي حالة أخرى تُرفض بـ ErrUnknownStatus.
الأخطاء المميزة: ErrBadSignature وErrInvalidAmount وErrUnknownCurrency وErrInvalidTime، إضافةً إلى ErrMalformedBody وErrMissingField وErrUnknownStatus. كلها تُغلَّف بسياق ويُفحص بها عبر errors.Is.
لاحظ أن المخرجات تُظهر حدثي نجاح لنفس الطلب ORD-2026-1042، واحداً من كل مزود. Dedupe بمفتاح Provider:EventID لا يدمجهما لأن المعرّفين مختلفان، وهذا ما طلبته. إن كان هذا ما يسبب التحويلات المكررة في التسوية، فتحتاج خطوة منفصلة تُجمّع بحسب Reference.
الملف: /mnt/user-data/uploads/main.go
Main
Code
·GO
// حزمة واحدة بملف واحد: تحقق وتوحيد إشعارات الدفع من «مدى-بي» و«باي-لاين»
// مع إزالة التكرار الناتج عن إعادة الإرسال (retry).
// حتمي بالكامل: لا شبكة، لا ملفات، لا time.Now، مكتبة قياسية فقط.
package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"
)
// ---------------------------------------------------------------------------
// الأخطاء المميزة (sentinel errors)
// ---------------------------------------------------------------------------
var (
	ErrBadSignature = errors.New("توقيع الإشعار غير مطابق")
	ErrMalformedBody = errors.New("جسم الإشعار غير صالح")
	ErrMissingField = errors.New("حقل مطلوب مفقود")
	ErrInvalidAmount = errors.New("المبلغ غير صالح (يجب أن يكون أكبر من صفر)")
	ErrUnknownCurrency = errors.New("عملة غير معروفة")
	ErrInvalidTime = errors.New("صيغة وقت الحدث غير صالحة")
	ErrUnknownStatus = errors.New("حالة دفع غير معروفة")
)
// ---------------------------------------------------------------------------
// الهيكل الموحّد
// ---------------------------------------------------------------------------
const (
	ProviderMadaPay = "mada\_pay"
	ProviderPayLine = "payline"
	StatusSucceeded = "succeeded"
	StatusFailed = "failed"
)
type PaymentEvent struct {
	Provider string // "mada\_pay" | "payline"
	EventID string // معرّف فريد عند كل مزود
	Status string // "succeeded" | "failed"
	AmountCents int64 // بأصغر وحدة للعملة (هللة/سنت)
	Currency string // ISO 4217 upper-case
	Reference string // رقم طلبنا عند المزود
	OccurredAt time.Time // UTC
}
// ---------------------------------------------------------------------------
// أدوات التوحيد والتحقق المشتركة
// ---------------------------------------------------------------------------
// العملات المعتمدة (جميعها بخانتين عشريتين).
var knownCurrencies = map\[string]bool{
	"SAR": true, "AED": true, "USD": true, "EUR": true,
	"GBP": true, "QAR": true, "EGP": true,
}
var statusAliases = map\[string]string{
	"success": StatusSucceeded,
	"succeeded": StatusSucceeded,
	"paid": StatusSucceeded,
	"completed": StatusSucceeded,
	"approved": StatusSucceeded,
	"failed": StatusFailed,
	"failure": StatusFailed,
	"declined": StatusFailed,
	"rejected": StatusFailed,
	"error": StatusFailed,
}
func normalizeStatus(raw string) (string, error) {
	s, ok := statusAliases\[strings.ToLower(strings.TrimSpace(raw))]
	if !ok {
	 return "", fmt.Errorf("%w: %q", ErrUnknownStatus, raw)
	}
	return s, nil
}
func normalizeCurrency(raw string) (string, error) {
	c := strings.ToUpper(strings.TrimSpace(raw))
	if !knownCurrencies\[c] {
	 return "", fmt.Errorf("%w: %q", ErrUnknownCurrency, raw)
	}
	return c, nil
}
// verifyHMAC يقارن HMAC-SHA256 للرسالة بالتوقيع المستلم (hex، مع بادئة sha256= اختيارية)
// بمقارنة ثابتة الزمن.
func verifyHMAC(message, secret, gotHex string) error {
	gotHex = strings.TrimSpace(gotHex)
	if len(gotHex) >= 7 \&\& strings.EqualFold(gotHex\[:7], "sha256=") {
	 gotHex = gotHex\[7:]
	}
	if gotHex == "" {
	 return fmt.Errorf("%w: التوقيع مفقود", ErrBadSignature)
	}
	got, err := hex.DecodeString(gotHex)
	if err != nil {
	 return fmt.Errorf("%w: التوقيع ليس hex صالحاً", ErrBadSignature)
	}
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(message))
	if !hmac.Equal(got, mac.Sum(nil)) {
	 return ErrBadSignature
	}
	return nil
}
// parseDecimalCents يحوّل نصاً عشرياً مثل "150.75" إلى 15075 بدون أرقام عائمة.
func parseDecimalCents(s string) (int64, error) {
	s = strings.TrimSpace(s)
	whole, frac, \_ := strings.Cut(s, ".")
	if whole == "" || len(whole) > 15 || len(frac) > 2 {
	 return 0, fmt.Errorf("%w: %q", ErrInvalidAmount, s)
	}
	for \_, part := range \[]string{whole, frac} {
	 for \_, r := range part {
	 if r < '0' || r > '9' {
	 return 0, fmt.Errorf("%w: %q", ErrInvalidAmount, s)
	 }
	 }
	}
	for len(frac) < 2 {
	 frac += "0"
	}
	w, err1 := strconv.ParseInt(whole, 10, 64)
	f, err2 := strconv.ParseInt(frac, 10, 64)
	if err1 != nil || err2 != nil {
	 return 0, fmt.Errorf("%w: %q", ErrInvalidAmount, s)
	}
	cents := w\*100 + f
	if cents <= 0 {
	 return 0, fmt.Errorf("%w: %q", ErrInvalidAmount, s)
	}
	return cents, nil
}
// ---------------------------------------------------------------------------
// مدى-بي
// الجسم JSON، والتوقيع في الترويسة X-Mada-Signature بصيغة sha256=<hex>
// ---------------------------------------------------------------------------
type madaPayload struct {
	EventID string `json:"event\_id"`
	State string `json:"state"`
	AmountMinor json.Number `json:"amount\_minor"` // بأصغر وحدة (هللة)
	Currency string `json:"currency"`
	MerchantRef string `json:"merchant\_ref"`
	CreatedAt string `json:"created\_at"` // RFC 3339 (قد يحمل إزاحة +03:00)
}
func ParseMadaPay(body string, signatureHex string, secret string) (PaymentEvent, error) {
	// التحقق من الجسم كاملاً قبل أي تحليل له.
	if err := verifyHMAC(body, secret, signatureHex); err != nil {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w", err)
	}
	var p madaPayload
	dec := json.NewDecoder(strings.NewReader(body))
	dec.UseNumber()
	if err := dec.Decode(\&p); err != nil {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w: %v", ErrMalformedBody, err)
	}
	if p.EventID == "" {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w: event\_id", ErrMissingField)
	}
	if p.MerchantRef == "" {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w: merchant\_ref", ErrMissingField)
	}
	status, err := normalizeStatus(p.State)
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w", err)
	}
	cents, err := strconv.ParseInt(p.AmountMinor.String(), 10, 64)
	if err != nil || cents <= 0 {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w: %q", ErrInvalidAmount, p.AmountMinor.String())
	}
	cur, err := normalizeCurrency(p.Currency)
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w", err)
	}
	t, err := time.Parse(time.RFC3339, p.CreatedAt)
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("mada\_pay: %w: %q", ErrInvalidTime, p.CreatedAt)
	}
	return PaymentEvent{
	 Provider: ProviderMadaPay,
	 EventID: p.EventID,
	 Status: status,
	 AmountCents: cents,
	 Currency: cur,
	 Reference: p.MerchantRef,
	 OccurredAt: t.UTC(),
	}, nil
}
// ---------------------------------------------------------------------------
// باي-لاين
// التوقيع في الحقل sign داخل الجسم، وهو HMAC-SHA256 لقيم الحقول
// (عدا sign) مرتبةً أبجدياً حسب اسم الحقل، ومفصولة بـ "\&". hex بأحرف صغيرة.
// ---------------------------------------------------------------------------
// payLineSigningString يبني السلسلة الموقَّعة من الحقول بعد استبعاد sign.
func payLineSigningString(fields map\[string]string) string {
	keys := make(\[]string, 0, len(fields))
	for k := range fields {
	 if k != "sign" {
	 keys = append(keys, k)
	 }
	}
	sort.Strings(keys)
	vals := make(\[]string, len(keys))
	for i, k := range keys {
	 vals\[i] = fields\[k]
	}
	return strings.Join(vals, "\&")
}
// decodeFlatFields يقرأ كائن JSON مسطحاً ويحوّل كل قيمة إلى نص
// (الأرقام تحتفظ بصياغتها الأصلية عبر json.Number).
func decodeFlatFields(body string) (map\[string]string, error) {
	var raw map\[string]interface{}
	dec := json.NewDecoder(strings.NewReader(body))
	dec.UseNumber()
	if err := dec.Decode(\&raw); err != nil {
	 return nil, fmt.Errorf("%w: %v", ErrMalformedBody, err)
	}
	out := make(map\[string]string, len(raw))
	for k, v := range raw {
	 switch x := v.(type) {
	 case string:
	 out\[k] = x
	 case json.Number:
	 out\[k] = x.String()
	 case bool:
	 out\[k] = strconv.FormatBool(x)
	 default:
	 return nil, fmt.Errorf("%w: الحقل %q ليس قيمة بسيطة", ErrMalformedBody, k)
	 }
	}
	return out, nil
}
func ParsePayLine(body string, secret string) (PaymentEvent, error) {
	f, err := decodeFlatFields(body)
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("payline: %w", err)
	}
	// التحقق من التوقيع أولاً، قبل الوثوق بأي حقل.
	if err := verifyHMAC(payLineSigningString(f), secret, f\["sign"]); err != nil {
	 return PaymentEvent{}, fmt.Errorf("payline: %w", err)
	}
	if f\["txn\_id"] == "" {
	 return PaymentEvent{}, fmt.Errorf("payline: %w: txn\_id", ErrMissingField)
	}
	if f\["order\_no"] == "" {
	 return PaymentEvent{}, fmt.Errorf("payline: %w: order\_no", ErrMissingField)
	}
	status, err := normalizeStatus(f\["result"])
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("payline: %w", err)
	}
	cents, err := parseDecimalCents(f\["amt"])
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("payline: %w", err)
	}
	cur, err := normalizeCurrency(f\["cur"])
	if err != nil {
	 return PaymentEvent{}, fmt.Errorf("payline: %w", err)
	}
	sec, err := strconv.ParseInt(strings.TrimSpace(f\["ts"]), 10, 64)
	if err != nil || sec <= 0 {
	 return PaymentEvent{}, fmt.Errorf("payline: %w: %q", ErrInvalidTime, f\["ts"])
	}
	return PaymentEvent{
	 Provider: ProviderPayLine,
	 EventID: f\["txn\_id"],
	 Status: status,
	 AmountCents: cents,
	 Currency: cur,
	 Reference: f\["order\_no"],
	 OccurredAt: time.Unix(sec, 0).UTC(),
	}, nil
}
// ---------------------------------------------------------------------------
// إزالة التكرار
// ---------------------------------------------------------------------------
// Dedupe يُبقي أول ظهور لكل (Provider:EventID) ويحافظ على الترتيب.
func Dedupe(events \[]PaymentEvent) \[]PaymentEvent {
	seen := make(map\[string]struct{}, len(events))
	out := make(\[]PaymentEvent, 0, len(events))
	for \_, e := range events {
	 key := e.Provider + ":" + e.EventID
	 if \_, dup := seen\[key]; dup {
	 continue
	 }
	 seen\[key] = struct{}{}
	 out = append(out, e)
	}
	return out
}
// ---------------------------------------------------------------------------
// بيانات تجريبية (مفاتيح ثابتة، لا شيء عشوائي)
// ---------------------------------------------------------------------------
const (
	madaSecret = "demo-mada-pay-secret-key"
	payLineSecret = "demo-payline-secret-key"
)
func signMada(body, secret string) string {
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(body))
	return "sha256=" + hex.EncodeToString(mac.Sum(nil))
}
// signedPayLineBody يبني جسم باي-لاين موقَّعاً؛ json.Marshal لخريطة يرتب المفاتيح فيكون الناتج حتمياً.
func signedPayLineBody(fields map\[string]string, secret string) string {
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(payLineSigningString(fields)))
	fields\["sign"] = hex.EncodeToString(mac.Sum(nil))
	b, \_ := json.Marshal(fields)
	return string(b)
}
func printEvent(e PaymentEvent) {
	fmt.Printf(" %-8s %-12s %-9s %8.2f %s ref=%s at=%s\\n",
	 e.Provider, e.EventID, e.Status,
	 float64(e.AmountCents)/100, e.Currency, e.Reference,
	 e.OccurredAt.Format(time.RFC3339))
}
func main() {
	const orderRef = "ORD-2026-1042"
	// 1) مدى-بي: نجاح، 150.75 ر.س، بتوقيت +03:00 (سيُحوَّل إلى UTC).
	madaBody := `{"event\_id":"mp\_evt\_9001","state":"SUCCESS","amount\_minor":15075,` +
	 `"currency":"SAR","merchant\_ref":"` + orderRef + `","created\_at":"2026-10-29T14:30:00+03:00"}`
	madaSig := signMada(madaBody, madaSecret)
	// 2) باي-لاين: نجاح لنفس الطلب، بأسماء وحالات وصيغ مختلفة (عملة بأحرف صغيرة، ts بالثواني).
	payTS := strconv.FormatInt(time.Date(2026, 10, 29, 11, 31, 5, 0, time.UTC).Unix(), 10)
	payFields := map\[string]string{
	 "txn\_id": "pl\_7001", "result": "paid", "amt": "150.75",
	 "cur": "sar", "order\_no": orderRef, "ts": payTS,
	}
	payBody := signedPayLineBody(payFields, payLineSecret)
	// 3) إعادة إرسال (retry) لنفس إشعار باي-لاين حرفياً.
	payRetryBody := payBody
	// 4) إشعار باي-لاين بتوقيع تالف: نغيّر المبلغ بعد التوقيع.
	tamperedFields := map\[string]string{
	 "txn\_id": "pl\_7002", "result": "completed", "amt": "999.00",
	 "cur": "SAR", "order\_no": "ORD-2026-1043", "ts": payTS,
	}
	tamperedBody := signedPayLineBody(tamperedFields, payLineSecret)
	tamperedBody = strings.Replace(tamperedBody, `"999.00"`, `"1.00"`, 1)
	type delivery struct {
	 name string
	 parse func() (PaymentEvent, error)
	}
	deliveries := \[]delivery{
	 {"مدى-بي: نجاح", func() (PaymentEvent, error) { return ParseMadaPay(madaBody, madaSig, madaSecret) }},
	 {"باي-لاين: نجاح", func() (PaymentEvent, error) { return ParsePayLine(payBody, payLineSecret) }},
	 {"باي-لاين: إعادة إرسال (retry)", func() (PaymentEvent, error) { return ParsePayLine(payRetryBody, payLineSecret) }},
	 {"باي-لاين: توقيع تالف", func() (PaymentEvent, error) { return ParsePayLine(tamperedBody, payLineSecret) }},
	}
	fmt.Println("== معالجة الإشعارات الواردة ==")
	var accepted \[]PaymentEvent
	for i, d := range deliveries {
	 ev, err := d.parse()
	 if err != nil {
	 fmt.Printf("%d) %s -> مرفوض: %v (توقيع تالف؟ %t)\\n", i+1, d.name, err, errors.Is(err, ErrBadSignature))
	 continue
	 }
	 fmt.Printf("%d) %s -> مقبول\\n", i+1, d.name)
	 accepted = append(accepted, ev)
	}
	unique := Dedupe(accepted)
	fmt.Printf("\\n== الأحداث الموحدة بعد إزالة التكرار (%d من %d مقبولة) ==\\n", len(unique), len(accepted))
	for \_, e := range unique {
	 printEvent(e)
	}
	// عرض أخطاء التحويل المميزة على أمثلة صغيرة.
	fmt.Println("\\n== فحوص الرفض (sentinel errors) ==")
	checks := \[]struct {
	 name string
	 body string
	 want error
	}{
	 {"مبلغ صفر", `{"event\_id":"x1","state":"SUCCESS","amount\_minor":0,"currency":"SAR","merchant\_ref":"R","created\_at":"2026-10-29T10:00:00Z"}`, ErrInvalidAmount},
	 {"مبلغ سالب", `{"event\_id":"x2","state":"SUCCESS","amount\_minor":-500,"currency":"SAR","merchant\_ref":"R","created\_at":"2026-10-29T10:00:00Z"}`, ErrInvalidAmount},
	 {"عملة غير معروفة", `{"event\_id":"x3","state":"SUCCESS","amount\_minor":500,"currency":"XYZ","merchant\_ref":"R","created\_at":"2026-10-29T10:00:00Z"}`, ErrUnknownCurrency},
	 {"وقت غير صالح", `{"event\_id":"x4","state":"SUCCESS","amount\_minor":500,"currency":"SAR","merchant\_ref":"R","created\_at":"29/10/2026"}`, ErrInvalidTime},
	}
	for \_, c := range checks {
	 \_, err := ParseMadaPay(c.body, signMada(c.body, madaSecret), madaSecret)
	 fmt.Printf(" %-18s -> %t (%v)\\n", c.name, errors.Is(err, c.want), err)
	}
}
جChatGPT
سأبني الحزمة في ملف main.go باستخدام مكتبة Go القياسية فقط، مع توحيد الإشعارات والتحقق من التوقيع قبل قبول أي حدث، وإزالة التكرار وفق Provider + ":" + EventID مع الاحتفاظ بأول ظهور.
هناك نقطة أمنية مهمة: الإشعار ذو التوقيع غير الصحيح يجب ألا يدخل قائمة الأحداث المقبولة أصلاً. كذلك، إزالة تكرار الإشعارات داخل الذاكرة لا تمنع تكرار التسوية بعد إعادة تشغيل البرنامج؛ في الإنتاج تحتاج إلى قيد فريد دائم على معرّف الحدث ضمن معاملة التسوية.
ملف main.go
يعتمد المثال التالي مخططاً واضحاً للحقول، مع قبول بعض الأسماء البديلة الشائعة بين البوابتين. توقيع PayLine يُحسب من أزواج key=value المرتبة أبجدياً، مع استثناء sign، ثم تُجمع باستخدام \&. وتُعامل قيمة amount\_cents بوصفها هللات/وحدات العملة الصغرى، وليس مبلغاً عشرياً.
package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"
)
var (
	ErrInvalidSignature = errors.New("invalid signature")
	ErrInvalidAmount = errors.New("invalid amount")
	ErrUnknownCurrency = errors.New("unknown currency")
	ErrInvalidOccurredAt = errors.New("invalid OccurredAt")
	ErrInvalidStatus = errors.New("invalid payment status")
	ErrInvalidBody = errors.New("invalid JSON body")
	ErrMissingField = errors.New("missing required field")
)
type PaymentEvent struct {
	Provider string
	EventID string
	Status string
	AmountCents int64
	Currency string
	Reference string
	OccurredAt time.Time
}
// Fixed demo secrets. In production, keep secrets outside source code.
const (
	madaSecret = "mada-demo-secret-2026"
	paylineSecret = "payline-demo-secret-2026"
)
var knownCurrencies = func() map\[string]bool {
	// ISO 4217 alphabetic currency codes, including common fund/metal
	// codes. This is a static validation list, not a live ISO registry.
	codes := strings.Fields(`
AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF
BMD BND BOB BOV BRL BSD BTN BWP BYN BZD CAD CDF CHE CHF CHW CLF
CLP CNY COP COU CRC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB EUR
FJD FKP GBP GEL GHS GIP GMD GNF GTQ GYD HKD HNL HTG HUF IDR ILS
INR IQD IRR ISK JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT
LAK LBP LKR LRD LSL LYD MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR
MWK MXN MXV MYR MZN NAD NGN NIO NOK NPR NZD OMR PAB PEN PGK PHP
PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE
SLL SOS SRD SSP STN SVC SYP SZL THB TJS TMT TND TOP TRY TTD TWD
TZS UAH UGX USD USN UYI UYU UYW UZS VED VES VND VUV WST XAF XAG
XAU XBA XBB XBC XBD XCD XCG XDR XOF XPD XPF XPT XSU XTS XUA XXX
YER ZAR ZMW ZWG
`)
	m := make(map\[string]bool, len(codes))
	for \_, c := range codes {
	 m\[c] = true
	}
	return m
}()
// JSON values are kept as RawMessage so numbers and strings can both
// be accepted without losing their textual representation.
type rawFields map\[string]json.RawMessage
func decodeBody(body string) (rawFields, error) {
	var fields rawFields
	if err := json.Unmarshal(\[]byte(body), \&fields); err != nil || fields == nil {
	 return nil, ErrInvalidBody
	}
	return fields, nil
}
func fieldString(fields rawFields, names ...string) (string, bool) {
	for \_, name := range names {
	 raw, ok := fields\[name]
	 if !ok {
	 continue
	 }
	 var s string
	 if err := json.Unmarshal(raw, \&s); err == nil {
	 return s, true
	 }
	 // Permit JSON integer/decimal tokens as text.
	 var n json.Number
	 if err := json.Unmarshal(raw, \&n); err == nil {
	 return n.String(), true
	 }
	}
	return "", false
}
func requiredField(fields rawFields, names ...string) (string, error) {
	s, ok := fieldString(fields, names...)
	if !ok || strings.TrimSpace(s) == "" {
	 return "", fmt.Errorf("%w: %s", ErrMissingField, strings.Join(names, "/"))
	}
	return s, nil
}
func normalizeStatus(s string) (string, error) {
	switch strings.ToLower(strings.TrimSpace(s)) {
	case "success", "succeeded", "paid", "completed":
	 return "succeeded", nil
	case "failed", "failure", "declined", "cancelled", "canceled":
	 return "failed", nil
	default:
	 return "", fmt.Errorf("%w: %q", ErrInvalidStatus, s)
	}
}
func parseAmount(s string) (int64, error) {
	n, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64)
	if err != nil || n <= 0 {
	 return 0, fmt.Errorf("%w: %q", ErrInvalidAmount, s)
	}
	return n, nil
}
func parseCurrency(s string) (string, error) {
	c := strings.ToUpper(strings.TrimSpace(s))
	if len(c) != 3 || !knownCurrencies\[c] {
	 return "", fmt.Errorf("%w: %q", ErrUnknownCurrency, s)
	}
	return c, nil
}
func parseOccurredAt(s string) (time.Time, error) {
	// Require an explicit timezone: RFC3339 / RFC3339Nano.
	t, err := time.Parse(time.RFC3339Nano, strings.TrimSpace(s))
	if err != nil {
	 return time.Time{}, fmt.Errorf("%w: %q", ErrInvalidOccurredAt, s)
	}
	return t.UTC(), nil
}
func normalize(fields rawFields, provider string) (PaymentEvent, error) {
	var e PaymentEvent
	e.Provider = provider
	var err error
	if e.EventID, err = requiredField(fields,
	 "event\_id", "eventId", "eventid", "id", "transaction\_id"); err != nil {
	 return e, err
	}
	status, err := requiredField(fields,
	 "status", "payment\_status", "paymentStatus", "state")
	if err != nil {
	 return e, err
	}
	if e.Status, err = normalizeStatus(status); err != nil {
	 return e, err
	}
	amount, err := requiredField(fields,
	 "amount\_cents", "amountCents", "amount")
	if err != nil {
	 return e, err
	}
	if e.AmountCents, err = parseAmount(amount); err != nil {
	 return e, err
	}
	currency, err := requiredField(fields, "currency", "currency\_code", "currencyCode")
	if err != nil {
	 return e, err
	}
	if e.Currency, err = parseCurrency(currency); err != nil {
	 return e, err
	}
	if e.Reference, err = requiredField(fields,
	 "reference", "order\_reference", "orderReference", "order\_ref", "merchant\_reference"); err != nil {
	 return e, err
	}
	occurred, err := requiredField(fields,
	 "occurred\_at", "occurredAt", "created\_at", "createdAt", "timestamp")
	if err != nil {
	 return e, err
	}
	if e.OccurredAt, err = parseOccurredAt(occurred); err != nil {
	 return e, err
	}
	return e, nil
}
func verifyHMAC(message, signature, secret string) error {
	signature = strings.TrimSpace(signature)
	signature = strings.TrimPrefix(signature, "sha256=")
	got, err := hex.DecodeString(signature)
	if err != nil {
	 return ErrInvalidSignature
	}
	mac := hmac.New(sha256.New, \[]byte(secret))
	\_, \_ = mac.Write(\[]byte(message))
	if !hmac.Equal(got, mac.Sum(nil)) {
	 return ErrInvalidSignature
	}
	return nil
}
// ParseMadaPay validates the signature over the exact original body bytes.
func ParseMadaPay(body string, signatureHex string, secret string) (PaymentEvent, error) {
	if err := verifyHMAC(body, signatureHex, secret); err != nil {
	 return PaymentEvent{}, err
	}
	fields, err := decodeBody(body)
	if err != nil {
	 return PaymentEvent{}, err
	}
	return normalize(fields, "mada\_pay")
}
// PayLine canonicalization: sort field names lexicographically,
// exclude "sign", join key=value pairs using "\&".
func payLineCanonical(fields rawFields) (string, error) {
	keys := make(\[]string, 0, len(fields))
	values := make(map\[string]string, len(fields))
	for key := range fields {
	 if key == "sign" {
	 continue
	 }
	 value, ok := fieldString(fields, key)
	 if !ok {
	 return "", fmt.Errorf("%w: unsupported PayLine value for %q", ErrInvalidBody, key)
	 }
	 keys = append(keys, key)
	 values\[key] = value
	}
	sort.Strings(keys)
	pairs := make(\[]string, 0, len(keys))
	for \_, key := range keys {
	 pairs = append(pairs, key+"="+values\[key])
	}
	return strings.Join(pairs, "\&"), nil
}
func ParsePayLine(body string, secret string) (PaymentEvent, error) {
	fields, err := decodeBody(body)
	if err != nil {
	 return PaymentEvent{}, err
	}
	signature, err := requiredField(fields, "sign")
	if err != nil {
	 return PaymentEvent{}, err
	}
	canonical, err := payLineCanonical(fields)
	if err != nil {
	 return PaymentEvent{}, err
	}
	if err := verifyHMAC(canonical, signature, secret); err != nil {
	 return PaymentEvent{}, err
	}
	return normalize(fields, "payline")
}
// Dedupe keeps the first event for each provider/event ID pair.
func Dedupe(events \[]PaymentEvent) \[]PaymentEvent {
	seen := make(map\[string]struct{}, len(events))
	result := make(\[]PaymentEvent, 0, len(events))
	for \_, event := range events {
	 key := event.Provider + ":" + event.EventID
	 if \_, exists := seen\[key]; exists {
	 continue
	 }
	 seen\[key] = struct{}{}
	 result = append(result, event)
	}
	return result
}
// Demo helpers generate correctly signed sample payloads.
func signHMAC(message, secret string) string {
	mac := hmac.New(sha256.New, \[]byte(secret))
	\_, \_ = mac.Write(\[]byte(message))
	return hex.EncodeToString(mac.Sum(nil))
}
func signPayLineBody(body, secret string) (string, error) {
	fields, err := decodeBody(body)
	if err != nil {
	 return "", err
	}
	canonical, err := payLineCanonical(fields)
	if err != nil {
	 return "", err
	}
	// Re-encode as JSON with a generated sign field.
	fields\["sign"], \_ = json.Marshal(signHMAC(canonical, secret))
	encoded, err := json.Marshal(fields)
	if err != nil {
	 return "", err
	}
	return string(encoded), nil
}
func main() {
	accepted := make(\[]PaymentEvent, 0, 4)
	// Both providers report the same order, but have distinct event IDs.
	madaBody := `{"event\_id":"mada-evt-001","status":"SUCCESS","amount\_cents":12500,"currency":"SAR","reference":"ORDER-1001","occurred\_at":"2026-10-29T10:00:00+03:00"}`
	madaSignature := signHMAC(madaBody, madaSecret)
	madaEvent, err := ParseMadaPay(madaBody, madaSignature, madaSecret)
	if err != nil {
	 fmt.Println("MadaPay rejected:", err)
	} else {
	 accepted = append(accepted, madaEvent)
	}
	paylineUnsigned := `{"eventId":"payline-evt-900","payment\_status":"paid","amount\_cents":12500,"currency":"sar","order\_ref":"ORDER-1001","created\_at":"2026-10-29T07:00:00Z"}`
	paylineBody, err := signPayLineBody(paylineUnsigned, paylineSecret)
	if err != nil {
	 panic(err)
	}
	paylineEvent, err := ParsePayLine(paylineBody, paylineSecret)
	if err != nil {
	 fmt.Println("PayLine rejected:", err)
	} else {
	 accepted = append(accepted, paylineEvent)
	 // Simulate an identical retry from PayLine.
	 accepted = append(accepted, paylineEvent)
	}
	// Tampered body: signature was calculated for a different payload.
	tamperedBody := strings.Replace(madaBody, "12500", "12501", 1)
	\_, err = ParseMadaPay(tamperedBody, madaSignature, madaSecret)
	if err != nil {
	 fmt.Println("Tampered notification rejected:", err)
	}
	finalEvents := Dedupe(accepted)
	fmt.Printf("\\nFinal events (%d):\\n", len(finalEvents))
	for \_, event := range finalEvents {
	 fmt.Printf(
	 "Provider=%s EventID=%s Status=%s AmountCents=%d Currency=%s Reference=%s OccurredAt=%s\\n",
	 event.Provider,
	 event.EventID,
	 event.Status,
	 event.AmountCents,
	 event.Currency,
	 event.Reference,
	 event.OccurredAt.Format(time.RFC3339Nano),
	 )
	}
}
التشغيل والتحقق
احفظ الملف باسم main.go ثم شغّله:
go run main.go
الناتج المتوقع يتضمن حدثين مقبولين فقط؛ إشعار نجاح من كل بوابة، مع رفض التوقيع التالف وإزالة إعادة إرسال PayLine المكررة:
Tampered notification rejected: invalid signature
Final events (2):
Provider=mada\_pay EventID=mada-evt-001 Status=succeeded AmountCents=12500 Currency=SAR Reference=ORDER-1001 OccurredAt=2026-10-29T07:00:00Z
Provider=payline EventID=payline-evt-900 Status=succeeded AmountCents=12500 Currency=SAR Reference=ORDER-1001 OccurredAt=2026-10-29T07:00:00Z
ملاحظات مهمة قبل الإنتاج:
\- مخطط الحقول وأسماء الحقول البديلة في المثال افتراضات عملية؛ يجب مطابقتها مع التوثيق الرسمي لكل بوابة.
\- يجب التأكد من خوارزمية التوقيع الدقيقة لدى PayLine، خصوصاً قواعد الترميز والقيم الفارغة وترتيب الحقول؛ أي اختلاف في بناء النص الموقّع سيؤدي إلى رفض إشعارات صحيحة.
\- قائمة العملات ثابتة ومضمّنة في الملف؛ ينبغي مراجعتها دورياً مقابل معيار ISO 4217.
\- Dedupe تزيل التكرار من الشريحة الحالية فقط. لمنع التسوية المكررة فعلياً، استخدم قيداً فريداً دائماً على (Provider, EventID) داخل قاعدة البيانات، ونفّذ تسجيل الحدث والتسوية ضمن معاملة ذرية واحدة. لا تُرجع نجاحاً للإشعار إلا بعد حفظه أو تسجيله بصورة موثوقة.
أDeepSeek
الحقول المرتبة أبجدياً (باستثناء حقل sign نفسه)، وتتحقق.
هيكل موحّد:
go
type PaymentEvent struct {
  Provider string // "mada\_pay" | "payline"
  EventID string // معرّف فريد عند كل مزود
  Status string // "succeeded" | "failed" — يجب توحيد الحالات ("SUCCESS","paid","completed" → succeeded)
  AmountCents int64
  Currency string // ISO 4217 upper-case
  Reference string // رقم طلبنا عند المزود
  OccurredAt time.Time // بصيغة UTC
}
Dedupe(events \[]PaymentEvent) \[]PaymentEvent — تعيد قائمة بدون تكرار: المفتاح هو Provider + ":" + EventID، وعند التكرار يُبقى أول ظهور فقط مع الحفاظ على الترتيب.
أخطاء التحويل: مبالغ سالبة أو صفر تُرفض، عملة غير معروفة تُرفض، OccurredAt بصيغة غير صالحة تُرفض — كلها بأخطاء مميزة القيمة (sentinel errors).
بيانات تجريبية مضمّنة في main تُظهر: إشعارا نجاح من المزودين لنفس الطلب (منصوعين يدوياً بمفاتيح ثابتة في الملف)، إشعار payline مكرر، وإشعار بتوقيع تالف — مع طباعة الأحداث الموحدة النهائية. حتمي بالكامل، لا time.Now، لا قراءة من ملفات أو الشبكة، مكتبة قياسية فقط (crypto/hmac, crypto/sha256, encoding/hex, encoding/json, sort, strings, time).
Here's a complete, deterministic, single-file Go solution matching the spec:
go
package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"
)
// ---------- Sentinel errors ----------
var (
	ErrSignatureMismatch = errors.New("signature mismatch")
	ErrMissingSignature = errors.New("missing signature")
	ErrBadAmount = errors.New("amount must be positive")
	ErrUnknownCurrency = errors.New("unknown currency")
	ErrBadTimestamp = errors.New("invalid occurred\_at timestamp")
	ErrMalformedBody = errors.New("malformed body")
	ErrMissingField = errors.New("missing required field")
	ErrUnknownStatus = errors.New("unknown status")
)
// ---------- Unified event ----------
type PaymentEvent struct {
	Provider string
	EventID string
	Status string
	AmountCents int64
	Currency string
	Reference string
	OccurredAt time.Time
}
var knownCurrencies = map\[string]struct{}{
	"SAR": {}, "USD": {}, "EUR": {}, "AED": {}, "GBP": {},
	"KWD": {}, "BHD": {}, "OMR": {}, "QAR": {}, "EGP": {}, "JOD": {},
}
// ---------- Helpers ----------
func hmacSHA256Hex(secret, payload string) string {
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(payload))
	return hex.EncodeToString(mac.Sum(nil))
}
func normalizeStatus(provider, s string) (string, error) {
	u := strings.ToUpper(strings.TrimSpace(s))
	switch u {
	case "SUCCESS", "SUCCEEDED", "PAID", "COMPLETED", "CAPTURED", "OK":
	 return "succeeded", nil
	case "FAILED", "FAILURE", "DECLINED", "ERROR", "CANCELED", "CANCELLED", "REJECTED":
	 return "failed", nil
	}
	return "", fmt.Errorf("%w: %q (provider=%s)", ErrUnknownStatus, s, provider)
}
func normalizeCurrency(c string) (string, error) {
	u := strings.ToUpper(strings.TrimSpace(c))
	if \_, ok := knownCurrencies\[u]; !ok {
	 return "", fmt.Errorf("%w: %q", ErrUnknownCurrency, c)
	}
	return u, nil
}
func validateAmount(a int64) (int64, error) {
	if a <= 0 {
	 return 0, fmt.Errorf("%w: %d", ErrBadAmount, a)
	}
	return a, nil
}
func parseUTC(s string) (time.Time, error) {
	// Accept RFC3339 and a couple of common layouts; always force UTC.
	layouts := \[]string{
	 time.RFC3339Nano,
	 time.RFC3339,
	 "2006-01-02T15:04:05",
	 "2006-01-02 15:04:05",
	}
	for \_, l := range layouts {
	 if t, err := time.Parse(l, s); err == nil {
	 return t.UTC(), nil
	 }
	}
	return time.Time{}, fmt.Errorf("%w: %q", ErrBadTimestamp, s)
}
// ---------- Mada-Pay ----------
// Body is JSON; signature in header as "sha256=<hex>", HMAC over the whole raw body.
type madaPayBody struct {
	ID string `json:"id"`
	Status string `json:"status"`
	Amount json.RawMessage `json:"amount"` // could be number or string
	Currency string `json:"currency"`
	OrderRef string `json:"order\_ref"`
	CreatedAt string `json:"created\_at"`
}
func ParseMadaPay(body string, signatureHex string, secret string) (PaymentEvent, error) {
	// Verify signature (header format: "sha256=<hex>" or bare hex).
	sig := strings.TrimSpace(signatureHex)
	if sig == "" {
	 return PaymentEvent{}, ErrMissingSignature
	}
	if strings.HasPrefix(strings.ToLower(sig), "sha256=") {
	 sig = sig\[len("sha256="):]
	}
	expected := hmacSHA256Hex(secret, body)
	// constant-time compare on decoded bytes
	gotB, err1 := hex.DecodeString(sig)
	expB, err2 := hex.DecodeString(expected)
	if err1 != nil || err2 != nil || !hmac.Equal(gotB, expB) {
	 return PaymentEvent{}, fmt.Errorf("%w (mada\_pay)", ErrSignatureMismatch)
	}
	var raw madaPayBody
	if err := json.Unmarshal(\[]byte(body), \&raw); err != nil {
	 return PaymentEvent{}, fmt.Errorf("%w: %v", ErrMalformedBody, err)
	}
	if raw.ID == "" || raw.Status == "" || raw.Currency == "" || raw.OrderRef == "" || raw.CreatedAt == "" {
	 return PaymentEvent{}, fmt.Errorf("%w (mada\_pay)", ErrMissingField)
	}
	// Amount may be number or numeric string.
	var amount int64
	if len(raw.Amount) > 0 \&\& raw.Amount\[0] == '"' {
	 var s string
	 if err := json.Unmarshal(raw.Amount, \&s); err != nil {
	 return PaymentEvent{}, fmt.Errorf("%w: amount", ErrMalformedBody)
	 }
	 if \_, err := fmt.Sscanf(s, "%d", \&amount); err != nil {
	 return PaymentEvent{}, fmt.Errorf("%w: amount", ErrMalformedBody)
	 }
	} else {
	 if err := json.Unmarshal(raw.Amount, \&amount); err != nil {
	 return PaymentEvent{}, fmt.Errorf("%w: amount", ErrMalformedBody)
	 }
	}
	status, err := normalizeStatus("mada\_pay", raw.Status)
	if err != nil {
	 return PaymentEvent{}, err
	}
	cur, err := normalizeCurrency(raw.Currency)
	if err != nil {
	 return PaymentEvent{}, err
	}
	if \_, err := validateAmount(amount); err != nil {
	 return PaymentEvent{}, err
	}
	ts, err := parseUTC(raw.CreatedAt)
	if err != nil {
	 return PaymentEvent{}, err
	}
	return PaymentEvent{
	 Provider: "mada\_pay",
	 EventID: raw.ID,
	 Status: status,
	 AmountCents: amount,
	 Currency: cur,
	 Reference: raw.OrderRef,
	 OccurredAt: ts,
	}, nil
}
// ---------- PayLine ----------
// Body is a form-encoded string "k1=v1\&k2=v2...". Signature in field "sign".
// HMAC-SHA256 over alphabetically-sorted fields (excluding "sign") joined by "\&".
// Value is hex.
func ParsePayLine(body string, secret string) (PaymentEvent, error) {
	fields := map\[string]string{}
	var order \[]string
	for \_, part := range strings.Split(body, "\&") {
	 if part == "" {
	 continue
	 }
	 kv := strings.SplitN(part, "=", 2)
	 if len(kv) != 2 {
	 return PaymentEvent{}, fmt.Errorf("%w (payline)", ErrMalformedBody)
	 }
	 k := kv\[0]
	 v := kv\[1]
	 fields\[k] = v
	 order = append(order, k)
	}
	\_ = order
	sig, ok := fields\["sign"]
	if !ok || sig == "" {
	 return PaymentEvent{}, ErrMissingSignature
	}
	// Build canonical string.
	keys := make(\[]string, 0, len(fields))
	for k := range fields {
	 if k == "sign" {
	 continue
	 }
	 keys = append(keys, k)
	}
	sort.Strings(keys)
	var b strings.Builder
	for i, k := range keys {
	 if i > 0 {
	 b.WriteByte('\&')
	 }
	 b.WriteString(k)
	 b.WriteByte('=')
	 b.WriteString(fields\[k])
	}
	expected := hmacSHA256Hex(secret, b.String())
	gotB, err1 := hex.DecodeString(sig)
	expB, err2 := hex.DecodeString(expected)
	if err1 != nil || err2 != nil || !hmac.Equal(gotB, expB) {
	 return PaymentEvent{}, fmt.Errorf("%w (payline)", ErrSignatureMismatch)
	}
	// Required fields (PayLine naming).
	eventID := fields\["transaction\_id"]
	statusRaw := fields\["status"]
	amountStr := fields\["amount"]
	currencyRaw := fields\["currency"]
	ref := fields\["order\_id"]
	tsStr := fields\["created\_at"]
	if eventID == "" || statusRaw == "" || amountStr == "" || currencyRaw == "" || ref == "" || tsStr == "" {
	 return PaymentEvent{}, fmt.Errorf("%w (payline)", ErrMissingField)
	}
	var amount int64
	if \_, err := fmt.Sscanf(amountStr, "%d", \&amount); err != nil {
	 return PaymentEvent{}, fmt.Errorf("%w: amount", ErrMalformedBody)
	}
	status, err := normalizeStatus("payline", statusRaw)
	if err != nil {
	 return PaymentEvent{}, err
	}
	cur, err := normalizeCurrency(currencyRaw)
	if err != nil {
	 return PaymentEvent{}, err
	}
	if \_, err := validateAmount(amount); err != nil {
	 return PaymentEvent{}, err
	}
	ts, err := parseUTC(tsStr)
	if err != nil {
	 return PaymentEvent{}, err
	}
	return PaymentEvent{
	 Provider: "payline",
	 EventID: eventID,
	 Status: status,
	 AmountCents: amount,
	 Currency: cur,
	 Reference: ref,
	 OccurredAt: ts,
	}, nil
}
// ---------- Dedupe ----------
func Dedupe(events \[]PaymentEvent) \[]PaymentEvent {
	seen := make(map\[string]struct{}, len(events))
	out := make(\[]PaymentEvent, 0, len(events))
	for \_, e := range events {
	 k := e.Provider + ":" + e.EventID
	 if \_, ok := seen\[k]; ok {
	 continue
	 }
	 seen\[k] = struct{}{}
	 out = append(out, e)
	}
	return out
}
// ---------- Demo ----------
const (
	madaSecret = "mada\_secret\_demo\_key\_123"
	paylineSecret = "payline\_secret\_demo\_key\_456"
)
func buildMadaBody() string {
	// Hand-crafted JSON. Amount is number (cents).
	return `{"id":"MP-EVT-9001","status":"SUCCESS","amount":15000,"currency":"sar","order\_ref":"ORDER-42","created\_at":"2024-03-01T12:34:56Z"}`
}
func buildPayLineBody(signHex string) string {
	// Fields (order doesn't matter for signing; signing canonicalizes).
	// Status uses "completed" to exercise mapping.
	return "transaction\_id=PL-TX-7001" +
	 "\&status=completed" +
	 "\&amount=15000" +
	 "\¤cy=SAR" +
	 "\&order\_id=ORDER-42" +
	 "\&created\_at=2024-03-01T12:35:10Z" +
	 "\&sign=" + signHex
}
func signPayLine(fields map\[string]string, secret string) string {
	keys := make(\[]string, 0, len(fields))
	for k := range fields {
	 keys = append(keys, k)
	}
	sort.Strings(keys)
	var b strings.Builder
	for i, k := range keys {
	 if i > 0 {
	 b.WriteByte('\&')
	 }
	 b.WriteString(k)
	 b.WriteByte('=')
	 b.WriteString(fields\[k])
	}
	return hmacSHA256Hex(secret, b.String())
}
func main() {
	// --- Mada-Pay success ---
	madaBody := buildMadaBody()
	madaSig := "sha256=" + hmacSHA256Hex(madaSecret, madaBody)
	madaEvt, err := ParseMadaPay(madaBody, madaSig, madaSecret)
	if err != nil {
	 fmt.Println("mada parse error:", err)
	}
	// --- PayLine success (same order, different provider) ---
	plFields := map\[string]string{
	 "transaction\_id": "PL-TX-7001",
	 "status": "completed",
	 "amount": "15000",
	 "currency": "SAR",
	 "order\_id": "ORDER-42",
	 "created\_at": "2024-03-01T12:35:10Z",
	}
	plBody := buildPayLineBody(signPayLine(plFields, paylineSecret))
	plEvt, err := ParsePayLine(plBody, paylineSecret)
	if err != nil {
	 fmt.Println("payline parse error:", err)
	}
	// --- PayLine duplicate (retry) ---
	plDupBody := buildPayLineBody(signPayLine(plFields, paylineSecret))
	plDupEvt, err := ParsePayLine(plDupBody, paylineSecret)
	if err != nil {
	 fmt.Println("payline dup parse error:", err)
	}
	// --- Tampered signature ---
	tamperedSig := "sha256=" + strings.Repeat("a", 64)
	\_, err = ParseMadaPay(madaBody, tamperedSig, madaSecret)
	fmt.Println("tampered mada -> error:", err)
	if !errors.Is(err, ErrSignatureMismatch) {
	 fmt.Println("WARNING: expected ErrSignatureMismatch")
	}
	// --- Dedupe \& print ---
	all := \[]PaymentEvent{madaEvt, plEvt, plDupEvt}
	final := Dedupe(all)
	fmt.Println("\\nUnified events (after dedupe):")
	for \_, e := range final {
	 fmt.Printf(" provider=%s event\_id=%s status=%s amount=%d %s ref=%s at=%s\\n",
	 e.Provider, e.EventID, e.Status, e.AmountCents, e.Currency,
	 e.Reference, e.OccurredAt.Format(time.RFC3339))
	}
	fmt.Printf("\\nTotal parsed=%d, after dedupe=%d\\n", len(all), len(final))
}
Key design decisions
Signature verification is constant-time via hmac.Equal on decoded bytes; any mismatch (including malformed hex) maps to ErrSignatureMismatch.
Mada-Pay accepts the header as sha256=<hex> or bare <hex>, and HMACs the entire raw body (no re-marshaling), matching the spec.
PayLine canonicalizes by sorting all non-sign keys alphabetically, joins with k=v\&..., then HMACs. Signature stored in sign field.
Field unification: id/transaction\_id → EventID; status/status mapped through normalizeStatus; order\_ref/order\_id → Reference; created\_at parsed with several layouts then forced to UTC.
Sentinels are all distinct so callers can branch via errors.Is. Validation is ordered so signature errors surface before field/amount errors.
Dedupe preserves first occurrence and order using a map\[string]struct{} keyed on Provider:EventID.
Deterministic demo: no time.Now, no network, no files; secrets and payloads are constants. The tampered-signature case is asserted against ErrSignatureMismatch via errors.Is.
دGemini
إليك حزمة متكاملة في ملف واحد main.go باللغة Go، تستوفي جميع الشروط والمتطلبات المذكورة بدون أي اعتماديات خارجية أو اتصال شبكي، وتتضمن الدوال المطلوبة، المعالجة الآمنة للتوقيعات (HMAC-SHA256)، الأخطاء المعيارية (Sentinel Errors)، دالة إزالة التكرار (Dedupe)، وبيانات تجريبية شاملة في الدالة main.
ملف التنفيذ: main.go
Go
package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"
)
// الأخطاء المعيارية (Sentinel Errors) المحددة للمتطلبات
var (
	ErrInvalidAmount = errors.New("invalid amount: must be greater than zero")
	ErrInvalidCurrency = errors.New("invalid or unknown currency")
	ErrInvalidTimestamp = errors.New("invalid timestamp format")
	ErrInvalidSignature = errors.New("invalid signature")
)
// PaymentEvent الهيكل الموحد لأحداث الدفع
type PaymentEvent struct {
	Provider string // "mada\_pay" | "payline"
	EventID string // معرّف فريد عند كل مزود
	Status string // "succeeded" | "failed"
	AmountCents int64 // المبلغ بالهللات/السنتات
	Currency string // ISO 4217 upper-case
	Reference string // رقم طلبنا عند المزود
	OccurredAt time.Time // وقت الحدوث بصيغة UTC
}
// ---------------------------------------------------------
// 1. ParseMadaPay
// ---------------------------------------------------------
func ParseMadaPay(body string, signatureHex string, secret string) (PaymentEvent, error) {
	// التحقق من صيغة التوقيع sha256=<hex>
	const prefix = "sha256="
	if !strings.HasPrefix(signatureHex, prefix) {
	 return PaymentEvent{}, ErrInvalidSignature
	}
	receivedHex := strings.TrimPrefix(signatureHex, prefix)
	// التحقق من صحة توقيع HMAC-SHA256 للجسم كاملاً
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(body))
	expectedHex := hex.EncodeToString(mac.Sum(nil))
	if !hmac.Equal(\[]byte(receivedHex), \[]byte(expectedHex)) {
	 return PaymentEvent{}, ErrInvalidSignature
	}
	// هيكل بيانات Mada-Pay الداخلي
	var raw struct {
	 EventID string `json:"event\_id"`
	 Status string `json:"status"`
	 Amount int64 `json:"amount\_cents"`
	 Currency string `json:"currency"`
	 Reference string `json:"reference"`
	 OccurredAt string `json:"occurred\_at"`
	}
	if err := json.Unmarshal(\[]byte(body), \&raw); err != nil {
	 return PaymentEvent{}, err
	}
	return validateAndNormalize(
	 "mada\_pay",
	 raw.EventID,
	 raw.Status,
	 raw.Amount,
	 raw.Currency,
	 raw.OccurredAt,
	 raw.Reference,
	)
}
// ---------------------------------------------------------
// 2. ParsePayLine
// ---------------------------------------------------------
func ParsePayLine(body string, secret string) (PaymentEvent, error) {
	var data map\[string]any
	if err := json.Unmarshal(\[]byte(body), \&data); err != nil {
	 return PaymentEvent{}, err
	}
	receivedSign, ok := data\["sign"].(string)
	if !ok {
	 return PaymentEvent{}, ErrInvalidSignature
	}
	// استبعاد حقل sign لحساب التوقيع
	delete(data, "sign")
	// ترتيب الحقول أبجدياً حسب المفتاح
	var keys \[]string
	for k := range data {
	 keys = append(keys, k)
	}
	sort.Strings(keys)
	// تجميع القيم المرتبة بفاصل \&
	var values \[]string
	for \_, k := range keys {
	 values = append(values, valueToString(data\[k]))
	}
	stringToSign := strings.Join(values, "\&")
	// حساب التوقيع المتوقع
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(stringToSign))
	expectedSign := hex.EncodeToString(mac.Sum(nil))
	if !hmac.Equal(\[]byte(receivedSign), \[]byte(expectedSign)) {
	 return PaymentEvent{}, ErrInvalidSignature
	}
	// استخراج البيانات بنجاح بعد التحقق
	var raw struct {
	 TxID string `json:"tx\_id"`
	 State string `json:"state"`
	 Amount int64 `json:"amount"`
	 Curr string `json:"curr"`
	 OrderRef string `json:"order\_ref"`
	 Time string `json:"time"`
	}
	\_ = json.Unmarshal(\[]byte(body), \&raw)
	return validateAndNormalize(
	 "payline",
	 raw.TxID,
	 raw.State,
	 raw.Amount,
	 raw.Curr,
	 raw.Time,
	 raw.OrderRef,
	)
}
// ---------------------------------------------------------
// 3. Dedupe
// ---------------------------------------------------------
func Dedupe(events \[]PaymentEvent) \[]PaymentEvent {
	seen := make(map\[string]bool)
	var result \[]PaymentEvent
	for \_, e := range events {
	 key := fmt.Sprintf("%s:%s", e.Provider, e.EventID)
	 if !seen\[key] {
	 seen\[key] = true
	 result = append(result, e)
	 }
	}
	return result
}
// ---------------------------------------------------------
// دوال مساعدة للتحقق، التطبيع، وتحويل القيم
// ---------------------------------------------------------
func validateAndNormalize(provider, eventID, rawStatus string, amount int64, currency string, rawTime string, reference string) (PaymentEvent, error) {
	// 1. التحقق من المبلغ (يجب أن يكون أكبر من صفر)
	if amount <= 0 {
	 return PaymentEvent{}, ErrInvalidAmount
	}
	// 2. التحقق من العملة (ISO 4217 upper-case مكونة من 3 حروف)
	curr := strings.ToUpper(strings.TrimSpace(currency))
	if len(curr) != 3 {
	 return PaymentEvent{}, ErrInvalidCurrency
	}
	// 3. التحقق من وقت الحدوث (OccurredAt)
	t, err := time.Parse(time.RFC3339, rawTime)
	if err != nil {
	 return PaymentEvent{}, ErrInvalidTimestamp
	}
	// 4. توحيد الحالات (Status)
	statusLower := strings.ToLower(strings.TrimSpace(rawStatus))
	var normalizedStatus string
	switch statusLower {
	case "success", "paid", "completed", "succeeded":
	 normalizedStatus = "succeeded"
	case "failed", "failure", "declined":
	 normalizedStatus = "failed"
	default:
	 normalizedStatus = "failed"
	}
	return PaymentEvent{
	 Provider: provider,
	 EventID: eventID,
	 Status: normalizedStatus,
	 AmountCents: amount,
	 Currency: curr,
	 Reference: reference,
	 OccurredAt: t.UTC(),
	}, nil
}
func valueToString(v any) string {
	switch val := v.(type) {
	case string:
	 return val
	case float64:
	 if val == float64(int64(val)) {
	 return fmt.Sprintf("%d", int64(val))
	 }
	 return fmt.Sprintf("%f", val)
	case bool:
	 if val {
	 return "true"
	 }
	 return "false"
	default:
	 return fmt.Sprintf("%v", val)
	}
}
// مساعدة لتوليد توقيع Mada-Pay تجريبياً
func generateMadaSignature(body, secret string) string {
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(body))
	return "sha256=" + hex.EncodeToString(mac.Sum(nil))
}
// مساعدة لتوليد توقيع Pay-Line تجريبياً
func generatePayLineSignature(body, secret string) string {
	var data map\[string]any
	\_ = json.Unmarshal(\[]byte(body), \&data)
	delete(data, "sign")
	var keys \[]string
	for k := range data {
	 keys = append(keys, k)
	}
	sort.Strings(keys)
	var values \[]string
	for \_, k := range keys {
	 values = append(values, valueToString(data\[k]))
	}
	stringToSign := strings.Join(values, "\&")
	mac := hmac.New(sha256.New, \[]byte(secret))
	mac.Write(\[]byte(stringToSign))
	return hex.EncodeToString(mac.Sum(nil))
}
// ---------------------------------------------------------
// الدالة الرئيسية للتجربة (Main)
// ---------------------------------------------------------
func main() {
	madaSecret := "secret\_mada\_123"
	paylineSecret := "secret\_payline\_456"
	// 1. إشعار نجاح من Mada-Pay
	madaBody := `{"event\_id":"mp\_evt\_1001","status":"SUCCESS","amount\_cents":15000,"currency":"SAR","reference":"ORD-999","occurred\_at":"2026-10-29T10:00:00Z"}`
	madaSig := generateMadaSignature(madaBody, madaSecret)
	event1, err1 := ParseMadaPay(madaBody, madaSig, madaSecret)
	if err1 != nil {
	 fmt.Println("Error parsing MadaPay:", err1)
	}
	// 2. إشعار نجاح من Pay-Line (مع توليد التوقيع وحقنه في الجسم)
	paylineBodyTemplate := `{"amount":15000,"curr":"SAR","order\_ref":"ORD-999","sign":"%s","time":"2026-10-29T10:01:00Z","state":"completed","tx\_id":"pl\_txn\_5001"}`
	// لتوليد التوقيع، نحتاج أولاً وضع علامة مؤقتة أو بناء الخريطة وترتيبها
	// سنقوم بحساب التوقيع الحقيقي للقيم المرتبة أبجديامع المفاتيح: amount, curr, order\_ref, state, time, tx\_id
	plTempBody := `{"amount":15000,"curr":"SAR","order\_ref":"ORD-999","sign":"","time":"2026-10-29T10:01:00Z","state":"completed","tx\_id":"pl\_txn\_5001"}`
	plSig := generatePayLineSignature(plTempBody, paylineSecret)
	paylineBody := fmt.Sprintf(paylineBodyTemplate, plSig)
	event2, err2 := ParsePayLine(paylineBody, paylineSecret)
	if err2 != nil {
	 fmt.Println("Error parsing PayLine:", err2)
	}
	// 3. إشعار Pay-Line مكرر (نفس الـ EventID: pl\_txn\_5001)
	event3, err3 := ParsePayLine(paylineBody, paylineSecret)
	if err3 != nil {
	 fmt.Println("Error parsing duplicate PayLine:", err3)
	}
	// 4. إشعار بتوقيع تالف (سيفشل التحقق)
	\_, err4 := ParseMadaPay(madaBody, "sha256=badsignature123", madaSecret)
	fmt.Printf("Test Corrupted Signature (Expected Error): %v\\n\\n", err4)
	// 5. إشعار بمبلغ غير صالح (صفر أو سالب - سيفشل التحقق)
	badAmountBody := `{"event\_id":"mp\_evt\_1002","status":"SUCCESS","amount\_cents":0,"currency":"SAR","reference":"ORD-100","occurred\_at":"2026-10-29T10:05:00Z"}`
	badAmountSig := generateMadaSignature(badAmountBody, madaSecret)
	\_, err5 := ParseMadaPay(badAmountBody, badAmountSig, madaSecret)
	fmt.Printf("Test Invalid Amount (Expected Error): %v\\n\\n", err5)
	// تجميع الأحداث (بما فيها التكرار) وتطبيق دالة Dedupe
	rawEvents := \[]PaymentEvent{event1, event2, event3}
	dedupedEvents := Dedupe(rawEvents)
	// طباعة النتائج النهائية الموحدة
	fmt.Println("=== Final Deduped Payment Events ===")
	for i, ev := range dedupedEvents {
	 fmt.Printf("\[%d] Provider: %s | EventID: %s | Status: %s | Amount: %d %s | Ref: %s | Time: %s\\n",
	 i+1, ev.Provider, ev.EventID, ev.Status, ev.AmountCents, ev.Currency, ev.Reference, ev.OccurredAt.Format(time.RFC3339))
	}
}