blizzard

name	blizzard
description	This skill should be used when the user asks about Blizzard, Blizzard staking, wWAL, WAL liquid staking, Walrus liquid staking, BlizzardStakeNFT, or wants to integrate with Blizzard on Sui. Covers WAL liquid staking, LST minting/burning, exchange rate syncing, transmutation, and stake NFT management.

Blizzard Protocol on Sui

Blizzard is a liquid staking protocol for WAL (Walrus) tokens on Sui. Users stake WAL to receive a liquid staking token (LST) that appreciates as staking rewards accrue. The protocol distributes staked WAL across multiple Walrus storage nodes, tracks exchange rates per epoch, and supports transmutation between different LST variants (e.g., to wWAL).

Package IDs

Package	Original ID	Description
Core	0x29ba7f7bc53e776f27a6d1289555ded2f407b4b1a799224f06b26addbcd1c33d	BlizzardStaking, LST mint/burn, exchange rates, nodes, fees, stake NFTs

Source Files

Decompiled Move source (v2):

• packages/mainnet_most_used/0x1a/6a6bfd4d6d2aa9af72f6804d9330873b44bfd0e1405005ae19587539fd2c58/decompiled_modules/

Architecture

• BlizzardStaking<T>: Shared object per LST type. Stores inner state (BlizzardStateV1) as a dynamic field. T is the LST coin type.
• BlizzardStateV1<T>: Core state containing fee balances (WAL + LST), historic exchange rates, treasury, total WAL value, allowed storage nodes, fee config.
• BlizzardNode: Per-node state tracking staked WAL positions (BigVector of StakedWal), per-epoch totals, and last synced values.
• BlizzardStakeNFT: NFT representing staked WAL that hasn't been converted to LST yet (used when staking after votes are finished in current epoch). Contains the inner StakedWal and activation epoch.
• BlizzardTreasury<T>: Wraps the TreasuryCap for the LST token, used for minting and burning.
• BlizzardFee: Fee configuration with mint, burn, transmute, and protocol fee rates (in BPS, max mint/burn/transmute: 1000 = 10%, max protocol: 3000 = 30%).
• ExchangeRate: Tracks LST/WAL exchange rate as a pair of u128 values for precise conversions.
• IX (Withdraw Instructions): Specifies which nodes and epoch/value pairs to withdraw from when burning LST.

Key Design: Walrus Staking Integration

Blizzard integrates with the Walrus staking system (0xfdc88f...::staking::Staking). WAL is staked to Walrus storage nodes, and the exchange rate between LST and WAL is synced per epoch based on staking rewards.

Two Minting Paths

1. mint: Standard path -- stake WAL to a node, receive LST immediately. Works when staking will activate in next epoch.
2. mint_after_votes_finished: When called after votes are finished for the current epoch, staking activates 2 epochs later. Returns a BlizzardStakeNFT instead of LST. The NFT can later be burned for LST via burn_stake_nft.

Constants

• Fees in BPS (basis points, 10000 = 100%)
• Max mint/burn/transmute fee: 1000 BPS (10%)
• Max protocol fee: 3000 BPS (30%)
• WAL token: 0x356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal::WAL
• wWAL token: 0xb1b0650a8862e30e3f604fd6c5838bc25464b8d3d827fbd58af7cb9685b832bf::wwal::WWAL

Key Modules

Module	Purpose
blizzard_protocol	Main entry: mint, burn_lst, burn_stake_nft, transmute, sync_exchange_rate, admin ops
blizzard_inner_protocol	Core logic: BlizzardStateV1, mint/burn implementation, exchange rate sync
blizzard_stake_nft	BlizzardStakeNFT: split, join, keep (for deferred minting)
blizzard_exchange_rate	ExchangeRate struct: LST/WAL conversion math
blizzard_fee	BlizzardFee config: mint, burn, transmute, protocol fees
blizzard_node	BlizzardNode: per-node staked WAL tracking
blizzard_withdraw_ix	IX struct: withdrawal instructions (node_id + epoch/value pairs)
blizzard_treasury	TreasuryCap wrapper for LST minting/burning
blizzard_historic_rate	Historic exchange rates per epoch
blizzard_acl	Admin access control (AdminWitness)
blizzard	Package witness (BLIZZARD) and init

Common Integration Patterns

Mint LST (Stake WAL)

// Stake WAL to a Walrus node, receive LST immediately
let lst_coin = blizzard_protocol::mint<LST_TYPE>(
    blizzard_staking,     // &mut BlizzardStaking<LST_TYPE>
    walrus_staking,       // &mut staking::Staking
    wal_coin,             // Coin<WAL>
    node_id,              // ID of the Walrus storage node
    allowed_versions,     // &AllowedVersions
    ctx
);
// Returns: Coin<LST_TYPE>

Mint After Votes Finished (Get Stake NFT)

// When staking after votes finished, get an NFT instead of LST
let stake_nft = blizzard_protocol::mint_after_votes_finished<LST_TYPE>(
    blizzard_staking, walrus_staking, wal_coin, node_id, allowed_versions, ctx
);
// Returns: BlizzardStakeNFT (can be burned for LST later)

Burn Stake NFT for LST

let lst_coin = blizzard_protocol::burn_stake_nft<LST_TYPE>(
    blizzard_staking, walrus_staking, stake_nft, allowed_versions, ctx
);

Burn LST (Unstake to StakedWal)

// Build withdrawal instructions
let epoch_values = blizzard_withdraw_ix::new_epoch_value_vector(epochs, values);
let ix = blizzard_withdraw_ix::new_ix(node_id, epoch_values);

let (remaining_lst, staked_wal_vec) = blizzard_protocol::burn_lst<LST_TYPE>(
    blizzard_staking, walrus_staking, lst_coin, vector[ix], allowed_versions, ctx
);
// Returns: (Coin<LST_TYPE> remainder, vector<StakedWal>)

Transmute LST to wWAL

let (remaining_lst, wwal_coin) = blizzard_protocol::transmute<LST_TYPE>(
    blizzard_staking,       // &mut BlizzardStaking<LST_TYPE>
    wwal_staking,           // &mut BlizzardStaking<WWAL>
    walrus_staking,         // &mut staking::Staking
    lst_coin,               // Coin<LST_TYPE>
    withdraw_ixs,           // vector<IX>
    allowed_versions,       // &AllowedVersions
    ctx
);
// Returns: (Coin<LST_TYPE> remainder, Coin<WWAL>)

Sync Exchange Rate

// Should be called periodically (once per epoch) to update rates
blizzard_protocol::sync_exchange_rate<LST_TYPE>(blizzard_staking, walrus_staking);

Query Exchange Rate

// Convert amounts between WAL and LST at a given epoch
let lst_amount = blizzard_protocol::to_lst_at_epoch<LST_TYPE>(
    blizzard_staking, epoch, wal_amount, round_up
);
let wal_amount = blizzard_protocol::to_wal_at_epoch<LST_TYPE>(
    blizzard_staking, epoch, lst_amount, round_up
);
// Both return Option<u64>

Stake NFT Operations

// Split a stake NFT
let new_nft = blizzard_stake_nft::split(&mut nft, amount, ctx);

// Join two stake NFTs
blizzard_stake_nft::join(&mut nft1, nft2);

// Transfer to sender
blizzard_stake_nft::keep(nft, ctx);

Query Fee Config

let fee_config = blizzard_protocol::fee_config<LST_TYPE>(blizzard_staking);
let mint_fee = blizzard_fee::mint(&fee_config);   // BPS
let burn_fee = blizzard_fee::burn(&fee_config);    // BPS

Related Skills

• sui-framework -- Core Sui types (Coin, Balance, Clock)