We build DeFi and on-chain games on Solana.
Juge Labs is a studio building its own products — decentralised finance applications and games whose logic lives on-chain. We write the programs, the clients that call them, and the security review that runs before either ships.
Two things, both on-chain.
DeFi applications
Vaults, swaps and staking, and the account structures underneath them. Programs that hold value, which is why the constraint set gets written before the logic does.
On-chain games
Game state as program state. Deterministic logic, on-chain settlement, and enough care about transaction cost that the thing is actually playable.
Nothing is live yet.
The first applications are in progress. When one ships it will be listed here with its program address and its source, so the code can be read before it is trusted.
Five steps, in this order, every time.
Scope
What the program must guarantee, written before any code.
Program
Anchor and Rust, constraint set first, logic second.
Review
The eighteen on-chain vulnerability classes, walked in full.
Devnet
Deployed, exercised, and upgraded at least once before mainnet is considered.
Mainnet
Upgrade authority and keypair custody decided in advance, never after.
A close instruction, in full.
This is not a simplified excerpt. It is the constraint set a position-close instruction needs, in the order Anchor checks it.
use anchor_lang::prelude::*;
#[derive(Accounts)]
pub struct ClosePosition<'info> {
#[account(mut)]
pub owner: Signer<'info>,
#[account(
mut,
close = owner,
seeds = [b"position", owner.key().as_ref()],
bump = position.bump,
has_one = owner,
)]
pub position: Account<'info, Position>,
}
pub fn close_position(_ctx: Context<ClosePosition>) -> Result<()> {
Ok(())
}Returns the rent to the owner and zeroes the account, so the same address cannot be revived and reused.
Uses the bump stored at init instead of re-deriving one — the canonical PDA, not merely a valid one.
The ownership check. Leave it off and any signer can close any position.
Kit — the studio's own system.
Seven separable parts in thirty-eight palettes, generated from a single source file rather than drawn. It is the first thing this studio shipped, and it is on this page because the same discipline runs through the programs: small parts, defined edges, one rule applied the same way every time.