Struct Stamp 

pub struct Stamp { /* private fields */ }

A postage stamp represents proof of payment for storing a chunk.

Stamps are created by signing a message containing the chunk address, batch ID, stamp index, and timestamp with the batch owner’s private key.

Wire Format

A serialized stamp is 113 bytes:

• Batch ID: 32 bytes
• Bucket (x): 4 bytes, big-endian
• Index (y): 4 bytes, big-endian
• Timestamp: 8 bytes, big-endian
• Signature: 65 bytes (r || s || v)

Implementations

impl Stamp

pub const fn new( batch: BatchId, bucket: u32, index: u32, timestamp: u64, sig: Signature, ) -> Self

Creates a new stamp with the given parameters.

pub const fn with_index( batch: BatchId, index: StampIndex, timestamp: u64, sig: Signature, ) -> Self

Creates a new stamp from a stamp index.

pub const fn batch(&self) -> BatchId

Returns the batch ID.

pub const fn stamp_index(&self) -> StampIndex

Returns the stamp index.

pub const fn bucket(&self) -> u32

Returns the collision bucket.

pub const fn index(&self) -> u32

Returns the position within the bucket.

pub const fn timestamp(&self) -> u64

Returns the timestamp.

pub const fn signature(&self) -> &Signature

Returns the signature.

pub fn to_bytes(&self) -> StampBytes

Serializes the stamp to a 113-byte array.

pub fn from_bytes(bytes: &StampBytes) -> Result<Self, StampError>

Deserializes a stamp from a 113-byte array.

Returns an error if the signature bytes are invalid.

pub fn try_from_slice(bytes: &[u8]) -> Result<Self, StampError>

Attempts to deserialize a stamp from a byte slice.

Returns an error if the slice is not exactly 113 bytes or if the signature is invalid.

pub fn recover_signer( &self, chunk_address: &SwarmAddress, ) -> Result<Address, StampError>

Recovers the signer address from this stamp using EIP-191 message recovery.

This computes the stamp digest from the chunk address and stamp fields, then recovers the Ethereum address that signed it.

Arguments

• chunk_address - The address of the chunk this stamp is for

Returns

The Ethereum address of the signer, or an error if recovery fails.

Example

let stamp = Stamp::try_from_slice(&bytes)?;
let signer = stamp.recover_signer(&chunk_address)?;
println!("Stamp signed by: {}", signer);

pub fn verify( &self, chunk_address: &SwarmAddress, owner: Address, ) -> Result<(), StampError>

Verifies this stamp was signed by the expected owner.

This is a convenience method that calls recover_signer and compares the result to the expected owner address.

Arguments

• chunk_address - The address of the chunk this stamp is for
• owner - The expected owner/signer address

Returns

Ok(()) if the stamp was signed by the expected owner, or an error if signature recovery fails or the signer doesn’t match.

Example

let stamp = Stamp::try_from_slice(&bytes)?;
stamp.verify(&chunk_address, batch.owner())?;

pub fn recover_pubkey( &self, chunk_address: &SwarmAddress, ) -> Result<VerifyingKey, StampError>

Recovers the public key from this stamp.

This is useful for caching the public key after the first verification of a batch. Subsequent stamps from the same batch can then use verify_with_pubkey which is approximately 10x faster than full signature recovery.

Arguments

• chunk_address - The address of the chunk this stamp is for

Returns

The public key of the signer, or an error if recovery fails.

Example

// First stamp: recover public key and cache it
let pubkey = first_stamp.recover_pubkey(&first_chunk_address)?;

// Subsequent stamps: fast verification with cached pubkey
for (stamp, addr) in remaining_stamps {
    stamp.verify_with_pubkey(&addr, &pubkey)?;
}

pub fn verify_with_pubkey( &self, chunk_address: &SwarmAddress, pubkey: &VerifyingKey, ) -> Result<(), StampError>

Verifies this stamp using a known public key.

This is approximately 10x faster than verify or recover_signer because it avoids the expensive ECDSA public key recovery operation.

Use this when you’ve already recovered the owner’s public key from a previous stamp in the same batch (via recover_pubkey).

Arguments

• chunk_address - The address of the chunk this stamp is for
• pubkey - The expected signer’s public key (cached from previous recovery)

Returns

Ok(()) if the signature is valid for the given public key, or an error if verification fails.

Example

// First stamp: recover and cache the public key
let pubkey = first_stamp.recover_pubkey(&first_address)?;
let owner = alloy_signer::utils::public_key_to_address(&pubkey);

// Fast verification for remaining stamps in the same batch
second_stamp.verify_with_pubkey(&second_address, &pubkey)?;
third_stamp.verify_with_pubkey(&third_address, &pubkey)?;

Trait Implementations

impl<'a> Arbitrary<'a> for Stamp

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for Stamp

fn clone(&self) -> Stamp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stamp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Stamp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Stamp

impl From<Stamp> for StampBytes

fn from(stamp: Stamp) -> Self

Converts to this type from the input type.

impl PartialEq for Stamp

fn eq(&self, other: &Stamp) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Stamp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Stamp

impl TryFrom<[u8; 113]> for Stamp

type Error = StampError

The type returned in the event of a conversion error.

fn try_from(bytes: StampBytes) -> Result<Self, Self::Error>

Performs the conversion.