Struct BinaryWriter 

pub struct BinaryWriter { /* private fields */ }

Binary writer that matches TypeScript SDK encoding exactly

Implementations

impl BinaryWriter

pub fn new() -> Self

Create a new binary writer

pub fn with_capacity(capacity: usize) -> Self

Create a binary writer with pre-allocated capacity

pub fn into_bytes(self) -> Vec<u8>

Get the accumulated bytes

pub fn bytes(&self) -> &[u8]

Get a reference to the accumulated bytes

pub fn clear(&mut self)

Clear the buffer

pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), EncodingError>

Write raw bytes to the buffer

pub fn write_field( &mut self, field: u32, value: &[u8], ) -> Result<(), EncodingError>

Encode a field with its number and value Matches TS: fieldMarshalBinary(field: number, val: Uint8Array)

pub fn write_uvarint(&mut self, value: u64) -> Result<(), EncodingError>

Encode an unsigned varint using Go’s canonical encoding/binary algorithm Matches Go: binary.PutUvarint(buf, x)

pub fn write_uvarint_field( &mut self, value: u64, field: u32, ) -> Result<(), EncodingError>

Encode an unsigned varint with field number

pub fn write_varint(&mut self, value: i64) -> Result<(), EncodingError>

Encode a signed varint using Go’s canonical zigzag encoding Matches Go: binary.PutVarint(buf, x)

pub fn write_varint_field( &mut self, value: i64, field: u32, ) -> Result<(), EncodingError>

Encode a signed varint with field number

pub fn write_big_number(&mut self, value: &BigUint) -> Result<(), EncodingError>

Encode a big number (unsigned big integer) Matches TS: bigNumberMarshalBinary(bn: bigint, field?: number)

pub fn write_big_number_field( &mut self, value: &BigUint, field: u32, ) -> Result<(), EncodingError>

Encode a big number with field number

pub fn write_bool(&mut self, value: bool) -> Result<(), EncodingError>

Encode a boolean value Matches TS: booleanMarshalBinary(b: boolean, field?: number)

pub fn write_bool_field( &mut self, value: bool, field: u32, ) -> Result<(), EncodingError>

Encode a boolean with field number

pub fn write_string(&mut self, value: &str) -> Result<(), EncodingError>

Encode a string as UTF-8 bytes with length prefix Matches TS: stringMarshalBinary(val: string, field?: number)

pub fn write_string_field( &mut self, value: &str, field: u32, ) -> Result<(), EncodingError>

Encode a string with field number

pub fn write_bytes_with_length( &mut self, bytes: &[u8], ) -> Result<(), EncodingError>

Encode bytes with length prefix Matches TS: bytesMarshalBinary(val: Uint8Array, field?: number)

pub fn write_bytes_field( &mut self, bytes: &[u8], field: u32, ) -> Result<(), EncodingError>

Encode bytes with length prefix and field number

pub fn write_hash(&mut self, hash: &[u8; 32]) -> Result<(), EncodingError>

Encode a 32-byte hash without length prefix Matches TS: hashMarshalBinary(val: Uint8Array, field?: number)

pub fn write_hash_field( &mut self, hash: &[u8; 32], field: u32, ) -> Result<(), EncodingError>

Encode a hash with field number

pub fn write_hash_bytes(&mut self, hash: &[u8]) -> Result<(), EncodingError>

Encode a variable-length hash with validation

pub fn write_hash_bytes_field( &mut self, hash: &[u8], field: u32, ) -> Result<(), EncodingError>

Encode a variable-length hash with field number

pub fn write_optional<T, F>( &mut self, value: Option<&T>, _field: u32, writer_fn: F, ) -> Result<(), EncodingError>

where T: Clone, F: FnOnce(&mut Self, &T) -> Result<(), EncodingError>,

Write an optional value (None = skip, Some = encode)

pub fn write_array<T, F>( &mut self, items: &[T], _field: u32, writer_fn: F, ) -> Result<(), EncodingError>

where F: Fn(&mut Self, &T) -> Result<(), EncodingError>,

Write an array/slice with element encoding

impl BinaryWriter

Helper functions that match TypeScript SDK exactly

pub fn with_field_number( data: &[u8], field: Option<u32>, ) -> Result<Vec<u8>, EncodingError>

Create field-encoded data (helper matching TS withFieldNumber)

pub fn encode_uvarint(value: u64) -> Vec<u8>

Encode uvarint as standalone function

pub fn encode_varint(value: i64) -> Vec<u8>

Encode varint as standalone function

pub fn encode_string(value: &str) -> Vec<u8>

Encode string as standalone function

pub fn encode_bytes(bytes: &[u8]) -> Vec<u8>

Encode bytes with length as standalone function

pub fn encode_bool(value: bool) -> Vec<u8>

Encode boolean as standalone function

pub fn encode_hash(hash: &[u8; 32]) -> Vec<u8>

Encode hash as standalone function

Trait Implementations

impl Clone for BinaryWriter

fn clone(&self) -> BinaryWriter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BinaryWriter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BinaryWriter

fn default() -> Self

Returns the “default value” for a type.