Checks the oracle owner, account format, player and request address. All 64 bytes of the fulfilled result are hashed into the game’s randomness input.

pub fn read_result(account:&AccountInfo,client:&Pubkey,fulfilled:bool)->Result<([u8;32],Option<[u8;32]>),ProgramError>{
 require(account.owner==&ID)?;let d=account.try_borrow_data()?;
 require(d.len()>=73 && d[..8]==RESULT_DISC && d[8]<=1 && d[9..41]==client.to_bytes())?;
 let seed:[u8;32]=d[41..73].try_into().unwrap();require(account.key==&request_address(&seed))?;
 if fulfilled {
  require(d[8]==1 && d.len()==137)?;
  // Hash all 64 quorum bytes into the game's fixed 32-byte randomness input.
  Ok((seed,Some(solana_program::hash::hashv(&[b"solpot:orao:v1",&d[73..137]]).to_bytes())))
 }else{
  require(d[8]==0 && d.len()>=77)?;
  let count=u32::from_le_bytes(d[73..77].try_into().unwrap()) as usize;
  require(count==0 && d.len()==749)?;Ok((seed,None))
 }
}

The largest multiple of 400 below 2³² is 4,294,967,200. The remaining 96 values are skipped, avoiding modulo bias.

pub fn draw_from_word(word: u32) -> Option<u16> {
    const LIMIT: u64 = (1u64 << 32) / 400 * 400;
    if u64::from(word) >= LIMIT { None } else { Some((word % 400 + 1) as u16) }
}

One-spin entries read the authenticated bytes directly. Multi-spin packs use a separate hash for each spin; retry counters only reuse the same oracle result.

fn batch_draws(bytes:&[u8;32],game:&Pubkey,nonce:u64,seed_slot:u64,count:u8)->Result<[u16;10],ProgramError>{
 require((1..=10).contains(&count))?;
 let mut draws=[0u16;10];
 for index in 0..count {
  if count==1 { draws[0]=bytes.chunks_exact(4).find_map(|b|draw_from_word(u32::from_le_bytes(b.try_into().unwrap()))).ok_or(ProgramError::InvalidAccountData)?; break; }
  let mut draw=None;
  for counter in 0..16u8 {
   let digest=solana_program::hash::hashv(&[b"solpot:batch:v1",bytes,game.as_ref(),&nonce.to_le_bytes(),&seed_slot.to_le_bytes(),&[index,counter]]).to_bytes();
   draw=digest.chunks_exact(4).find_map(|b|draw_from_word(u32::from_le_bytes(b.try_into().unwrap())));
   if draw.is_some(){break;}
  }
  draws[usize::from(index)]=draw.ok_or(ProgramError::InvalidAccountData)?;
 }
 Ok(draws)
}

Numbers 1–4 win the reserved SOL pot. Numbers 5–84 return tokens. The program records rewards, burns and any unused pack credits together.

    pub fn settle_batch_verified(&mut self, player: &mut Player, nonce: u64, request: [u8;32], numbers: &[u16]) -> Result<(Settlement,u8)> {
        let spin = self.matching_spin(player, nonce, request)?;
        let count = self.pending_count();
        if numbers.len()!=usize::from(count) || numbers.iter().any(|n| !(1..=400).contains(n)) { return Err(Error::InvalidDraw); }
        let mut tokens=0; let mut sol=0; let mut burned=0; let mut played=0u8;
        for number in numbers {
            let reward=if (5..=84).contains(number) { self.consolation() } else { 0 };
            tokens=add(tokens,reward)?; burned=add(burned,self.entry-reward)?; played+=1;
            if *number<=4 { sol=spin.locked_pot; break; }
        }
        let unused=self.entry.checked_mul(u64::from(count-played)).ok_or(Error::Overflow)?;
        let new_pot=add(self.pot,if sol==0 {spin.locked_pot} else {0})?;
        let new_tokens=add(player.token_rewards,tokens)?; let new_sol=add(player.sol_rewards,sol)?;
        let token_liability=add(self.token_liability,tokens)?; let sol_liability=add(self.sol_liability,sol)?;
        let total_burned=add(self.burned,burned)?; let prepaid=add(player.prepaid,unused)?;
        let prepaid_liability=add(self.prepaid_liability,unused)?;
        self.pot=new_pot; player.token_rewards=new_tokens; player.sol_rewards=new_sol; player.prepaid=prepaid;
        self.token_liability=token_liability; self.sol_liability=sol_liability; self.prepaid_liability=prepaid_liability;
        self.burned=total_burned; self.pending=None; self.pending_count=0;
        Ok((Settlement{burned,tokens,sol},played))
    }