useanchor_lang::prelude::*;

useanchor_spl::token::{self,Token,TokenAccount,Transfer};

declare_id!("Vau1t11111111111111111111111111111111111111");

#[program]

pubmodvault{

usesuper::*;

pubfninitialize(ctx:Context<Initialize>,bump:u8)->Result<()>{

letvault=&mutctx.accounts.vault;

vault.authority=ctx.accounts.authority.key();

vault.bump=bump;

vault.total=0;

Ok(())

}

pubfndeposit(ctx:Context<Deposit>,amount:u64)->Result<()>{

require!(amount>0,VaultError::ZeroAmount);

token::transfer(ctx.accounts.transfer_ctx(),amount)?;

letvault=&mutctx.accounts.vault;

vault.total=vault.total.checked_add(amount).unwrap();

emit!(Deposited{owner:ctx.accounts.owner.key(),amount});

Ok(())

}

pubfnwithdraw(ctx:Context<Withdraw>,amount:u64)->Result<()>{

letvault=&mutctx.accounts.vault;

require!(vault.total>=amount,VaultError::Insufficient);

vault.total-=amount;

token::transfer(ctx.accounts.signed_ctx(),amount)?;

emit!(Withdrawn{owner:ctx.accounts.owner.key(),amount});

Ok(())

}

#[derive(Accounts)]

pubstructDeposit<'info>{

#[account(mut,seeds=[b"vault"],bump=vault.bump)]

pubvault:Account<'info,Vault>,

#[account(mut,token::authority=owner)]

pubfrom:Account<'info,TokenAccount>,

#[account(mut)]

pubto:Account<'info,TokenAccount>,

pubowner:Signer<'info>,

pubtoken_program:Program<'info,Token>,

}

#[account]

pubstructVault{

pubauthority:Pubkey,

pubtotal:u64,

pubbump:u8,

}

#[event]

pubstructDeposited{

pubowner:Pubkey,

pubamount:u64,

}

#[error_code]

pubenumVaultError{

#[msg("Amountmustbegreaterthanzero")]

ZeroAmount,

#[msg("Vaultholdslessthantheamount")]

Insufficient,

}

useanchor_lang::prelude::*;

useanchor_spl::token::{self,Token,TokenAccount,Transfer};

declare_id!("Vau1t11111111111111111111111111111111111111");

useanchor_lang::prelude::*;

useanchor_spl::token::{self,Token,TokenAccount,Transfer};

declare_id!("Vau1t11111111111111111111111111111111111111");

#[program]

pubmodvault{

usesuper::*;

pubfninitialize(ctx:Context<Initialize>,bump:u8)->Result<()>{

letvault=&mutctx.accounts.vault;

vault.authority=ctx.accounts.authority.key();

vault.bump=bump;

vault.total=0;

Ok(())

}

pubfndeposit(ctx:Context<Deposit>,amount:u64)->Result<()>{

require!(amount>0,VaultError::ZeroAmount);

token::transfer(ctx.accounts.transfer_ctx(),amount)?;

letvault=&mutctx.accounts.vault;

vault.total=vault.total.checked_add(amount).unwrap();

emit!(Deposited{owner:ctx.accounts.owner.key(),amount});

Ok(())

}

pubfnwithdraw(ctx:Context<Withdraw>,amount:u64)->Result<()>{

letvault=&mutctx.accounts.vault;

require!(vault.total>=amount,VaultError::Insufficient);

vault.total-=amount;

token::transfer(ctx.accounts.signed_ctx(),amount)?;

emit!(Withdrawn{owner:ctx.accounts.owner.key(),amount});

Ok(())

}

#[derive(Accounts)]

pubstructDeposit<'info>{

#[account(mut,seeds=[b"vault"],bump=vault.bump)]

pubvault:Account<'info,Vault>,

#[account(mut,token::authority=owner)]

pubfrom:Account<'info,TokenAccount>,

#[account(mut)]

pubto:Account<'info,TokenAccount>,

pubowner:Signer<'info>,

pubtoken_program:Program<'info,Token>,

}

#[account]

pubstructVault{

pubauthority:Pubkey,

pubtotal:u64,

pubbump:u8,

}

#[event]

pubstructDeposited{

pubowner:Pubkey,

pubamount:u64,

}

#[error_code]

pubenumVaultError{

#[msg("Amountmustbegreaterthanzero")]

ZeroAmount,

#[msg("Vaultholdslessthantheamount")]

Insufficient,

}

useanchor_lang::prelude::*;

useanchor_spl::token::{self,Token,TokenAccount,Transfer};

declare_id!("Vau1t11111111111111111111111111111111111111");

Weighless.

anchor buildtare build

The Anchor program you already wrote comes out at hand-written compute cost. Not a line changed, and a proof on chain that it is the same program.

$curl -fsSL https://api-production-aa6bb01d.up.railway.app/install.sh | sh

How the build works

squads_multisig_program, a production program, on the scale

Gross: 307,612; built with stock Anchor
Tare: 28,896; the framework’s own weight
Net: 278,716; built with Tare

Compute units for one call of each of its 34 instructions. 9% of the gross was tare.

squads_multisig_program: gross, tare and net compute units by instruction
Instruction, median units per call	Share of gross that is tare and net	Gross	Tare	Net
vault_transaction_create_from_buffer		21,013	2,048	18,965
batch_add_transaction		20,847	2,511	18,336
batch_execute_transaction		17,170	792	16,378
vault_transaction_create		15,285	2,045	13,240
vault_transaction_execute		14,671	328	14,343
multisig_create_v2		12,640	1,603	11,037
proposal_create		12,637	1,660	10,977
config_transaction_create		12,558	1,961	10,597
One call of each, over 129 inputs	9% of gross was tare	307,612	28,896	278,716

Its public source at 3a39735, built unchanged. Binary 773.2 KB to 759.3 KB. All 34 instructions and every corpus program

Four commands

$tare buildThe same workspace, the same source.
$tare weighGross, tare and net for every instruction.
$tare proveThe stock build and the Tare build, run side by side.
$tare attestThe result, on chain, for anyone to check.

What stays identical

Account layouts
Discriminators
Error codes and messages
Logs
The IDL
Events
Return data

Clients, indexers and every account already on chain keep working. The Tare build upgrades the program in place, at the same address.

How the proof works

Own testsGeneratedMainnet

Every input from the three corpora runs on both builds.

stock buildtare build

account bytes==account bytes

lamports==lamports

logs==logs

return data==return data

errors==errors

One difference fails the proof and prints the input. All equal, and tare attest writes the build hashes, the source commit, the corpus and the weights to a record on chain.

recordtare checktare flag

The three corpora and what is compared

189 open-source programs, 1,323 instructions, built unchanged

Gross: 6,295,676; every measured instruction, stock
Tare: 1,835,937; 29% of gross, the framework's own weight
Net: 4,459,739; the same instructions, built with Tare

The benchmark

weighany program

Its compute by instruction from recent mainnet transactions, its size and the rent it locks. By address, with no install.

TAREThe registry’s attest fee buys TARE and burns it.The token