Streampay

        require!(            authority == payment_record.user                || authority == payment_record.merchant                || authority.to_bytes() == BACKEND_AUTHORITY_BYTES,            PaymentRouterError::Unauthorized        );         payment_record.execution_reference = execution_reference;        payment_record.status = PaymentStatus::Completed;         Ok(())    }} #[derive(Accounts)]pub struct CreatePayment<'info> {    #[account(mut)]    pub user: Signer<'info>,    #[account(init, payer = user, space = PaymentRecord::SPACE)]    pub payment_record: Account<'info, PaymentRecord>,    pub system_program: Program<'info, System>,} #[derive(Accounts)]

1. Line 49 require!(: An explicit validation that aborts the instruction with an error.
2. Line 66 pub user: Signer<'info>,: Requires this account to have signed the transaction.
3. Line 67 #[account(init, payer = user, space = PaymentRecord::SPACE)]: Creates and pays for a new account. Space and payer must be specified.

        require!(            authority == payment.user                || authority == payment.merchant                || authority.to_bytes() == BACKEND_AUTHORITY_BYTES,            SubscriptionError::Unauthorized        );        require!(payment.merchant == plan.merchant, SubscriptionError::InvalidMerchant);        require!(payment.amount >= plan.amount, SubscriptionError::InvalidAmount);        require!(payment.is_confirmed, SubscriptionError::PaymentNotConfirmed);        require!(payment.plan_id == plan.plan_id, SubscriptionError::InvalidPlan);         let now = Clock::get()?.unix_timestamp;        let subscription = &mut ctx.accounts.subscription;        subscription.user = payment.user;        subscription.merchant = plan.merchant;        subscription.plan_id = plan.plan_id;        subscription.amount = plan.amount;        subscription.payment_record = payment_record;        subscription.start_timestamp = now;        subscription.end_timestamp = now            .checked_add(plan.duration_seconds)            .ok_or(SubscriptionError::TimestampOverflow)?;        subscription.status = SubscriptionStatus::Active;

1. Line 37 require!(: An explicit validation that aborts the instruction with an error.
2. Line 48 let now = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.
3. Line 57 .checked_add(plan.duration_seconds): Uses checked arithmetic so overflow fails instead of wrapping.

   const transaction = new Transaction().add(instruction);  const signature = await sendAndConfirmTransaction(connection, transaction, [    authority,  ]);   return signature;} /** * Derive the PDA for a payment record */export function derivePaymentRecordPDA(  user: PublicKey,  merchant: PublicKey,  seed: string): PublicKey {  const [pda] = PublicKey.findProgramAddressSync(    [      Buffer.from("payment_record"),      user.toBuffer(),      merchant.toBuffer(),      Buffer.from(seed),    ],

1. Line 135 const signature = await sendAndConfirmTransaction(connection, transaction, [: Submits the signed transaction to the cluster.
2. Line 150 const [pda] = PublicKey.findProgramAddressSync(: Derives a PDA from seeds and the program ID and returns the address with its canonical bump.

      { pubkey: subscriptionPlanPubkey, isSigner: false, isWritable: false },      { pubkey: paymentRecordPubkey, isSigner: false, isWritable: false },    ],    data: instructionData,  };   const transaction = new Transaction().add(instruction);  const signature = await sendAndConfirmTransaction(connection, transaction, [    authority,  ]);   return signature;} /** * Derive the PDA for a subscription plan */export function deriveSubscriptionPlanPDA(  merchant: PublicKey,  planId: number): PublicKey {  const [pda] = PublicKey.findProgramAddressSync(    [      Buffer.from("subscription_plan"),

1. Line 176 const signature = await sendAndConfirmTransaction(connection, transaction, [: Submits the signed transaction to the cluster.
2. Line 190 const [pda] = PublicKey.findProgramAddressSync(: Derives a PDA from seeds and the program ID and returns the address with its canonical bump.