Replace unmaintained bincode with binary-compatible wincode

This replaces the unmaintained bincode serialization library with wincode,
which produces identical byte output while being actively maintained.

Key changes:
- Replace bincode dependency with wincode in all Cargo.toml files
- Update Value enum derives from Serialize/Deserialize to also include
  SchemaWrite/SchemaRead (keeping both for compatibility)
- Replace bincode::serialize() calls with wincode::serialize()
- Replace bincode::deserialize() calls with wincode::deserialize()
- Update error handling for wincode::WriteError and wincode::ReadError
- Update protobuf documentation to note wincode (binary compatible with bincode)

The wire protocol remains unchanged as wincode produces byte-for-byte
identical output to bincode, maintaining compatibility with existing
Go clients and other consumers of the RPC protocol.

Author: Drew Robinson

Cargo.lock

@@ -29,7 +29,7 @@ cbc = "0.1.2"
 
 [dev-dependencies]
 arbitrary = { version = "1.3.0", features = ["derive_arbitrary"] }
-bincode = "1.3.3"
+wincode = { version = "0.2", features = ["derive"] }
 tempfile = "3.8.0"
 prost-build = "0.12"
 tonic-build = "0.11"

libsql-replication/Cargo.toml

@@ -71,7 +71,7 @@ message Description {
 }
 
 message Value {
-    /// bincode encoded Value
+    /// wincode encoded Value (binary compatible with bincode)
     bytes data = 1;
 }
 

libsql-replication/proto/proxy.proto

@@ -18,7 +18,7 @@ async-trait = "0.1.58"
 axum = { version = "0.6.18", features = ["headers"] }
 axum-extra = { version = "0.7", features = ["json-lines", "query"] }
 base64 = "0.21.0"
-bincode = "1.3.3"
+wincode = { version = "0.2", features = ["derive"] }
 bottomless = { version = "0", path = "../bottomless", features = ["libsql_linked_statically"] }
 bytes = { version = "1.2.1", features = ["serde"] }
 bytesize = { version = "1.2.0", features = ["serde"] }

libsql-server/Cargo.toml

@@ -244,8 +244,14 @@ impl From<tokio::sync::oneshot::error::RecvError> for Error {
     }
 }
 
-impl From<bincode::Error> for Error {
-    fn from(other: bincode::Error) -> Self {
+impl From<wincode::WriteError> for Error {
+    fn from(other: wincode::WriteError) -> Self {
+        Self::Internal(other.to_string())
+    }
+}
+
+impl From<wincode::ReadError> for Error {
+    fn from(other: wincode::ReadError) -> Self {
         Self::Internal(other.to_string())
     }
 }

libsql-server/src/error.rs

@@ -4,11 +4,12 @@ use anyhow::{anyhow, ensure, Context};
 use rusqlite::types::{ToSqlOutput, ValueRef};
 use rusqlite::ToSql;
 use serde::{Deserialize, Serialize};
+use wincode::{SchemaWrite, SchemaRead};
 
 use crate::query_analysis::Statement;
 
 /// Mirrors rusqlite::Value, but implement extra traits
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, SchemaWrite, SchemaRead)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 pub enum Value {
     Null,

libsql-server/src/query.rs

@@ -99,7 +99,7 @@ pub mod rpc {
                 crate::query::Params::Named(params) => {
                     let iter = params.into_iter().map(|(k, v)| -> Result<_, SqldError> {
                         let v = Value {
-                            data: bincode::serialize(&v)?,
+                            data: wincode::serialize(&v)?,
                         };
                         Ok((k, v))
                     });
@@ -111,7 +111,7 @@ pub mod rpc {
                         .iter()
                         .map(|v| {
                             Ok(Value {
-                                data: bincode::serialize(&v)?,
+                                data: wincode::serialize(&v)?,
                             })
                         })
                         .collect::<Result<Vec<_>, SqldError>>()?;
@@ -130,12 +130,12 @@ pub mod rpc {
                     let params = pos
                         .values
                         .into_iter()
-                        .map(|v| bincode::deserialize(&v.data).map_err(|e| e.into()))
+                        .map(|v| wincode::deserialize(&v.data).map_err(|e| e.into()))
                         .collect::<Result<Vec<_>, SqldError>>()?;
                     Ok(Self::Positional(params))
                 }
                 query::Params::Named(named) => {
-                    let values = named.values.iter().map(|v| bincode::deserialize(&v.data));
+                    let values = named.values.iter().map(|v| wincode::deserialize(&v.data));
                     let params = itertools::process_results(values, |values| {
                         named.names.into_iter().zip(values).collect()
                     })?;
@@ -455,7 +455,7 @@ impl QueryResultBuilder for ExecuteResultsBuilder {
     }
 
     fn add_row_value(&mut self, v: ValueRef) -> Result<(), QueryResultBuilderError> {
-        let data = bincode::serialize(
+        let data = wincode::serialize(
             &crate::query::Value::try_from(v).map_err(QueryResultBuilderError::from_any)?,
         )
         .map_err(QueryResultBuilderError::from_any)?;

libsql-server/src/rpc/proxy.rs

@@ -27,7 +27,7 @@ bitflags = { version = "2.4.0", optional = true }
 tower = { workspace = true, features = ["util"], optional = true }
 worker = { version = "0.6.7", optional = true }
 
-bincode = { version = "1", optional = true }
+wincode = { version = "0.2", optional = true, features = ["derive"] }
 anyhow = { version = "1.0.71", optional = true }
 bytes = { version = "1.4.0", features = ["serde"], optional = true }
 uuid = { version = "1.4.0", features = ["v4", "serde"], optional = true }
@@ -83,7 +83,7 @@ replication = [
   "dep:http",
   "dep:tokio",
   "dep:anyhow",
-  "dep:bincode",
+  "dep:wincode",
   "dep:zerocopy",
   "dep:bytes",
   "dep:uuid",

libsql/Cargo.toml

@@ -31,8 +31,8 @@ pub enum Error {
     Hrana(crate::BoxError), // Not in rusqlite
     #[error("Write delegation: `{0}`")]
     WriteDelegation(crate::BoxError), // Not in rusqlite
-    #[error("bincode: `{0}`")]
-    Bincode(crate::BoxError),
+    #[error("wincode: `{0}`")]
+    Wincode(crate::BoxError),
     #[error("invalid column index")]
     InvalidColumnIndex,
     #[error("invalid column type")]
@@ -112,8 +112,15 @@ pub fn sqlite_errmsg_to_string(errmsg: *const std::ffi::c_char) -> String {
 }
 
 #[cfg(feature = "replication")]
-impl From<bincode::Error> for Error {
-    fn from(e: bincode::Error) -> Self {
-        Error::Bincode(e.into())
+impl From<wincode::WriteError> for Error {
+    fn from(e: wincode::WriteError) -> Self {
+        Error::Wincode(e.into())
+    }
+}
+
+#[cfg(feature = "replication")]
+impl From<wincode::ReadError> for Error {
+    fn from(e: wincode::ReadError) -> Self {
+        Error::Wincode(e.into())
     }
 }

libsql/src/errors.rs

@@ -291,7 +291,7 @@ impl From<Params> for libsql_replication::rpc::proxy::query::Params {
             Params::Positional(values) => {
                 let values = values
                     .iter()
-                    .map(|v| bincode::serialize(v).unwrap())
+                    .map(|v| wincode::serialize(v).unwrap())
                     .map(|data| proxy::Value { data })
                     .collect::<Vec<_>>();
                 proxy::query::Params::Positional(proxy::Positional { values })
@@ -300,7 +300,7 @@ impl From<Params> for libsql_replication::rpc::proxy::query::Params {
                 let (names, values) = values
                     .into_iter()
                     .map(|(name, value)| {
-                        let data = bincode::serialize(&value).unwrap();
+                        let data = wincode::serialize(&value).unwrap();
                         let value = proxy::Value { data };
                         (name, value)
                     })