tdp-solana

rustc --version
solana --version
anchor --version   # v0.31.x
node --version     # v18+
yarn --version

git clone https://github.com/mancer-team2/programs.git
cd programs
yarn install

anchor build        # compiles the program + generates the keypair
anchor keys sync    # writes the program ID into lib.rs and Anchor.toml

solana config set --url devnet
solana airdrop 2
anchor deploy --provider.cluster devnet

# Pure-logic unit tests always run.
# LiteSVM integration tests need the compiled .so, so build first.
anchor build
cargo test

#[account]
#[derive(InitSpace)]
pub struct Stream {
    pub creator: Pubkey,              // funded the escrow, may cancel/close
    pub recipient: Pubkey,            // entitled to withdraw vested tokens
    pub mint: Pubkey,                 // SPL token being vested
    pub escrow_token_account: Pubkey, // PDA-owned escrow holding the tokens
    pub stream_id: u64,               // creator-scoped id, used in the PDA seed
    pub total_amount: u64,            // tokens originally deposited
    pub withdrawn_amount: u64,        // cumulative amount already claimed
    pub start_time: i64,              // unix ts vesting begins
    pub cliff_time: i64,              // nothing claimable before this ts
    pub end_time: i64,                // unix ts at 100% unlocked
    pub cancelable: bool,             // creator allowed to cancel
    pub canceled: bool,               // stream has been canceled
    pub vesting_type: VestingType,    // Cliff | Linear | Milestone
    pub milestone_reached: bool,      // milestone flag (milestone vesting only)
    pub milestone_time: i64,          // gate ts for milestone unlock
    pub bump: u8,                     // Stream PDA bump
    pub escrow_bump: u8,              // escrow authority PDA bump
    pub created_at: i64,              // unix ts the account was created
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Copy, PartialEq, Eq, InitSpace)]
pub enum VestingType {
    Cliff,      // all-or-nothing at end_time (cliff_time == end_time)
    Linear,     // proportional over [start_time, end_time] (cliff_time == start_time)
    Milestone,  // all-at-once once the creator marks the milestone reached
}

// Stream account PDA
seeds = [
    b"stream",
    creator.key().as_ref(),
    recipient.as_ref(),
    &stream_id.to_le_bytes(),
]

// Escrow authority PDA — owns the escrow token account.
// Only the program can sign for it (no private key).
seeds = [b"escrow_authority", stream.key().as_ref()]

pub fn create_stream(
    ctx: Context<CreateStream>,
    stream_id: u64,
    recipient: Pubkey,
    total_amount: u64,
    start_time: i64,
    cliff_time: i64,
    end_time: i64,
    cancelable: bool,
    vesting_type: VestingType,
    milestone_time: i64,
) -> Result<()>

require!(total_amount > 0, VestingError::InvalidAmount);
require!(recipient != Pubkey::default(), VestingError::InvalidRecipient);
match vesting_type {
    VestingType::Cliff => {
        require!(start_time < end_time, VestingError::InvalidSchedule);
        require!(cliff_time == end_time, VestingError::InvalidCliff);
    }
    VestingType::Linear => {
        require!(start_time < end_time, VestingError::InvalidSchedule);
        require!(cliff_time == start_time, VestingError::InvalidCliff);
    }
    VestingType::Milestone => {
        require!(milestone_time > 0, VestingError::InvalidMilestoneTime);
    }
}
require!(creator_token_balance >= total_amount, VestingError::InsufficientFunds);

// 1. Recompute what has vested right now.
let vested = calculate_vested_amount_by_type(/* schedule + vesting_type */, now)?;
// 2. Subtract what was already claimed.
let withdrawable = vested.checked_sub(stream.withdrawn_amount)?;
require!(withdrawable > 0, VestingError::NothingToWithdraw);
// 3. Effects before interactions: bump the claimed total first.
stream.withdrawn_amount = stream.withdrawn_amount.checked_add(withdrawable)?;
// 4. PDA-signed transfer escrow -> recipient ATA.
token::transfer(/* escrow_authority signs */, withdrawable)?;

// to_recipient = vested - withdrawn   (unlocked but not yet claimed)
// to_creator   = total  - vested      (still locked)
pub fn split_cancel_amounts(
    total_amount: u64,
    vested_amount: u64,
    withdrawn_amount: u64,
) -> Result<(u64, u64)> {
    let to_recipient = vested_amount.checked_sub(withdrawn_amount)?;
    let to_creator = total_amount.checked_sub(vested_amount)?;
    Ok((to_recipient, to_creator))
}

// Linear: 0 before the cliff, total after end_time, else proportional.
if current_time < cliff_time { return Ok(0); }
if current_time >= end_time  { return Ok(total_amount); }

let elapsed  = (current_time - start_time) as u128;
let duration = (end_time - start_time) as u128;
let vested   = (total_amount as u128) * elapsed / duration; // all checked_*

// Cliff: total once current_time >= end_time, otherwise 0.
// Milestone: total once milestone_reached && current_time >= milestone_time.