feat: Add RPCs for statement (#500)

Introduce a new `statement` module in the Rust SDK providing:
- `StatementContext` for querying account statement data
- `GET /v1/statement/list` to retrieve statement data list
(daily/monthly)
- `GET /v1/statement/download` to get statement file download URLs
- Comprehensive deserialization types for statement content (member
info,
  asset, equity holdings, trades, fees, corporate actions, etc.)

Also add `LONGBRIDGE_TEST_ENV` environment variable support in the OAuth
client to route requests to the test environment (`longbridge.xyz`).

---------

Co-authored-by: geomantic <lei.zhong@longbridge-inc.com>

Author: ZGeomantic

c/csrc/include/longbridge.h

@@ -1278,6 +1278,11 @@ typedef enum lb_granularity_t {
   GranularityMonthly,
 } lb_granularity_t;
 
+/**
+ * Asset context
+ */
+typedef struct CAssetContext CAssetContext;
+
 /**
  * Configuration options for Longbridge SDK
  */
@@ -4107,6 +4112,54 @@ typedef struct lb_news_item_t {
 extern "C" {
 #endif // __cplusplus
 
+/**
+ * Create a new `AssetContext`
+ *
+ * @param config  Config object
+ * @return A new asset context
+ */
+const struct CAssetContext *lb_asset_context_new(const struct lb_config_t *config);
+
+/**
+ * Retain the asset context (increment reference count)
+ */
+void lb_asset_context_retain(const struct CAssetContext *ctx);
+
+/**
+ * Release the asset context (decrement reference count)
+ */
+void lb_asset_context_release(const struct CAssetContext *ctx);
+
+/**
+ * Get statement data list
+ *
+ * @param ctx             Asset context
+ * @param statement_type  1 = daily, 2 = monthly
+ * @param start_date      Start date for pagination (0 = default)
+ * @param limit           Number of results (0 = default 20)
+ * @param callback        Async callback
+ * @param userdata        User data passed to the callback
+ */
+void lb_asset_context_statements(const struct CAssetContext *ctx,
+                                 int32_t statement_type,
+                                 int32_t start_date,
+                                 int32_t limit,
+                                 lb_async_callback_t callback,
+                                 void *userdata);
+
+/**
+ * Get statement data download URL
+ *
+ * @param ctx       Asset context
+ * @param file_key  File key from the list response
+ * @param callback  Async callback
+ * @param userdata  User data passed to the callback
+ */
+void lb_asset_context_download_url(const struct CAssetContext *ctx,
+                                   const char *file_key,
+                                   lb_async_callback_t callback,
+                                   void *userdata);
+
 /**
  * Create a new `Config` using API Key authentication
  *

c/src/asset_context/context.rs

@@ -0,0 +1,98 @@
+use std::{ffi::c_void, os::raw::c_char, sync::Arc};
+
+use longbridge::asset::{
+    AssetContext, GetStatementListOptions, GetStatementOptions, StatementType,
+};
+
+use crate::{
+    asset_context::types::CStatementItemOwned,
+    async_call::{CAsyncCallback, execute_async},
+    config::CConfig,
+    types::{CString, CVec, cstr_to_rust},
+};
+
+/// Asset context
+pub struct CAssetContext {
+    ctx: AssetContext,
+}
+
+/// Create a new `AssetContext`
+///
+/// @param config  Config object
+/// @return A new asset context
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn lb_asset_context_new(config: *const CConfig) -> *const CAssetContext {
+    let config = Arc::new((*config).0.clone());
+    let ctx = AssetContext::new(config);
+    Arc::into_raw(Arc::new(CAssetContext { ctx }))
+}
+
+/// Retain the asset context (increment reference count)
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn lb_asset_context_retain(ctx: *const CAssetContext) {
+    Arc::increment_strong_count(ctx);
+}
+
+/// Release the asset context (decrement reference count)
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn lb_asset_context_release(ctx: *const CAssetContext) {
+    let _ = Arc::from_raw(ctx);
+}
+
+/// Get statement data list
+///
+/// @param ctx             Asset context
+/// @param statement_type  1 = daily, 2 = monthly
+/// @param start_date      Start date for pagination (0 = default)
+/// @param limit           Number of results (0 = default 20)
+/// @param callback        Async callback
+/// @param userdata        User data passed to the callback
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn lb_asset_context_statements(
+    ctx: *const CAssetContext,
+    statement_type: i32,
+    start_date: i32,
+    limit: i32,
+    callback: CAsyncCallback,
+    userdata: *mut c_void,
+) {
+    let ctx_inner = (*ctx).ctx.clone();
+    let st = if statement_type == 2 {
+        StatementType::Monthly
+    } else {
+        StatementType::Daily
+    };
+    let mut opts = GetStatementListOptions::new(st);
+    if start_date > 0 {
+        opts = opts.page(start_date);
+    }
+    if limit > 0 {
+        opts = opts.page_size(limit);
+    }
+    execute_async(callback, ctx, userdata, async move {
+        let rows: CVec<CStatementItemOwned> = ctx_inner.statements(opts).await?.list.into();
+        Ok(rows)
+    });
+}
+
+/// Get statement data download URL
+///
+/// @param ctx       Asset context
+/// @param file_key  File key from the list response
+/// @param callback  Async callback
+/// @param userdata  User data passed to the callback
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn lb_asset_context_download_url(
+    ctx: *const CAssetContext,
+    file_key: *const c_char,
+    callback: CAsyncCallback,
+    userdata: *mut c_void,
+) {
+    let ctx_inner = (*ctx).ctx.clone();
+    let file_key = cstr_to_rust(file_key);
+    let opts = GetStatementOptions::new(file_key);
+    execute_async(callback, ctx, userdata, async move {
+        let url: CString = ctx_inner.statement_download_url(opts).await?.url.into();
+        Ok(url)
+    });
+}

c/src/asset_context/mod.rs

@@ -0,0 +1,2 @@
+mod context;
+mod types;

c/src/asset_context/types.rs

@@ -0,0 +1,39 @@
+use std::os::raw::c_char;
+
+use longbridge::asset::StatementItem;
+
+use crate::types::{CString, ToFFI};
+
+/// Statement item
+#[repr(C)]
+pub struct CStatementItem {
+    /// Statement date (integer, e.g. 20250301)
+    pub dt: i32,
+    /// File key
+    pub file_key: *const c_char,
+}
+
+#[derive(Debug)]
+pub(crate) struct CStatementItemOwned {
+    dt: i32,
+    file_key: CString,
+}
+
+impl From<StatementItem> for CStatementItemOwned {
+    fn from(item: StatementItem) -> Self {
+        Self {
+            dt: item.dt,
+            file_key: item.file_key.into(),
+        }
+    }
+}
+
+impl ToFFI for CStatementItemOwned {
+    type FFIType = CStatementItem;
+    fn to_ffi_type(&self) -> CStatementItem {
+        CStatementItem {
+            dt: self.dt,
+            file_key: self.file_key.to_ffi_type(),
+        }
+    }
+}

c/src/lib.rs

@@ -1,5 +1,6 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
+mod asset_context;
 mod async_call;
 mod callback;
 mod config;

cpp/include/asset_context.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "async_result.hpp"
+#include "callback.hpp"
+#include "config.hpp"
+#include "types.hpp"
+
+typedef struct lb_asset_context_t lb_asset_context_t;
+
+namespace longbridge {
+namespace asset {
+
+/// Statement item
+struct StatementItem
+{
+  /// Statement date (integer, e.g. 20250301)
+  int32_t dt;
+  /// File key
+  std::string file_key;
+};
+
+/// Statement download URL response
+struct StatementDownloadUrlResponse
+{
+  /// Presigned download URL
+  std::string url;
+};
+
+/// Asset context
+class AssetContext
+{
+private:
+  const lb_asset_context_t* ctx_;
+
+public:
+  AssetContext();
+  AssetContext(const lb_asset_context_t* ctx);
+  AssetContext(const AssetContext& ctx);
+  AssetContext(AssetContext&& ctx);
+  ~AssetContext();
+
+  AssetContext& operator=(const AssetContext& ctx);
+
+  static AssetContext create(const Config& config);
+
+  /// Get statement data list
+  void statements(
+    int32_t statement_type,
+    int32_t start_date,
+    int32_t limit,
+    AsyncCallback<AssetContext, std::vector<StatementItem>> callback) const;
+
+  /// Get statement data download URL
+  void statement_download_url(
+    const std::string& file_key,
+    AsyncCallback<AssetContext, StatementDownloadUrlResponse> callback)
+    const;
+};
+
+} // namespace asset
+} // namespace longbridge

cpp/include/longbridge.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "asset_context.hpp"
 #include "config.hpp"
 #include "decimal.hpp"
 #include "http_client.hpp"