@wireio/protoc-gen-solana 1.0.1

package/lib/util/names.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Convert a protobuf fully-qualified name to a Rust-safe identifier (PascalCase struct name).
+ * e.g. "my_package.MyMessage" → "MyMessage"
+ */
+export declare function protoNameToRust(fqn: string): string;
+/**
+ * Keep snake_case field name as-is for Rust struct members.
+ * e.g. "user_name" → "user_name"
+ * Only converts camelCase → snake_case if needed.
+ */
+export declare function toSnakeCase(name: string): string;
+/**
+ * Generate output .rs filename for a given .proto file, optionally rooted
+ * under a directory derived from the proto package name.
+ * e.g. "my_service.proto" with package "example.nested"
+ *      → "example/nested/my_service.pb.rs"
+ */
+export declare function protoFileToRsFile(protoFile: string, packageName?: string): string;
+//# sourceMappingURL=names.d.ts.map

package/lib/util/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/util/names.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAYjF"}

package/lib/util/names.js

@@ -0,0 +1,38 @@
+/**
+ * Convert a protobuf fully-qualified name to a Rust-safe identifier (PascalCase struct name).
+ * e.g. "my_package.MyMessage" → "MyMessage"
+ */
+export function protoNameToRust(fqn) {
+    const parts = fqn.split(".");
+    return parts[parts.length - 1];
+}
+/**
+ * Keep snake_case field name as-is for Rust struct members.
+ * e.g. "user_name" → "user_name"
+ * Only converts camelCase → snake_case if needed.
+ */
+export function toSnakeCase(name) {
+    // Already snake_case in proto, but handle camelCase just in case
+    return name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+/**
+ * Generate output .rs filename for a given .proto file, optionally rooted
+ * under a directory derived from the proto package name.
+ * e.g. "my_service.proto" with package "example.nested"
+ *      → "example/nested/my_service.pb.rs"
+ */
+export function protoFileToRsFile(protoFile, packageName) {
+    const base = protoFile.replace(/\.proto$/, "");
+    const parts = base.split("/");
+    const filename = parts[parts.length - 1];
+    // Rust files use snake_case
+    const snakeFilename = filename
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+    const rsBasename = `${snakeFilename}.pb.rs`;
+    if (!packageName)
+        return rsBasename;
+    const dir = packageName.split(".").join("/");
+    return `${dir}/${rsBasename}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@wireio/protoc-gen-solana",
+  "version": "1.0.1",
+  "description": "protoc plugin generating Rust encode/decode modules from protobuf3 definitions for Solana programs",
+  "private": false,
+  "type": "module",
+  "types": "lib/index.d.ts",
+  "module": "dist/bundle/protoc-gen-solana.mjs",
+  "bin": {
+    "protoc-gen-solana": "dist/bundle/protoc-gen-solana.mjs"
+  },
+  "pkg": {
+    "assets": [
+      "rs/**/*"
+    ]
+  },
+  "files": [
+    "lib",
+    "dist/bundle",
+    "rs",
+    "README.md"
+  ],
+  "dependencies": {
+    "protobufjs": "^8.0.0",
+    "tracer": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "@yao-pkg/pkg": "^6.14.1",
+    "esbuild": "^0.27.3",
+    "prettier": "^3.8.1",
+    "protoc": "^29.6.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "build:dev": "tsc -b tsconfig.json -w",
+    "bundle": "node esbuild.config.js",
+    "bundle:dev": "node esbuild.config.js -w",
+    "dev": "concurrently npm:build:dev npm:bundle:dev",
+    "dist": "pnpm build && pnpm bundle && pkg -c package.json --output dist/bin/protoc-gen-solana -d --options experimental-require-module dist/bundle/protoc-gen-solana.mjs",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "generate:test": "npm run dist && mkdir -p ./dist/tests/generated && npx protoc --plugin=protoc-gen-solana=$PWD/dist/bin/protoc-gen-solana --solana_out=./dist/tests/generated tests/protos/*.proto",
+    "clean": "rm -rf lib dist"
+  }
+}

package/rs/protobuf_runtime.rs

@@ -0,0 +1,352 @@
+// Shared protobuf3 wire format primitives for protoc-gen-solana.
+// This file is also emitted by the plugin alongside generated codecs.
+//
+// Optimized for Solana's compute budget: minimal allocations,
+// no unnecessary copies, and efficient varint handling.
+
+use std::fmt;
+
+// ── Error type ───────────────────────────────────────────────────────
+
+#[derive(Debug, Clone)]
+pub enum DecodeError {
+    BufferOverflow,
+    InvalidVarint,
+    UnknownWireType(u64),
+    InvalidData(&'static str),
+}
+
+impl fmt::Display for DecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DecodeError::BufferOverflow => write!(f, "protobuf: buffer overflow"),
+            DecodeError::InvalidVarint => write!(f, "protobuf: invalid varint"),
+            DecodeError::UnknownWireType(wt) => write!(f, "protobuf: unknown wire type {}", wt),
+            DecodeError::InvalidData(msg) => write!(f, "protobuf: {}", msg),
+        }
+    }
+}
+
+// ── Key (tag) encode / decode ────────────────────────────────────────
+
+#[inline]
+pub fn encode_key(buf: &mut Vec<u8>, tag: u64) {
+    encode_varint(buf, tag);
+}
+
+#[inline]
+pub fn decode_key(data: &[u8], pos: usize) -> Result<(u64, usize), DecodeError> {
+    decode_varint(data, pos)
+}
+
+// ── Wire Type 0: Varint ──────────────────────────────────────────────
+
+#[inline]
+pub fn encode_varint(buf: &mut Vec<u8>, mut value: u64) {
+    loop {
+        if value < 0x80 {
+            buf.push(value as u8);
+            return;
+        }
+        buf.push(((value & 0x7F) | 0x80) as u8);
+        value >>= 7;
+    }
+}
+
+#[inline]
+pub fn decode_varint(data: &[u8], mut pos: usize) -> Result<(u64, usize), DecodeError> {
+    let mut result: u64 = 0;
+    let mut shift: u32 = 0;
+    loop {
+        if pos >= data.len() {
+            return Err(DecodeError::BufferOverflow);
+        }
+        let b = data[pos];
+        pos += 1;
+        result |= ((b & 0x7F) as u64) << shift;
+        if b & 0x80 == 0 {
+            return Ok((result, pos));
+        }
+        shift += 7;
+        if shift > 63 {
+            return Err(DecodeError::InvalidVarint);
+        }
+    }
+}
+
+// ── Bool ─────────────────────────────────────────────────────────────
+
+#[inline]
+pub fn encode_bool(buf: &mut Vec<u8>, value: bool) {
+    buf.push(if value { 1 } else { 0 });
+}
+
+#[inline]
+pub fn decode_bool(data: &[u8], pos: usize) -> Result<(bool, usize), DecodeError> {
+    let (v, new_pos) = decode_varint(data, pos)?;
+    Ok((v != 0, new_pos))
+}
+
+// ── ZigZag (sint32/sint64) ───────────────────────────────────────────
+
+#[inline]
+pub fn encode_zigzag32(buf: &mut Vec<u8>, value: i32) {
+    let encoded = ((value << 1) ^ (value >> 31)) as u32;
+    encode_varint(buf, encoded as u64);
+}
+
+#[inline]
+pub fn decode_zigzag32(data: &[u8], pos: usize) -> Result<(i32, usize), DecodeError> {
+    let (raw, new_pos) = decode_varint(data, pos)?;
+    let n = raw as u32;
+    let value = ((n >> 1) as i32) ^ (-((n & 1) as i32));
+    Ok((value, new_pos))
+}
+
+#[inline]
+pub fn encode_zigzag64(buf: &mut Vec<u8>, value: i64) {
+    let encoded = ((value << 1) ^ (value >> 63)) as u64;
+    encode_varint(buf, encoded);
+}
+
+#[inline]
+pub fn decode_zigzag64(data: &[u8], pos: usize) -> Result<(i64, usize), DecodeError> {
+    let (raw, new_pos) = decode_varint(data, pos)?;
+    let value = ((raw >> 1) as i64) ^ (-((raw & 1) as i64));
+    Ok((value, new_pos))
+}
+
+// ── Wire Type 1: 64-bit (little-endian) ─────────────────────────────
+
+#[inline]
+pub fn encode_fixed64(buf: &mut Vec<u8>, value: u64) {
+    buf.extend_from_slice(&value.to_le_bytes());
+}
+
+#[inline]
+pub fn decode_fixed64(data: &[u8], pos: usize) -> Result<(u64, usize), DecodeError> {
+    if pos + 8 > data.len() {
+        return Err(DecodeError::BufferOverflow);
+    }
+    let value = u64::from_le_bytes(data[pos..pos + 8].try_into().unwrap());
+    Ok((value, pos + 8))
+}
+
+#[inline]
+pub fn encode_sfixed64(buf: &mut Vec<u8>, value: i64) {
+    encode_fixed64(buf, value as u64);
+}
+
+#[inline]
+pub fn decode_sfixed64(data: &[u8], pos: usize) -> Result<(i64, usize), DecodeError> {
+    let (raw, new_pos) = decode_fixed64(data, pos)?;
+    Ok((raw as i64, new_pos))
+}
+
+// ── Wire Type 5: 32-bit (little-endian) ─────────────────────────────
+
+#[inline]
+pub fn encode_fixed32(buf: &mut Vec<u8>, value: u32) {
+    buf.extend_from_slice(&value.to_le_bytes());
+}
+
+#[inline]
+pub fn decode_fixed32(data: &[u8], pos: usize) -> Result<(u32, usize), DecodeError> {
+    if pos + 4 > data.len() {
+        return Err(DecodeError::BufferOverflow);
+    }
+    let value = u32::from_le_bytes(data[pos..pos + 4].try_into().unwrap());
+    Ok((value, pos + 4))
+}
+
+#[inline]
+pub fn encode_sfixed32(buf: &mut Vec<u8>, value: i32) {
+    encode_fixed32(buf, value as u32);
+}
+
+#[inline]
+pub fn decode_sfixed32(data: &[u8], pos: usize) -> Result<(i32, usize), DecodeError> {
+    let (raw, new_pos) = decode_fixed32(data, pos)?;
+    Ok((raw as i32, new_pos))
+}
+
+// ── Wire Type 2: Length-delimited ────────────────────────────────────
+
+#[inline]
+pub fn encode_bytes(buf: &mut Vec<u8>, value: &[u8]) {
+    encode_varint(buf, value.len() as u64);
+    buf.extend_from_slice(value);
+}
+
+#[inline]
+pub fn decode_bytes(data: &[u8], pos: usize) -> Result<(Vec<u8>, usize), DecodeError> {
+    let (len, pos) = decode_varint(data, pos)?;
+    let len = len as usize;
+    if pos + len > data.len() {
+        return Err(DecodeError::BufferOverflow);
+    }
+    Ok((data[pos..pos + len].to_vec(), pos + len))
+}
+
+#[inline]
+pub fn encode_string(buf: &mut Vec<u8>, value: &str) {
+    encode_bytes(buf, value.as_bytes());
+}
+
+#[inline]
+pub fn decode_string(data: &[u8], pos: usize) -> Result<(String, usize), DecodeError> {
+    let (raw, new_pos) = decode_bytes(data, pos)?;
+    String::from_utf8(raw)
+        .map(|s| (s, new_pos))
+        .map_err(|_| DecodeError::InvalidData("invalid UTF-8 in string field"))
+}
+
+// ── Skip unknown fields ──────────────────────────────────────────────
+
+#[inline]
+pub fn skip_field(data: &[u8], pos: usize, wire_type: u64) -> Result<usize, DecodeError> {
+    match wire_type {
+        0 => {
+            // Varint: skip until MSB is clear
+            let (_, new_pos) = decode_varint(data, pos)?;
+            Ok(new_pos)
+        }
+        1 => {
+            // 64-bit: skip 8 bytes
+            if pos + 8 > data.len() {
+                return Err(DecodeError::BufferOverflow);
+            }
+            Ok(pos + 8)
+        }
+        2 => {
+            // Length-delimited: read length, skip that many bytes
+            let (len, new_pos) = decode_varint(data, pos)?;
+            let end = new_pos + len as usize;
+            if end > data.len() {
+                return Err(DecodeError::BufferOverflow);
+            }
+            Ok(end)
+        }
+        5 => {
+            // 32-bit: skip 4 bytes
+            if pos + 4 > data.len() {
+                return Err(DecodeError::BufferOverflow);
+            }
+            Ok(pos + 4)
+        }
+        _ => Err(DecodeError::UnknownWireType(wire_type)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_varint_roundtrip() {
+        for &val in &[0u64, 1, 127, 128, 255, 300, 16384, u64::MAX] {
+            let mut buf = Vec::new();
+            encode_varint(&mut buf, val);
+            let (decoded, pos) = decode_varint(&buf, 0).unwrap();
+            assert_eq!(decoded, val);
+            assert_eq!(pos, buf.len());
+        }
+    }
+
+    #[test]
+    fn test_bool_roundtrip() {
+        for &val in &[true, false] {
+            let mut buf = Vec::new();
+            encode_bool(&mut buf, val);
+            let (decoded, _) = decode_bool(&buf, 0).unwrap();
+            assert_eq!(decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_zigzag32_roundtrip() {
+        for &val in &[0i32, 1, -1, 2, -2, i32::MAX, i32::MIN] {
+            let mut buf = Vec::new();
+            encode_zigzag32(&mut buf, val);
+            let (decoded, _) = decode_zigzag32(&buf, 0).unwrap();
+            assert_eq!(decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_zigzag64_roundtrip() {
+        for &val in &[0i64, 1, -1, 2, -2, i64::MAX, i64::MIN] {
+            let mut buf = Vec::new();
+            encode_zigzag64(&mut buf, val);
+            let (decoded, _) = decode_zigzag64(&buf, 0).unwrap();
+            assert_eq!(decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_fixed64_roundtrip() {
+        for &val in &[0u64, 1, 0xDEAD_BEEF, u64::MAX] {
+            let mut buf = Vec::new();
+            encode_fixed64(&mut buf, val);
+            let (decoded, _) = decode_fixed64(&buf, 0).unwrap();
+            assert_eq!(decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_fixed32_roundtrip() {
+        for &val in &[0u32, 1, 0xDEAD, u32::MAX] {
+            let mut buf = Vec::new();
+            encode_fixed32(&mut buf, val);
+            let (decoded, _) = decode_fixed32(&buf, 0).unwrap();
+            assert_eq!(decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_string_roundtrip() {
+        for val in &["", "hello", "hello world 🌍"] {
+            let mut buf = Vec::new();
+            encode_string(&mut buf, val);
+            let (decoded, _) = decode_string(&buf, 0).unwrap();
+            assert_eq!(&decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_bytes_roundtrip() {
+        for val in &[vec![], vec![1u8, 2, 3], vec![0xFF; 300]] {
+            let mut buf = Vec::new();
+            encode_bytes(&mut buf, val);
+            let (decoded, _) = decode_bytes(&buf, 0).unwrap();
+            assert_eq!(&decoded, val);
+        }
+    }
+
+    #[test]
+    fn test_skip_field() {
+        // Varint
+        let mut buf = Vec::new();
+        encode_varint(&mut buf, 300);
+        let new_pos = skip_field(&buf, 0, 0).unwrap();
+        assert_eq!(new_pos, buf.len());
+
+        // Fixed64
+        let mut buf = Vec::new();
+        encode_fixed64(&mut buf, 42);
+        let new_pos = skip_field(&buf, 0, 1).unwrap();
+        assert_eq!(new_pos, 8);
+
+        // Length-delimited
+        let mut buf = Vec::new();
+        encode_string(&mut buf, "hello");
+        let new_pos = skip_field(&buf, 0, 2).unwrap();
+        assert_eq!(new_pos, buf.len());
+
+        // Fixed32
+        let mut buf = Vec::new();
+        encode_fixed32(&mut buf, 42);
+        let new_pos = skip_field(&buf, 0, 5).unwrap();
+        assert_eq!(new_pos, 4);
+    }
+}