Solana: Borsh, Bincode, and Wincode serialization

Documentation Index

Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt

Use this file to discover all available pages before exploring further.

• Solana accounts store raw bytes — to read them, you need to know how the owning program serialized its data.
• Borsh is the canonical, deterministic, cross-language format used by Anchor and most clients.
• Bincode is the Rust-only format the validator has historically used internally; it is now unmaintained and being phased out.
• Wincode is Anza’s bincode-compatible replacement with zero-copy reads, already shipping inside Agave — it is the reason recent gRPC streams are faster.

​

Why serialization matters on Solana

• Borsh — the canonical format for on-chain program data and clients.
• Bincode — the format the validator uses internally for its own wire protocol and snapshots.
• Wincode — Anza’s high-performance, bincode-compatible successor.

​

Borsh

​

Bincode

​

Wincode

​

Decode account data from your Chainstack node

1. Sign up with Chainstack.
2. Deploy a node.
3. View node access and credentials.

import * as borsh from "borsh";
import { Connection, PublicKey } from "@solana/web3.js";

// Schema must match the on-chain struct field-for-field, in order.
const schema = {
  struct: {
    amount: "u64",
    nonce: "u32",
  },
};

const connection = new Connection("YOUR_CHAINSTACK_ENDPOINT");
const pubkey = new PublicKey("YourProgramAccountAddressHere");

const accountInfo = await connection.getAccountInfo(pubkey);
if (!accountInfo) throw new Error("Account not found");

// web3.js returns account data as a Buffer, already base64-decoded.
const decoded = borsh.deserialize(schema, accountInfo.data) as {
  amount: bigint;
  nonce: number;
};

console.log(decoded.amount); // u64 values come back as BigInt
console.log(decoded.nonce);

​

Not everything is Borsh: SPL Token accounts

• Pass encoding: "jsonParsed" to getAccountInfo and let your Chainstack node return a structured JSON object with mint, owner, and tokenAmount.
• Decode the binary layout client-side with @solana/spl-token, which uses fixed-offset buffer layouts, not Borsh.

import { AccountLayout } from "@solana/spl-token";
import { Connection, PublicKey } from "@solana/web3.js";

const connection = new Connection("YOUR_CHAINSTACK_ENDPOINT");
const info = await connection.getAccountInfo(new PublicKey("TokenAccountAddressHere"));
if (!info) throw new Error("Account not found");

const token = AccountLayout.decode(info.data); // fixed 165-byte layout, not Borsh
console.log(token.amount); // bigint
console.log(new PublicKey(token.owner).toBase58());

​

Serialize and deserialize in Rust

borsh = { version = "1", features = ["derive"] }
bincode = { version = "2", features = ["derive"] }
wincode = { version = "0.5", features = ["derive"] }

use borsh::{BorshSerialize, BorshDeserialize, to_vec, from_slice};

#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
struct Transfer {
    amount: u64,
    nonce: u32,
}

let original = Transfer { amount: 1_000_000, nonce: 42 };

let bytes: Vec<u8> = to_vec(&original)?;
let decoded: Transfer = from_slice(&bytes)?;
assert_eq!(original, decoded);

​

Zero-copy reads with Wincode

use wincode::{SchemaWrite, SchemaRead, ZeroCopy};

// Layout matches a token-like account: mint (32), owner (32), amount (8).
#[derive(SchemaWrite, SchemaRead)]
#[wincode(assert_zero_copy)]
#[repr(C)]
struct TokenAccountData {
    mint: [u8; 32],
    owner: [u8; 32],
    amount: u64,
}

// `use wincode::ZeroCopy` brings from_bytes / from_bytes_mut into scope.
// Read a typed reference into the buffer — zero allocations, zero copies.
let account: &TokenAccountData = TokenAccountData::from_bytes(raw)?;
println!("{}", account.amount);

// Or borrow mutably and edit the buffer in place.
let account: &mut TokenAccountData = TokenAccountData::from_bytes_mut(raw_mut)?;
account.amount += 500; // writes directly into the underlying bytes

​

Which format should you use?

• Building an on-chain program, or a client or indexer that reads its data — use Borsh. Anchor gives you this by default, and it keeps your TypeScript and Python tooling interoperable.
• Writing a performance-critical native program or low-level tooling that parses raw account bytes at volume — reach for Wincode and its zero-copy reads.
• Maintaining existing code that uses bincode — plan a migration to Wincode. The wire formats are compatible for default types, so the move does not break data already on disk or in flight.

​

Performance and Geyser streams

​

Additional resources

• getAccountInfo vs getMultipleAccounts — fetch the bytes you decode here.
• Anchor development — the framework that handles Borsh and discriminators for you.
• Listening to programs using Geyser and Yellowstone gRPC — stream account and transaction data at scale.
• Borsh specification — the canonical, cross-language format spec.
• anza-xyz/wincode — the bincode-compatible successor from Anza.