Struct Writer 

pub struct Writer { /* private fields */ }

A binary writer for serializing Bitcoin data structures.

Writer provides methods for writing integers in little-endian format and Bitcoin-specific variable-length integers (varints).

Example

use bsv_rs::primitives::encoding::Writer;

let mut writer = Writer::new();
writer.write_u8(0x01);
writer.write_u16_le(0x0002);
writer.write_u32_le(0x00000003);

let data = writer.into_bytes();
assert_eq!(data, vec![0x01, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00]);

Implementations

impl Writer

pub fn new() -> Self

Creates a new empty writer.

pub fn with_capacity(capacity: usize) -> Self

Creates a new writer with pre-allocated capacity.

Arguments

• capacity - The number of bytes to pre-allocate

pub fn len(&self) -> usize

Returns the current length of the written data.

pub fn is_empty(&self) -> bool

Returns true if no data has been written.

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

Returns a reference to the written bytes.

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

Consumes the writer and returns the written bytes.

pub fn write_u8(&mut self, val: u8) -> &mut Self

Writes a single unsigned byte.

pub fn write_u16_le(&mut self, val: u16) -> &mut Self

Writes a 16-bit unsigned integer in little-endian format.

pub fn write_u32_le(&mut self, val: u32) -> &mut Self

Writes a 32-bit unsigned integer in little-endian format.

pub fn write_u64_le(&mut self, val: u64) -> &mut Self

Writes a 64-bit unsigned integer in little-endian format.

pub fn write_i8(&mut self, val: i8) -> &mut Self

Writes a single signed byte.

pub fn write_i16_le(&mut self, val: i16) -> &mut Self

Writes a 16-bit signed integer in little-endian format.

pub fn write_i32_le(&mut self, val: i32) -> &mut Self

Writes a 32-bit signed integer in little-endian format.

pub fn write_i64_le(&mut self, val: i64) -> &mut Self

Writes a 64-bit signed integer in little-endian format.

pub fn write_var_int(&mut self, val: u64) -> &mut Self

Writes a Bitcoin variable-length integer.

Bitcoin varints are encoded as follows:

• 0x00-0xFC: 1 byte, value as-is
• 0xFD-0xFFFF: 3 bytes, 0xFD prefix + 2 bytes little-endian uint16
• 0x10000-0xFFFFFFFF: 5 bytes, 0xFE prefix + 4 bytes little-endian uint32
• 0x100000000-0xFFFFFFFFFFFFFFFF: 9 bytes, 0xFF prefix + 8 bytes little-endian uint64

Arguments

• val - The value to encode

Example

use bsv_rs::primitives::encoding::Writer;

let mut w = Writer::new();
w.write_var_int(252); // 0xFC - single byte
assert_eq!(w.len(), 1);

let mut w = Writer::new();
w.write_var_int(253); // 0xFD - needs 3-byte encoding
assert_eq!(w.len(), 3);

let mut w = Writer::new();
w.write_var_int(0x10000); // needs 5-byte encoding
assert_eq!(w.len(), 5);

let mut w = Writer::new();
w.write_var_int(0x100000000); // needs 9-byte encoding
assert_eq!(w.len(), 9);

pub fn write_bytes(&mut self, data: &[u8]) -> &mut Self

Writes raw bytes.

Arguments

• data - The bytes to write

pub fn write_var_bytes(&mut self, data: &[u8]) -> &mut Self

Writes a variable-length byte sequence (varint length prefix followed by bytes).

This is commonly used in Bitcoin for scripts and other length-prefixed data.

Arguments

• data - The bytes to write

Trait Implementations

impl Clone for Writer

fn clone(&self) -> Writer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Writer

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

Formats the value using the given formatter.

impl Default for Writer

fn default() -> Writer

Returns the “default value” for a type.