fix: CometBFT height deserialization and SQLite write contention

CometBFT returns block height as a JSON string (e.g. "6294") but
cometCommitResponse.Height was typed as int64, causing unmarshal
failures and HTTP 500 on all /v1/memory/submit calls. Fixed with
the json:",string" tag.

Also added a write mutex to SQLiteStore.RunInTx to serialize write
transactions at the Go level, preventing SQLITE_BUSY errors when
concurrent DEFERRED transactions both escalate to write locks.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: l33tdawg

api/rest/handlers_test.go

@@ -307,7 +307,7 @@ func TestSubmitMemory(t *testing.T) {
 				"check_tx":  map[string]interface{}{"code": 0, "log": ""},
 				"tx_result": map[string]interface{}{"code": 0, "data": "", "log": "memory submitted"},
 				"hash":      "ABCDEF1234567890",
-				"height":    1,
+				"height":    "1",
 			},
 		})
 	}))

api/rest/memory_handler.go

@@ -127,7 +127,7 @@ type cometCommitResponse struct {
 			Log  string `json:"log"`
 		} `json:"tx_result"`
 		Hash   string `json:"hash"`
-		Height int64  `json:"height"`
+		Height int64  `json:"height,string"`
 	} `json:"result"`
 	Error *struct {
 		Code    int    `json:"code"`

internal/store/sqlite.go

@@ -38,6 +38,7 @@ type SQLiteStore struct {
 	vault             *vault.Vault // nil = no encryption
 	vaultExpected     bool         // true = encryption should be active; reject writes if vault nil
 	decryptWarnOnce   sync.Once    // gates the one-time decryption failure warning
+	writeMu           sync.Mutex   // serializes write transactions to prevent SQLITE_BUSY
 }
 
 // encPrefix marks content as encrypted (prepended to base64 ciphertext).
@@ -2473,6 +2474,11 @@ func (s *SQLiteStore) RunInTx(ctx context.Context, fn func(tx OffchainStore) err
 		// Already in a transaction — execute directly.
 		return fn(s)
 	}
+	// Serialize write transactions at the Go level to prevent SQLITE_BUSY.
+	// SQLite's busy_timeout handles statement-level contention, but concurrent
+	// DEFERRED transactions that both escalate to write locks can still fail.
+	s.writeMu.Lock()
+	defer s.writeMu.Unlock()
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
 		return fmt.Errorf("begin tx: %w", err)