Struct BatchClaim 

#[repr(C)]
pub struct BatchClaim {
    pub start_epoch: [u8; 8],
    pub end_epoch: [u8; 8],
    pub participant_type: u8,
    pub claim_type: u8,
    pub epoch_count: u8,
    pub max_batch_size: u8,
    pub _padding: [u8; 4],
}

BatchClaim instruction data for Dual Merkle Tree system.

This instruction allows users to claim rewards for multiple epochs in a single transaction using the Dual Merkle Tree verification system. Each epoch requires both payment and seal merkle proofs for complete security verification.

Dual Merkle Verification for Batch Claims

For each epoch in the batch:

1. Payment Proof: Verifies user’s activity within the epoch
2. Seal Proof: Verifies the payment merkle root is authentic (from oracle)
3. Dual Verification: Both proofs must pass for each epoch

Data Structure

The instruction uses a hybrid approach supporting different claim types:

// Fixed-size struct (25 bytes)
struct BatchClaim {
    start_epoch: [u8; 8],     // 8 bytes - Start epoch for range claims
    end_epoch: [u8; 8],       // 8 bytes - End epoch for range claims
    participant_type: u8,     // 1 byte - 0 for customer, 1 for merchant
    claim_type: u8,           // 1 byte - 0=range, 1=vector, 2=date_range
    epoch_count: u8,          // 1 byte - Number of epochs for vector claims
    max_batch_size: u8,       // 1 byte - Maximum epochs to process
    _padding: [u8; 4],        // 4 bytes - Padding for alignment
}

// Variable-size additional data (appended after fixed struct)
// For vector claims: Vec<u64> of epochs
// For each epoch: payment_proof + payment_indices + payment_root + seal_proof + seal_indices + epoch_data
// Social flags array: 1 byte per epoch (0=no social, 1=has social)
// Social data array: SocialClaimData for epochs with social claims

Claim Types

• Range Claims (0): Claim all epochs from start_epoch to end_epoch (inclusive)
• Vector Claims (1): Claim specific epochs listed in variable data
• Date Range Claims (2): Convert date range to epoch range automatically

Benefits

• Gas Efficiency: Single transaction for multiple epochs
• User Experience: Natural date-based interface
• Flexibility: Support for both contiguous and non-contiguous epochs
• Security: Each epoch validated independently with dual merkle proofs
• Unified: Supports both payment and social rewards in single batch
• Payment-First: All social claims require payment activity
• Unlimited History: No storage limits for historical claims

Historical Claims Support

For historical epoch claims, each epoch includes epoch-specific data:

• Current Epochs: Use on-chain snapshot data for reward calculation
• Historical Epochs: Use epoch-specific data embedded in the instruction
• No On-Chain Storage: Historical data comes with the batch claim instruction
• Accurate Rewards: Users get correct rewards for historical activity across all epochs

This enables the Dual Merkle Tree’s promise of unlimited claim history without requiring expensive on-chain storage of historical snapshots.

Error Handling

• No Activity: Skip epochs with no user activity
• Invalid Proofs: Fail on security-critical errors (payment or seal)
• Batch Limits: Respect max_batch_size to prevent gas limit issues
• Pool Limits: Validate against both payment and social pool limits

Fields

start_epoch: [u8; 8]

Start epoch for range claims (inclusive)

end_epoch: [u8; 8]

End epoch for range claims (inclusive)

participant_type: u8

Participant type: 0 for customer, 1 for merchant

claim_type: u8

Claim type: 0=range, 1=vector, 2=date_range

epoch_count: u8

Number of epochs for vector claims

max_batch_size: u8

Maximum epochs to process (gas limit protection)

_padding: [u8; 4]

Padding to ensure proper alignment (4 bytes)

Implementations

impl BatchClaim

pub fn try_from_bytes(data: &[u8]) -> Result<&Self, ProgramError>

impl BatchClaim

pub fn to_bytes(&self) -> Vec<u8>

Trait Implementations

impl Clone for BatchClaim

fn clone(&self) -> BatchClaim

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BatchClaim

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

Formats the value using the given formatter.

impl Discriminator for BatchClaim

fn discriminator() -> u8

impl Zeroable for BatchClaim

fn zeroed() -> Self

Calls zeroed.

impl Copy for BatchClaim

impl Pod for BatchClaim