[#1129] feat: soroban contract and sdk feature SC-24 (#1209)

Implements the tagged event indexing feature (SC-24) across all three
layers of the SoroScan stack.

## Soroban Contract (soroban-contracts/soroscan_core)
- Added TaggedEventRecord struct with a 	ags: Vec<Symbol> field
  (max 4 tags, enforced on-chain)
- Added DataKey::LatestTaggedByType(Symbol) storage key so tagged
  events occupy a slot independent of the legacy EventRecord slot
- Added MAX_TAGS = 4 constant and ContractError::TooManyTags variant
- Added 
ecord_tagged_event() entry-point (auth-gated to registered
  indexers) that validates the tag count, stores the record, increments
  the global counter, and emits a (soroscan, sc24, event_type) event
- Added latest_tagged_by_type() read-only entry-point
- Added 6 unit tests covering: happy-path, empty tags, too-many-tags
  rejection, unauthorized indexer rejection, None-before-first-event,
  and legacy/tagged storage independence

## Python SDK (sdk/python)
- Added TaggedEventRequest and TaggedEventResponse Pydantic models
  with a ≤4 tag validator
- Added 
ecord_tagged_event() (sync) and async counterpart to both
  SoroScanClient and AsyncSoroScanClient
- Exported new models from soroscan/__init__.py
- Added 	ests/test_sc24_tagged_event.py with 16 unit tests covering
  sync, async (asyncio + trio), error propagation, and model validation

## TypeScript SDK (sdk/typescript)
- Added RecordTaggedEventParams, RecordTaggedEventResponse, and
  MAX_TAGS constant to 	ypes.ts
- Added GetEventsByContractsParams/Response (SC-23) and
  RecordStructuredEventParams/Response (SC-38) to 	ypes.ts so that
  all cross-feature imports resolve on this branch
- Added 
ecordTaggedEvent() and getEventsByContracts() methods to
  SoroScanClient
- Exported all new types from index.ts
- Added 	est/sc24-tagged-event.test.ts (2 unit tests: serialization
  and default empty-tag behaviour)
- Build (
pm run build) and all tests (46 passed) are green

## Documentation
- Added Tagged Events (SC-24) example snippet to docs/sdk-python.md
- Added Tagged Events (SC-24) example snippet to docs/sdk-typescript.md

Closes #1129

Author: She-ge

docs/sdk-python.md

@@ -44,9 +44,24 @@ async def main():
 
 asyncio.run(main())
 ```
+### Tagged Events (SC-24)
+
+SoroScan supports recording and indexing events with up to 4 producer-defined tags. This allows off-chain indexers to categorize and filter events efficiently:
+
+```python
+# Submit a tagged event
+response = client.record_tagged_event(
+    contract_id="CCAAA...",
+    event_type="transfer",
+    payload_hash="a" * 64,
+    tags=["defi", "token"]
+)
+print(f"Status: {response.status} | Echoed Tags: {response.tags}")
+```
 
 ## Features
 
+
 - **Type Safety**: Built with Pydantic v2 for robust data validation.
 - **Full Coverage**: 100% endpoint coverage for Contracts, Events, and Webhooks.
 - **Async Support**: Native support for `httpx` async clients.

docs/sdk-typescript.md

@@ -62,9 +62,24 @@ do {
   after = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
 } while (after);
 ```
+### Tagged Events (SC-24)
+
+You can submit events classified by up to 4 tags to support efficient event category indexing:
+
+```typescript
+const response = await client.recordTaggedEvent({
+  contractId: "CCAAA...",
+  eventType: "transfer",
+  payloadHash: "a".repeat(64),
+  tags: ["defi", "token"],
+});
+
+console.log(`Status: ${response.status}, tags: ${response.tags.join(", ")}`);
+```
 
 ## Features
 
+
 - **Strict Typing**: Full TypeScript support for all request and response shapes.
 - **Zero Dependencies**: Uses native `fetch` API for a minimal footprint.
 - **Dual Build**: Supports both ESM and CJS modules.

sdk/python/soroscan/client.py

@@ -463,8 +463,65 @@ def record_event(
             payload_hash=payload_hash,
         )
         response = self._client.post(url, headers=self._get_headers(), json=request.model_dump())
-        data = self._handle_response(response)
-        return RecordEventResponse.model_validate(data)
+        return RecordEventResponse.model_validate(self._handle_response(response))
+
+    def record_structured_event(
+        self,
+        contract_id: str,
+        event_type: str,
+        payload_hash: str,
+        schema_version: int,
+        correlation_id: str,
+    ) -> RecordEventResponse:
+        """Submit an idempotent SC-38 structured event."""
+        request = StructuredEventRequest(
+            contract_id=contract_id,
+            event_type=event_type,
+            payload_hash=payload_hash,
+            schema_version=schema_version,
+            correlation_id=correlation_id,
+        )
+        response = self._client.post(
+            urljoin(self.base_url, "/api/record/structured/"),
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+        return RecordEventResponse.model_validate(self._handle_response(response))
+
+    def record_tagged_event(
+        self,
+        contract_id: str,
+        event_type: str,
+        payload_hash: str,
+        tags: list[str] | None = None,
+    ) -> TaggedEventResponse:
+        """Submit an SC-24 tagged event.
+
+        Tags are short producer-defined classification strings that allow
+        off-chain indexers to filter events without decoding the full payload.
+        At most 4 tags may be supplied per event.
+
+        Args:
+            contract_id: Target contract address
+            event_type: Event type name
+            payload_hash: SHA-256 hash of payload (hex)
+            tags: Up to 4 classification tag strings (default: empty list)
+
+        Returns:
+            TaggedEventResponse with submission status and echoed tags
+        """
+        request = TaggedEventRequest(
+            contract_id=contract_id,
+            event_type=event_type,
+            payload_hash=payload_hash,
+            tags=tags or [],
+        )
+        response = self._client.post(
+            urljoin(self.base_url, "/api/record/tagged/"),
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+        return TaggedEventResponse.model_validate(self._handle_response(response))
 
     def add_indexer(self, indexer_address: str) -> AddIndexerResponse:
         """