How to Build a Liquidity Locker on Solana with Anchor

solana --version
anchor --version

anchor init liquidity-locker
cd liquidity-locker

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Token, TokenAccount, Transfer};
 
declare_id!("YOUR_PROGRAM_ID");
 
#[account]
pub struct LockAccount {
    pub authority: Pubkey,
    pub mint: Pubkey,
    pub amount: u64,
    pub unlock_ts: i64,
    pub vault: Pubkey,
    pub unlocked: bool,
    pub bump: u8,
}

#[program]
pub mod liquidity_locker {
    use super::*;
 
    pub fn create_lock(
        ctx: Context<CreateLock>,
        amount: u64,
        unlock_ts: i64,
    ) -> Result<()> {
        let clock = Clock::get()?;
        require!(unlock_ts > clock.unix_timestamp, LockerError::UnlockInPast);
        require!(amount > 0, LockerError::ZeroAmount);
 
        let lock = &mut ctx.accounts.lock_account;

#[derive(Accounts)]
pub struct CreateLock<'info> {
    #[account(
        init,
        payer = authority,
        space = LockAccount::SIZE,
        seeds = [b"lock", authority.key().as_ref(), mint.key().as_ref()],
        bump,
    )]
    pub lock_account: Account<'info, LockAccount>,
    #[account(
        init,
        payer = authority,
        token::mint = mint,
        token::authority = lock_account,
    )]
    pub vault: Account<'info, TokenAccount>,

#[error_code]
pub enum LockerError {
    #[msg("Unlock timestamp must be in the future")]
    UnlockInPast,
    #[msg("Amount must be greater than zero")]
    ZeroAmount,
    #[msg("Lock has already been unlocked")]
    AlreadyUnlocked,
    #[msg("Cannot unlock before the unlock timestamp")]
    TooEarly,
}
 
#[event]
pub struct LockCreated {
    pub authority: Pubkey,
    pub mint: Pubkey,
    pub amount: u64,
    pub unlock_ts: i64,
}
 
#[event]
pub

anchor build
anchor keys list
# Update declare_id!() and Anchor.toml
anchor deploy --provider.cluster devnet

import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { PublicKey, SystemProgram } from "@solana/web3.js";
import { TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from "@solana/spl-token";
import { LiquidityLocker } from "../target/types/liquidity_locker";
 
const provider = anchor.AnchorProvider.env();
anchor.setProvider(provider);
const program = anchor.workspace.LiquidityLocker as Program<

describe("liquidity-locker", () => {
  it("creates a lock and prevents early unlock", async () => {
    // Create lock with 30-day duration
    // Attempt unlock immediately → expect LockerError::TooEarly
  });
 
  it("allows unlock after expiry", async () => {
    // Use solana-test-validator with --warp-slot to advance time
    // Unlock → verify tokens returned to depositor
  });
});

anchor test