diff --git a/cmd/hardlink/main.go b/cmd/hardlink/main.go
index c7429af..9aa0f85 100644
--- a/cmd/hardlink/main.go
+++ b/cmd/hardlink/main.go
@@ -33,7 +33,7 @@ import (
)
const (
- buildVersion = "v2.2.3"
+ buildVersion = "v2.2.4"
serviceName = "hardlink"
pollingFrequency = 8 * time.Second
)
diff --git a/internal/handlers/creditcall_diagnostics_test.go b/internal/handlers/creditcall_diagnostics_test.go
index 979acb1..46f4f35 100644
--- a/internal/handlers/creditcall_diagnostics_test.go
+++ b/internal/handlers/creditcall_diagnostics_test.go
@@ -41,6 +41,8 @@ type creditCallDiagnosticFixture struct {
initial, confirmation map[string]string
startFailure, confirmFailure string
confirmationXML string
+ emptyConfirmation bool
+ correctedConfirmation bool
recoverConfirmation bool
zero bool
reason, message string
@@ -150,18 +152,61 @@ func creditCallDiagnosticFixtures() []creditCallDiagnosticFixture {
fixtures = append(fixtures, creditCallDiagnosticFixture{name: "sale/confirmation_recovers/" + failure, operation: "sale",
initial: creditCallDiagnosticFields("APPROVED", ""), confirmFailure: failure, recoverConfirmation: true, message: "Payment approved"})
}
- for _, response := range []struct{ name, xml, reason, cause string }{
- {"omitted", "", "", ""},
- {"malformed_retains_approval", "", "", ""},
+ const approvedEntry = "TRANSACTION_RESULTAPPROVED"
+ const declinedEntry = "TRANSACTION_RESULTDECLINED"
+ const errorEntry = "TRANSACTION_RESULTERROR"
+ const emptyEntry = "TRANSACTION_RESULT"
+ for _, response := range []struct {
+ name, xml, reason, cause string
+ corrected bool
+ }{
+ {"mixed_case", "TRANSACTION_RESULTaPpRoVeD", "", "", false},
+ {"omitted", "", "confirmation_result_unknown", "ConfirmTransaction result unknown", true},
+ {"empty_body", "", "confirmation_invalid_response", "ConfirmTransaction response is invalid", true},
+ {"whitespace_body", " \r\n\t", "confirmation_invalid_response", "ConfirmTransaction response is invalid", true},
+ {"malformed_retains_approval", "", "confirmation_invalid_response", "ConfirmTransaction response is invalid", true},
+ {"malformed_after_approved", "" + approvedEntry + "", "confirmation_invalid_response", "ConfirmTransaction response is invalid", true},
{"malformed_after_error", "TRANSACTION_RESULTERROR",
- "confirmation_invalid_response", "ConfirmTransaction response is invalid"},
+ "confirmation_invalid_response", "ConfirmTransaction response is invalid", false},
+ {"malformed_after_declined", "" + declinedEntry + "", "confirmation_invalid_response", "ConfirmTransaction response is invalid", false},
+ {"wrong_root", "", "confirmation_invalid_response", "ConfirmTransaction response is invalid", true},
+ {"sdk_only_disconnected", "ERRORSClientNotConnectedToServer",
+ "confirmation_sdk_ClientNotConnectedToServer", "ConfirmTransaction: ClientNotConnectedToServer", true},
+ {"sdk_only_not_found", "ERRORSTransactionNotFound",
+ "confirmation_sdk_TransactionNotFound", "ConfirmTransaction: TransactionNotFound", true},
+ {"duplicate_approved_declined", "" + approvedEntry + declinedEntry + "",
+ "confirmation_result_declined", "ConfirmTransaction result declined", false},
+ {"duplicate_declined_approved", "" + declinedEntry + approvedEntry + "", "", "", false},
+ {"duplicate_error_approved", "" + errorEntry + approvedEntry + "", "", "", false},
+ {"duplicate_approved_empty", "" + approvedEntry + emptyEntry + "",
+ "confirmation_result_unknown", "ConfirmTransaction result unknown", false},
+ {"duplicate_empty_approved", "" + emptyEntry + approvedEntry + "", "", "", false},
+ {"duplicate_approved_error", "" + approvedEntry + errorEntry + "",
+ "confirmation_result_error", "ConfirmTransaction result error", false},
} {
message := "Payment approved"
if response.reason != "" {
message = "Payment outcome uncertain: " + response.cause + "; contact reception"
}
fixtures = append(fixtures, creditCallDiagnosticFixture{name: "sale/confirmation_xml/" + response.name, operation: "sale",
- initial: creditCallDiagnosticFields("APPROVED", "ChipCardRemoved"), confirmationXML: response.xml, reason: response.reason, message: message})
+ initial: creditCallDiagnosticFields("APPROVED", "ChipCardRemoved"), confirmationXML: response.xml,
+ emptyConfirmation: response.xml == "", correctedConfirmation: response.corrected, reason: response.reason, message: message})
+ }
+ for _, metadata := range []string{"returned_amount", "overrides", "empty_overrides"} {
+ fields := creditCallDiagnosticFields("APPROVED", "")
+ fields[types.TotalAmount] = "3100"
+ confirmation := map[string]string{types.TransactionResult: "APPROVED"}
+ if metadata == "overrides" {
+ confirmation[types.Reference], confirmation[types.TotalAmount] = "SYNTH-CONFIRMATION", "2500"
+ confirmation[types.CardType], confirmation[types.PanMasked] = "Mastercard", "************7788"
+ confirmation[types.ExpiryDate], confirmation[types.CardReference] = "1231", "synthetic-confirmation-card"
+ confirmation[types.ReceiptDataCardholder] = "synthetic confirmation receipt"
+ }
+ if metadata == "empty_overrides" {
+ confirmation[types.ExpiryDate], confirmation[types.CardHash], confirmation[types.ReceiptDataCardholder] = "", "", ""
+ }
+ fixtures = append(fixtures, creditCallDiagnosticFixture{name: "sale/confirmation_metadata/" + metadata, operation: "sale",
+ initial: fields, confirmation: confirmation, message: "Payment approved"})
}
for _, code := range []string{"ConfirmTransaction failed: SYNTHETIC-SECRET PAN=4111111111111111", "ChipCardRemoved,SYNTHETIC-SECRET", "500005", "chipcardremoved"} {
reason, cause := "confirmation_result_error", "ConfirmTransaction result error"
@@ -274,7 +319,7 @@ func captureCreditCallDiagnostic(t *testing.T, fixture creditCallDiagnosticFixtu
fields = map[string]string{types.TransactionResult: "APPROVED", types.ReceiptDataCardholder: "synthetic confirmation receipt"}
}
xmlBody := fixture.confirmationXML
- if xmlBody == "" {
+ if xmlBody == "" && !fixture.emptyConfirmation {
xmlBody = chipDNAFixture(t, fields)
}
body.Reader = strings.NewReader(xmlBody)
@@ -380,12 +425,17 @@ func captureCreditCallDiagnostic(t *testing.T, fixture creditCallDiagnosticFixtu
// the captured unmodified production source and the diagnostic implementation.
func TestCreditCallDiagnosticParityCapture(t *testing.T) {
observations := map[string]creditCallDiagnosticObservation{}
+ corrections := map[string]creditCallDiagnosticFixture{}
for _, fixture := range creditCallDiagnosticFixtures() {
+ if fixture.correctedConfirmation {
+ corrections[fixture.name] = fixture
+ corrections["legacy/"+fixture.name] = fixture
+ }
t.Run(fixture.name, func(t *testing.T) {
observations[fixture.name] = captureCreditCallDiagnostic(t, fixture, false)
})
}
- // Legacy responses and side effects must remain exactly unchanged too.
+ // Legacy observations use the same explicitly allowed correction cases.
for _, fixture := range creditCallDiagnosticFixtures() {
if fixture.startFailure != "" || fixture.zero || fixture.confirmFailure != "" {
continue
@@ -421,9 +471,20 @@ func TestCreditCallDiagnosticParityCapture(t *testing.T) {
t.Errorf("missing baseline fixture %q", name)
continue
}
- if want.Final != nil && got.Final != nil {
- want.Final.Reason, want.Final.Message = "", ""
- got.Final.Reason, got.Final.Message = "", ""
+ if fixture, corrected := corrections[name]; corrected {
+ if want.Final != nil {
+ if want.Final.Outcome != "approved" || want.Final.Retryable {
+ t.Fatalf("%s baseline=%+v, want the specifically identified false approval", name, want.Final)
+ }
+ want.Final = &paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "creditcall",
+ AmountMinor: 1234, CurrencyCode: "GBP", Reason: fixture.reason, Message: fixture.message}
+ } else {
+ if !strings.HasPrefix(want.Legacy.Data, "/successful?") {
+ t.Fatalf("%s baseline=%+v, want the specifically identified false success redirect", name, want.Legacy)
+ }
+ want.Legacy = &cmstypes.ResponseRec{Status: cmstypes.StatusRec{Code: http.StatusOK, Message: "unknown"},
+ Data: "/unsuccessful?Description=Transaction+unknown&MsgType=error"}
+ }
}
// SQL generates the transaction timestamp during each run. Its type,
// UTC location and range are asserted above; retain raw values in captures.
@@ -431,7 +492,7 @@ func TestCreditCallDiagnosticParityCapture(t *testing.T) {
want.Persistence["TxnDateTime"], got.Persistence["TxnDateTime"] = "validated current UTC time", "validated current UTC time"
}
if !reflect.DeepEqual(got, want) {
- t.Errorf("%s changed beyond diagnostic fields: got %+v, want %+v", name, got, want)
+ t.Errorf("%s changed beyond the exact approved correction: got %+v, want %+v", name, got, want)
}
}
}
@@ -489,12 +550,12 @@ func TestCreditCallDiagnosticEntryOrderAndOwnership(t *testing.T) {
}
}
-func TestCreditCallConfirmationSDKErrorWithoutResultKeepsLegacyApproval(t *testing.T) {
+func TestCreditCallConfirmationSDKErrorWithoutResultRemainsUncertain(t *testing.T) {
fixture := creditCallDiagnosticFixture{name: "sale/confirmation_sdk_without_result", operation: "sale",
- initial: creditCallDiagnosticFields("APPROVED", ""), confirmation: map[string]string{types.Errors: "TransactionNotFound"}}
+ initial: creditCallDiagnosticFields("APPROVED", ""), confirmation: map[string]string{types.Errors: "ClientNotConnectedToServer"}}
got := captureCreditCallDiagnostic(t, fixture, false)
- if got.Final.Outcome != "approved" || got.Final.Reason != "" || got.Final.TransactionReference != "SYNTH-STAGE2" || got.Final.AmountMinor != 1234 {
- t.Errorf("confirmation SDK error without TRANSACTION_RESULT final=%+v, want unchanged inherited approval and metadata", got.Final)
+ if got.Final.Outcome != "unknown" || got.Final.Retryable || got.Final.Reason != "confirmation_sdk_ClientNotConnectedToServer" || got.Final.TransactionReference != "" || got.Final.AmountMinor != 1234 {
+ t.Errorf("confirmation SDK error without TRANSACTION_RESULT final=%+v, want nonretryable uncertainty without approved-only metadata", got.Final)
}
if len(got.Requests) != 2 || !reflect.DeepEqual(got.Receipts, []string{"synthetic initial receipt"}) {
t.Errorf("confirmation SDK error without TRANSACTION_RESULT requests/receipts=%v/%v, want one start, one confirmation and inherited receipt", got.Requests, got.Receipts)
diff --git a/internal/handlers/creditcall_sale.go b/internal/handlers/creditcall_sale.go
index 6381029..ea22a19 100644
--- a/internal/handlers/creditcall_sale.go
+++ b/internal/handlers/creditcall_sale.go
@@ -90,8 +90,8 @@ func (app *App) executeCreditCallSale(
return outcome
}
- // Intentionally reuse both records: XML appends confirmation entries, and
- // missing confirmation fields/receipts retain their existing legacy behavior.
+ // Reuse both records to preserve metadata and receipt merging. Only fresh
+ // confirmation entries can establish completion approval.
initialEntryCount := len(trResult.Entries)
parseErr := trResult.ParseTransactionResult(body)
if parseErr != nil {
@@ -99,7 +99,21 @@ func (app *App) executeCreditCallSale(
}
result.FillFromTransactionResult(trResult)
res = result.Fields[types.TransactionResult]
- if !strings.EqualFold(res, types.ResultApproved) {
+ confirmationEntries := trResult.Entries[initialEntryCount:]
+ var confirmationResult string
+ for _, entry := range confirmationEntries {
+ if entry.Key == types.TransactionResult {
+ confirmationResult = entry.Value
+ }
+ }
+ confirmationApproved := false
+ if parseErr == nil {
+ confirmationApproved = strings.EqualFold(confirmationResult, types.ResultApproved)
+ }
+ if !confirmationApproved {
+ if strings.EqualFold(res, types.ResultApproved) {
+ res = "unknown"
+ }
app.printCreditCallReceipt(result.CardholderReceipt)
desc := result.Fields[types.ErrorDescription]
if desc == "" {
@@ -109,10 +123,11 @@ func (app *App) executeCreditCallSale(
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Confirm result: "+res+" Description: "+desc)
outcome.HTTPStatus = http.StatusOK
outcome.Status = result.Status
+ outcome.Status.Message = res
outcome.Payment = result
outcome.FailureType = res
outcome.FailureDescription = result.Fields[types.Errors]
- outcome.confirmationDiagnostic = creditCallConfirmationResultDiagnostic(trResult.Entries[initialEntryCount:], parseErr != nil)
+ outcome.confirmationDiagnostic = creditCallConfirmationResultDiagnostic(confirmationEntries, parseErr != nil)
return outcome
}
diff --git a/internal/handlers/creditcall_sale_test.go b/internal/handlers/creditcall_sale_test.go
index a996bb5..2dbd570 100644
--- a/internal/handlers/creditcall_sale_test.go
+++ b/internal/handlers/creditcall_sale_test.go
@@ -219,8 +219,8 @@ func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) {
{"cancelled", "Cancelled", "", 0, false, "start receipt"},
{"timeout", "TIMEOUT", "", 0, false, "start receipt"},
{"confirmation declined", "Approved", "Declined", 1, false, "confirm receipt"},
- {"confirmation omissions", "Approved", "omitted", 1, true, "start receipt"},
- {"malformed confirmation", "Approved", "malformed", 1, true, "start receipt"},
+ {"confirmation omissions", "Approved", "omitted", 1, false, "start receipt"},
+ {"malformed confirmation", "Approved", "malformed", 1, false, "start receipt"},
} {
t.Run(test.name, func(t *testing.T) {
fields := map[string]string{types.TransactionResult: test.startResult, types.Reference: "native-ref",
@@ -314,6 +314,160 @@ func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) {
}
}
+func TestCreditCallFreshConfirmationResults(t *testing.T) {
+ fixtures := map[string]creditCallDiagnosticFixture{}
+ for _, fixture := range creditCallDiagnosticFixtures() {
+ fixtures[fixture.name] = fixture
+ }
+ for _, tc := range []struct {
+ name, outcome string
+ amount int64
+ }{
+ {"confirmation_xml/mixed_case", "approved", 1234},
+ {"confirmation_xml/omitted", "unknown", 1234},
+ {"confirmation_xml/empty_body", "unknown", 1234},
+ {"confirmation_xml/whitespace_body", "unknown", 1234},
+ {"confirmation_xml/malformed_retains_approval", "unknown", 1234},
+ {"confirmation_xml/malformed_after_approved", "unknown", 1234},
+ {"confirmation_xml/malformed_after_error", "unknown", 1234},
+ {"confirmation_xml/malformed_after_declined", "unknown", 1234},
+ {"confirmation_xml/wrong_root", "unknown", 1234},
+ {"confirmation_xml/sdk_only_disconnected", "unknown", 1234},
+ {"confirmation_xml/sdk_only_not_found", "unknown", 1234},
+ {"confirmation_xml/duplicate_approved_declined", "unknown", 1234},
+ {"confirmation_xml/duplicate_declined_approved", "approved", 1234},
+ {"confirmation_xml/duplicate_error_approved", "approved", 1234},
+ {"confirmation_xml/duplicate_approved_empty", "unknown", 1234},
+ {"confirmation_xml/duplicate_empty_approved", "approved", 1234},
+ {"confirmation_xml/duplicate_approved_error", "unknown", 1234},
+ {"confirmation_result/DECLINED", "unknown", 1234},
+ {"confirmation_result/ERROR", "unknown", 1234},
+ {"confirmation_result/CANCELLED", "unknown", 1234},
+ {"confirmation_result/CANCELED", "unknown", 1234},
+ {"confirmation_result/TIMEOUT", "unknown", 1234},
+ {"confirmation_result/UNKNOWN", "unknown", 1234},
+ {"confirmation_result/", "unknown", 1234},
+ {"confirmation_metadata/returned_amount", "approved", 3100},
+ {"confirmation_metadata/overrides", "approved", 2500},
+ {"confirmation_metadata/empty_overrides", "approved", 3100},
+ } {
+ for _, legacy := range []bool{false, true} {
+ mode := "modern"
+ if legacy {
+ mode = "legacy"
+ }
+ t.Run(mode+"/"+tc.name, func(t *testing.T) {
+ fixture, ok := fixtures["sale/"+tc.name]
+ if !ok {
+ t.Fatalf("missing confirmation fixture %q", tc.name)
+ }
+ got := captureCreditCallDiagnostic(t, fixture, legacy)
+ if len(got.Requests) != 2 {
+ t.Fatalf("Sale(%s) requests=%+v, want one start and one confirmation", tc.name, got.Requests)
+ }
+ if got.HTTPStatus != http.StatusOK || got.Requests[1].Path != "/confirm-transaction/" {
+ t.Errorf("Sale(%s) HTTP/requests=%d/%+v, want HTTP 200, one start and one confirmation", tc.name, got.HTTPStatus, got.Requests)
+ }
+ for _, request := range got.Requests {
+ if !request.FreshCallDeadline || request.Method != http.MethodPost {
+ t.Errorf("Sale(%s) request=%+v, want POST with an independent 300-second timeout", tc.name, request)
+ }
+ }
+ var confirmation creditcall.ConfirmTransactionRequest
+ if err := xml.Unmarshal([]byte(got.Requests[1].Body), &confirmation); err != nil {
+ t.Fatal(err)
+ }
+ if confirmation.Amount != "1234" || confirmation.Reference != "SYNTH-STAGE2" {
+ t.Errorf("Sale(%s) confirmation=%+v, want the original requested amount and authorization reference", tc.name, confirmation)
+ }
+ if legacy {
+ if strings.HasPrefix(got.Legacy.Data, "/successful?") != (tc.outcome == "approved") {
+ t.Errorf("Sale(%s) legacy=%+v, want success only for fresh approval", tc.name, got.Legacy)
+ }
+ if fixture.correctedConfirmation && (got.Legacy.Status.Code != http.StatusOK || got.Legacy.Status.Message != "unknown" || got.Legacy.Data != "/unsuccessful?Description=Transaction+unknown&MsgType=error") {
+ t.Errorf("Sale(%s) legacy=%+v, want unchanged status code and explicit uncertainty failure response", tc.name, got.Legacy)
+ }
+ } else if got.Final.Outcome != tc.outcome || got.Final.Retryable || got.Final.HTTPStatus != http.StatusOK || got.Final.AmountMinor != tc.amount || got.Final.Reason != fixture.reason || got.Final.Message != fixture.message {
+ t.Errorf("Sale(%s) final=%+v, want %s/nonretryable/HTTP200/amount%d and %q/%q", tc.name, got.Final, tc.outcome, tc.amount, fixture.reason, fixture.message)
+ }
+ wantReceipt := "synthetic initial receipt"
+ if tc.name == "confirmation_metadata/overrides" {
+ wantReceipt = "synthetic confirmation receipt"
+ }
+ if tc.name == "confirmation_metadata/empty_overrides" {
+ wantReceipt = ""
+ }
+ if !reflect.DeepEqual(got.Receipts, []string{wantReceipt}) || got.PersistenceCount != 0 {
+ t.Errorf("Sale(%s) receipts/persistence=%v/%d, want [%q]/0", tc.name, got.Receipts, got.PersistenceCount, wantReceipt)
+ }
+ })
+ }
+ }
+}
+
+func TestCreditCallSaleConfirmationPreservesMergedFields(t *testing.T) {
+ for _, tc := range []struct {
+ name, rawXML, receipt string
+ confirmation map[string]string
+ approved bool
+ }{
+ {name: "minimal approval", confirmation: map[string]string{types.TransactionResult: "APPROVED"}, receipt: "synthetic initial receipt", approved: true},
+ {name: "confirmation overrides", confirmation: map[string]string{types.TransactionResult: "APPROVED", types.Reference: "SYNTH-CONFIRMED", types.TotalAmount: "2500", types.CardHash: "", types.ReceiptDataCardholder: "synthetic confirmation receipt"}, receipt: "synthetic confirmation receipt", approved: true},
+ {name: "SDK-only uncertainty", confirmation: map[string]string{types.Errors: "ClientNotConnectedToServer"}, receipt: "synthetic initial receipt"},
+ {name: "partial approved XML", rawXML: "TRANSACTION_RESULTAPPROVED", receipt: "synthetic initial receipt"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ initial := creditCallDiagnosticFields("APPROVED", "")
+ initial[types.TotalAmount] = "3100"
+ initial["AUTH_DATE_TIME"], initial["CARDEASE_REFERENCE"] = "20300101120000", "synthetic-authorization"
+ expected := map[string]string{}
+ for key, value := range initial {
+ if key != types.ReceiptDataCardholder {
+ expected[key] = value
+ }
+ }
+ for key, value := range tc.confirmation {
+ if key != types.ReceiptDataCardholder {
+ expected[key] = value
+ }
+ }
+ var receipts []string
+ starts, confirms := 0, 0
+ body := &creditCallDiagnosticBody{}
+ app := &App{cfg: &config.ConfigRec{}, creditCallReceipt: func(receipt string) { receipts = append(receipts, receipt) }}
+ app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
+ confirms++
+ if r.URL.Path != "/confirm-transaction/" {
+ t.Errorf("unexpected confirmation path %q", r.URL.Path)
+ }
+ wire := tc.rawXML
+ if wire == "" {
+ wire = chipDNAFixture(t, tc.confirmation)
+ }
+ body.Reader = strings.NewReader(wire)
+ return &http.Response{StatusCode: http.StatusOK, Body: body}, nil
+ })
+ outcome := app.executeCreditCallSale(cmstypes.TransactionRec{AmountMinorUnits: "1234"}, func(*http.Client) (creditcall.TransactionResultXML, error) {
+ starts++
+ var result creditcall.TransactionResultXML
+ for key, value := range initial {
+ result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value})
+ }
+ return result, nil
+ })
+ if outcome.Approved != tc.approved || !reflect.DeepEqual(outcome.Payment.Fields, expected) || outcome.Payment.CardholderReceipt != tc.receipt {
+ t.Errorf("Sale(%s) approved/fields/receipt=%t/%v/%q, want %t/%v/%q", tc.name, outcome.Approved, outcome.Payment.Fields, outcome.Payment.CardholderReceipt, tc.approved, expected, tc.receipt)
+ }
+ if !tc.approved && (outcome.Status.Message != "unknown" || outcome.FailureType != "unknown" || outcome.Payment.Status.Message != "APPROVED") {
+ t.Errorf("Sale(%s) status/failure/payment status=%+v/%q/%+v, want uncertainty without mutating merged authorization evidence", tc.name, outcome.Status, outcome.FailureType, outcome.Payment.Status)
+ }
+ if starts != 1 || confirms != 1 || !body.closed || !reflect.DeepEqual(receipts, []string{tc.receipt}) {
+ t.Errorf("Sale(%s) starts/confirms/closed/receipts=%d/%d/%t/%v, want 1/1/true/[%q]", tc.name, starts, confirms, body.closed, receipts, tc.receipt)
+ }
+ })
+ }
+}
+
func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) {
for _, streaming := range []bool{false, true} {
var attempts int
diff --git a/release notes.md b/release notes.md
index 8929d5c..9a702b6 100644
--- a/release notes.md
+++ b/release notes.md
@@ -2,6 +2,9 @@
`buildVersion` is a const in `cmd/hardlink/main.go`.
+#### v2.2.4 - 05 November 2026
+fix(creditcall): require fresh confirmation approval for sale
+
#### v2.2.3 - 05 November 2026
fix(creditcall): preserve detailed SDK failure diagnostics