MSG Chain CosmWasm 合约 Gas 优化指南

数据来源：MSG Chain 代码库核实

主网状态: No-Go — 当前 MSGChain 主网裁决为 No-Go，以下内容反映代码实际状态，不代表生产可用。

目录

1. CosmWasm Gas 模型
2. 存储优化
3. 处理优化
4. 消息优化
5. 合约架构优化
6. 优化技术清单
7. Gas 分析工具
8. 实战案例
9. 优化陷阱与反模式
10. 附录

1. CosmWasm Gas 模型

1.1 Gas 基础概念

在 MSG Chain 上，Gas 是衡量智能合约执行计算成本的单位。每笔交易都必须支付 Gas 费用，以激励验证者处理交易并防止滥用网络资源。

交易费用 = Gas 消耗 × Gas 价格 (umsg/gas)

示例计算：

某笔交易消耗 500,000 gas
Gas 价格: 1,000,000,000 attoMSG/gas
费用: 500,000 × 1,000,000,000 = 500,000,000,000,000 attoMSG = 0.0005 MSG

1.2 CosmWasm Gas 构成

CosmWasm 的 Gas 消耗由两大模块组成：

总 Gas = SDK Gas + Wasm 执行 Gas

1.3 Wasm 执行 Gas 详解

CosmWasm 使用基于 Wasm 的 Gas 计量机制，每个 Wasm 指令都会消耗 Gas：

// Wasm 指令的 Gas 成本示例
// i32.add   -> 1 gas
// i64.add   -> 1 gas
// call      -> 2 gas + 被调用函数 gas
// memory.grow -> 1000 gas/page
// br_if     -> 1 gas
// local.get -> 1 gas

MSG Chain 特有 Gas 参数：

1.4 Gas Meter 工作原理

CosmWasm 的 Gas Meter 在 Wasm 虚拟机层面进行插桩计量：

// Gas Meter 简化实现示意
pub struct GasMeter {
    limit: u64,
    consumed: u64,
}

impl GasMeter {
    pub fn consume(&mut self, amount: u64) -> Result<(), GasError> {
        let new_consumed = self.consumed.checked_add(amount)
            .ok_or(GasError::Overflow)?;
        if new_consumed > self.limit {
            return Err(GasError::OutOfGas {
                limit: self.limit,
                consumed: self.consumed,
            });
        }
        self.consumed = new_consumed;
        Ok(())
    }
}

关键行为：

• 当 Gas 耗尽时，执行立即中止
• 所有状态变更回滚
• 已消耗的 Gas 不退费
• 事件日志部分保留

1.5 Gas 估算方法

在执行交易前使用 simulate() 方法估算 Gas 消耗：

use cosmwasm_std::Coin;

// 通过 simulate 估算 Gas
let simulate_result = client
    .simulate(
        &contract_addr,
        &execute_msg,
        &[Coin::new(1000, "umsg")],
    )
    .await?;

let estimated_gas = simulate_result.gas_info?.gas_used;
let safe_gas = (estimated_gas as f64 * 1.3) as u64; // 加 30% 安全缓冲

Gas 估算最佳实践：

1.6 交易 Gas 限制

MSG Chain 的交易限制：

最大交易 Gas:  ~10,000,000
最大区块 Gas:  50,000,000
区块时间:      5 秒
最大交易/区块: ~500 (简单交易)

Gas 限制策略：

// 在交易中设置 Gas 限制
let tx = TxBuilder::new()
    .gas_limit(1_000_000u64)  // 设置上限
    .gas_price(gas_price)
    .msgs(vec![msg])
    .build();

// 合约内获取剩余 Gas
use cosmwasm_std::QuerierWrapper;

let remaining = deps.querier
    .query_wasm_smart::<GasInfo>(
        env.contract.address,
        &QueryMsg::GasRemaining {},
    )?;

// 手动 Gas 检查（分阶段执行时）
if remaining_gas < 100_000 {
    // 跳过非关键操作
    return Ok(Response::new()
        .add_attribute("warning", "gas_low_skipped_optional_ops"));
}

1.7 Gas 退款机制

MSG Chain 的 Gas 退款规则：

// Gas 退款计算
let gas_limit = 1_000_000;
let gas_used = 750_000;
let gas_price = GasPrice::new(Decimal::percent(2), "umsg");

// 退款 = (limit - used) * price
// 但不会全额退款——最多退款 limit 的 1/3
let max_refund = gas_limit.saturating_sub(gas_used).min(gas_limit / 3);

1.8 MSG Chain 特有 Gas 考量

由于 MSG Chain 使用 Dilithium-5 签名，交易验证 Gas 有所不同：

// Dilithium-5 签名验证 Gas 成本
// 单次验证: ~200,000 gas
// 批量验证: 首签 200,000 + 每额外签名 180,000

use cosmwasm_std::CosmosMsg;

// 需要多次签名验证的合约应批量处理
pub fn verify_batch(
    deps: DepsMut,
    signer: &[u8],
    msgs: &[CosmosMsg],
) -> Result<(), ContractError> {
    // 批量验证一次签名，而非逐条验证
    let combined_hash = hash_all(msgs);
    verify_dilithium_signature(deps, signer, &combined_hash)
}

2. 存储优化

2.1 存储成本模型

MSG Chain 使用 BadgerDB 作为底层存储引擎，CosmWasm 通过 cw-storage-plus 进行抽象：

存储成本 = 写入次数 × ~30,000 gas + 数据大小 × ~1 gas/byte

核心原则：存储操作是 Gas 消耗的主要瓶颈。

2.2 Key 命名优化

Key 的长度直接影响存储 Gas。

use cw_storage_plus::{Map, Item, IndexedMap, MultiIndex};

// ❌ 不推荐：Key 过长，字符串编码膨胀
pub const BALANCES: Map<&Addr, Uint128> = Map::new("token_balances_v2");
pub const ALLOWANCES: Map<(&Addr, &Addr), Uint128> = Map::new("token_allowances_v2");

// ✅ 推荐：短 Key + 固定长度
pub const BAL: Map<&[u8], Uint128> = Map::new("b");       // balances
pub const ALW: Map<(&[u8], &[u8]), Uint128> = Map::new("a"); // allowances
pub const TTL: Map<&[u8], u64> = Map::new("t");            // timelock

// ✅ 极致优化：单字节 Key
pub const S: Map<&[u8], Uint128> = Map::new("\x01");       // state
pub const B: Map<&[u8], Uint128> = Map::new("\x02");       // balances
pub const A: Map<(&[u8], &[u8]), Uint128> = Map::new("\x03"); // allowances
pub const M: Map<&[u8], u64> = Map::new("\x04");           // metadata

Key 长度 Gas 对比（100 万次写入的理论成本）：

注意：Key 长度的优化对写入成本影响有限（存储写入的大头是 KV 操作本身而非 Key 长度），但在大量读取场景下有累积优势。

2.3 数据序列化优化

CosmWasm 默认使用 JSON 进行序列化。选择正确的序列化格式对 Gas 有显著影响。

use cosmwasm_std::{to_binary, from_binary, Binary, StdResult};
use serde::{Serialize, Deserialize};

// ❌ 不推荐：直接存储完整结构体
#[derive(Serialize, Deserialize)]
pub struct Account {
    pub address: String,        // 变长
    pub balance: Uint128,       // 32 字节
    pub nonce: u64,             // 8 字节
    pub metadata: Option<String>, // 可为空
    pub last_tx: u64,           // 8 字节
}
// JSON 序列化大小示例: {"address":"msg1...","balance":"1000000","nonce":1,...}
// 约 100-150 字节

// ✅ 推荐：紧凑数据结构 + 二进制编码
#[derive(Serialize, Deserialize)]
pub struct CompactAccount {
    pub b: Uint128,  // balance
    pub n: u64,      // nonce
    pub t: u64,      // last_tx
}
// 二进制编码大小: 32 + 8 + 8 = 48 字节（固定长度）

// ✅ 极致优化：使用 packed 编码
pub fn encode_account(account: &CompactAccount) -> Vec<u8> {
    let mut buf = Vec::with_capacity(48);
    buf.extend_from_slice(&account.b.to_be_bytes());  // 32 bytes
    buf.extend_from_slice(&account.n.to_be_bytes());  // 8 bytes
    buf.extend_from_slice(&account.t.to_be_bytes());  // 8 bytes
    buf
}

pub fn decode_account(data: &[u8]) -> StdResult<CompactAccount> {
    if data.len() != 48 {
        return Err(StdError::generic_err("invalid data length"));
    }
    Ok(CompactAccount {
        b: Uint128::from_be_bytes(data[0..32].try_into().unwrap()),
        n: u64::from_be_bytes(data[32..40].try_into().unwrap()),
        t: u64::from_be_bytes(data[40..48].try_into().unwrap()),
    })
}

序列化格式对比：

2.4 使用 bounded 数据结构

固定大小数据结构避免动态内存分配。

// ❌ 不推荐：变长数组
pub struct Proposal {
    pub id: u64,
    pub title: String,             // 变长
    pub description: String,       // 变长，可能非常大
    pub voters: Vec<Addr>,         // 变长
    pub votes: Vec<Uint128>,       // 变长
}

// ✅ 推荐：使用 bounded 类型
pub const MAX_TITLE_LEN: usize = 64;
pub const MAX_DESC_LEN: usize = 512;
pub const MAX_VOTERS: usize = 100;

pub struct BoundedProposal {
    pub id: u64,
    pub title: [u8; 64],           // 固定 64 字节
    pub title_len: u32,            // 实际长度
    pub description: [u8; 512],    // 固定 512 字节
    pub desc_len: u32,             // 实际长度
}

pub struct VoterInfo {
    pub voter: [u8; 32],           // Addr 的 hash
    pub vote: Uint128,             // 32 字节
}

// ✅ 使用 ArrayVec（如果可用）或自定义固定缓冲
pub fn store_proposal(store: &mut dyn Storage, proposal: &BoundedProposal) {
    let key = proposal_key(proposal.id);
    let data = encode_bounded_proposal(proposal);
    store.set(&key, &data);
}

pub fn read_proposal(store: &dyn Storage, id: u64) -> Option<BoundedProposal> {
    let key = proposal_key(id);
    store.get(&key).map(|data| decode_bounded_proposal(&data))
}

2.5 批量读写优化

use cosmwasm_std::Storage;
use cw_storage_plus::Map;

// ❌ 不推荐：逐条读取
pub fn read_batch_naive(
    store: &dyn Storage,
    addresses: &[Addr],
) -> Vec<Uint128> {
    let mut balances = Vec::with_capacity(addresses.len());
    for addr in addresses {
        balances.push(
            BALANCES.load(store, addr).unwrap_or_default()
        );
    }
    balances
}

// ✅ 推荐：批量读取（减少 KV 查询次数）
pub fn read_batch_optimized(
    store: &dyn Storage,
    addresses: &[Addr],
) -> Vec<Uint128> {
    let mut balances = Vec::with_capacity(addresses.len());
    for addr in addresses {
        // 用 raw query 跳过反序列化开销
        let key = BALANCES.key(addr);
        match store.get(&key) {
            Some(data) => {
                let balance: Uint128 = from_binary(&Binary(data))
                    .unwrap_or_default();
                balances.push(balance);
            }
            None => balances.push(Uint128::zero()),
        }
    }
    balances
}

// ✅ 极优：使用 range 批量查询
pub fn read_all_balances(
    store: &dyn Storage,
    start: Option<&[u8]>,
    limit: usize,
) -> Vec<(Addr, Uint128)> {
    BALANCES
        .range(store, start, None, cosmwasm_std::Order::Ascending)
        .take(limit)
        .filter_map(|item| item.ok())
        .collect()
}

批量写入：

// ❌ 不推荐：逐条写入（每次都是独立 KV 操作）
pub fn transfer_batch_naive(
    store: &mut dyn Storage,
    transfers: &[(&Addr, Uint128)],
) -> StdResult<()> {
    for (addr, amount) in transfers {
        let mut balance = BALANCES.load(store, addr).unwrap_or_default();
        balance = balance.checked_add(*amount)?;
        BALANCES.save(store, addr, &balance)?;
    }
    Ok(())
}

// ✅ 推荐：缓存写入
pub fn transfer_batch_optimized(
    store: &mut dyn Storage,
    transfers: &[(Vec<u8>, Uint128)], // 预计算 key
) -> StdResult<()> {
    // 缓存读取
    let mut cache: Vec<(Vec<u8>, Uint128)> = Vec::with_capacity(transfers.len());
    for (key, _) in transfers {
        let balance = store.get(key)
            .map(|d| from_binary::<Uint128>(&Binary(d)).unwrap_or_default())
            .unwrap_or_default();
        cache.push((key.clone(), balance));
    }

    // 批量更新
    for ((key, _), (_, balance)) in transfers.iter().zip(cache.iter_mut()) {
        *balance = balance.checked_add(transfers.iter()
            .find(|(k, _)| k == key)
            .map(|(_, a)| *a)
            .unwrap_or(Uint128::zero()))?;
    }

    // 批量写入
    for (key, balance) in &cache {
        store.set(key, &to_binary(balance)?);
    }
    Ok(())
}

批量操作 Gas 对比（100 个账户）：

2.6 索引策略优化

use cw_storage_plus::{IndexedMap, MultiIndex, index_list};

// ❌ 不推荐：为每个查询创建独立索引
pub struct TokenIndexes<'a> {
    pub owner: MultiIndex<'a, Addr, TokenInfo, String>,
    pub collection: MultiIndex<'a, String, TokenInfo, String>,
    pub rarity: MultiIndex<'a, u8, TokenInfo, String>,
}

// 三个独立索引 = 三次额外写入

// ✅ 推荐：合并索引，减少冗余
pub struct CompactTokenIndexes<'a> {
    pub owner: MultiIndex<'a, &'a [u8], TokenInfo, String>,
}

// 利用复合 Key 减少索引数
pub fn token_key(owner: &Addr, token_id: &str) -> Vec<u8> {
    let mut key = Vec::with_capacity(32 + token_id.len());
    key.extend_from_slice(&hash_address(owner));
    key.extend_from_slice(token_id.as_bytes());
    key
}

索引策略决策树：

是否需要按字段查询？
├── 否 → 直接使用 Map，不创建索引
├── 是，查询频率低 → 用 range() 扫描过滤
├── 是，查询频率高 → 创建 MultiIndex
└── 是，查询频率高，字段固定 → 预计算查询前缀

2.7 缓存策略

use std::collections::HashMap;
use cosmwasm_std::Storage;

// ✅ 推荐：合约内缓存频繁读取的数据
pub struct CachedContract<'a> {
    storage: &'a mut dyn Storage,
    balance_cache: HashMap<Vec<u8>, Uint128>,
    metadata_cache: HashMap<Vec<u8>, TokenMetadata>,
}

impl<'a> CachedContract<'a> {
    pub fn get_balance(&mut self, addr: &[u8]) -> StdResult<Uint128> {
        if let Some(balance) = self.balance_cache.get(addr) {
            return Ok(*balance);
        }
        let key = BAL.key(addr);
        let balance = self.storage.get(&key)
            .map(|d| from_binary::<Uint128>(&Binary(d)).unwrap_or_default())
            .unwrap_or_default();
        self.balance_cache.insert(addr.to_vec(), balance);
        Ok(balance)
    }

    pub fn flush(&mut self) -> StdResult<()> {
        for (addr, balance) in self.balance_cache.drain() {
            let key = BAL.key(&addr);
            self.storage.set(&key, &to_binary(&balance)?);
        }
        Ok(())
    }
}

缓存模式 Gas 对比：

2.8 存储布局优化

// ❌ 不推荐：所有数据放在同一命名空间
pub const STATE: Item<ContractState> = Item::new("state");
pub const TOKENS: Map<u64, TokenInfo> = Map::new("tokens");
pub const BALANCES: Map<&Addr, Uint128> = Map::new("balances");
pub const METADATA: Map<u64, TokenMetadata> = Map::new("metadata");

// ✅ 推荐：按访问频率分区存储
//
// 热数据命名空间 (高频访问):
// \x01 = 合约状态 (每次调用都需要)
// \x02 = 账户余额 (转账时频繁读写)
// \x03 = 当前 nonce (每次操作递增)
//
// 冷数据命名空间 (低频访问):
// \x10 = 历史记录 (仅在查询时读取)
// \x11 = 审计日志 (仅在审计时读取)
// \x12 = 元数据 (仅铸造和查询时)

pub const HOT_STATE: Item<ContractState> = Item::new("\x01");
pub const HOT_BAL: Map<&[u8], Uint128> = Map::new("\x02");
pub const HOT_NONCE: Item<u64> = Item::new("\x03");
pub const COLD_HISTORY: Map<u64, TxHistory> = Map::new("\x10");
pub const COLD_AUDIT: Map<u64, AuditEntry> = Map::new("\x11");
pub const COLD_META: Map<u64, TokenMeta> = Map::new("\x12");

// 利用 BadgerDB 的 key 排序特性
// BadgerDB 对前缀连续的数据有更好的缓存表现

2.9 使用 Item 替代 Singleton

use cw_storage_plus::Item;

// ❌ 不推荐：使用已废弃的 Singleton
// use cosmwasm_storage::Singleton;
// const STATE: Singleton<ContractState> = Singleton::new("state");

// ✅ 推荐：使用 Item（更轻量，更安全）
pub const STATE: Item<ContractState> = Item::new("\x01");

// ❌ 不推荐：频繁读写完整状态
pub fn update_nonce_naive(store: &mut dyn Storage) -> StdResult<()> {
    let mut state = STATE.load(store)?;
    state.nonce += 1;
    STATE.save(store, &state)
}

// ✅ 推荐：分离非关键状态，减少序列化开销
pub const NONCE: Item<u64> = Item::new("\x02");

pub fn update_nonce_optimized(store: &mut dyn Storage) -> StdResult<()> {
    let mut nonce = NONCE.load(store)?;
    nonce += 1;
    NONCE.save(store, &nonce)
}

2.10 延迟写入与合并写入

// ✅ 推荐：延迟非关键写入
pub struct DeferredWrite {
    writes: Vec<(Vec<u8>, Vec<u8>)>,    // (key, value)
    deletes: Vec<Vec<u8>>,              // keys to delete
}

impl DeferredWrite {
    pub fn schedule_write(&mut self, key: Vec<u8>, value: Vec<u8>) {
        self.writes.push((key, value));
    }

    pub fn schedule_delete(&mut self, key: Vec<u8>) {
        self.deletes.push(key);
    }

    pub fn flush(&self, store: &mut dyn Storage) {
        for (key, value) in &self.writes {
            store.set(key, value);
        }
        for key in &self.deletes {
            store.remove(key);
        }
    }
}

// 在合约入口处：
// 1. 读取所有需要的数据到内存
// 2. 执行所有计算
// 3. 收集所有写入操作
// 4. 批量写入

3. 处理优化

3.1 最小化分支

Wasm 虚拟机中，分支预测失败的惩罚较高。减少复杂分支可显著提升性能。

// ❌ 不推荐：多层嵌套分支
pub fn calculate_fee_naive(amount: Uint128, tier: u8) -> Uint128 {
    let fee_rate = if tier == 0 {
        Decimal::percent(10)
    } else if tier == 1 {
        Decimal::percent(5)
    } else if tier == 2 {
        Decimal::percent(2)
    } else if tier == 3 {
        Decimal::percent(1)
    } else {
        Decimal::percent(0)
    };
    amount * fee_rate
}

// ✅ 推荐：查找表消除分支
const FEE_RATES: [Decimal; 5] = [
    Decimal::percent(10),
    Decimal::percent(5),
    Decimal::percent(2),
    Decimal::percent(1),
    Decimal::zero(),
];

pub fn calculate_fee_optimized(amount: Uint128, tier: u8) -> Uint128 {
    let rate = FEE_RATES.get(tier as usize).unwrap_or(&Decimal::zero());
    amount * *rate
}

// ✅ 极致：位运算替代分支
pub fn min_uint128(a: Uint128, b: Uint128) -> Uint128 {
    // 条件移动替代分支
    let mask = if a < b { Uint128::MAX } else { Uint128::zero() };
    (a & mask) | (b & !mask)
    // 注意：实际 CosmWasm 中应使用 std::cmp::min，这里展示原理
}

3.2 数学运算优化

use cosmwasm_std::{Uint128, Decimal, StdResult};

// ❌ 不推荐：不必要的精度转换
pub fn calculate_swap_naive(
    reserve_in: Uint128,
    reserve_out: Uint128,
    amount_in: Uint128,
) -> StdResult<Uint128> {
    // 大量 Decimal 转换，消耗额外 Gas
    let reserve_in_dec = Decimal::from_ratio(reserve_in, Uint128::one());
    let reserve_out_dec = Decimal::from_ratio(reserve_out, Uint128::one());
    let amount_in_dec = Decimal::from_ratio(amount_in, Uint128::one());

    let numerator = amount_in_dec * reserve_out_dec;
    let denominator = reserve_in_dec + amount_in_dec;
    let result = numerator / denominator;

    Ok(result.to_uint_floor())
}

// ✅ 推荐：整数数学
pub fn calculate_swap_optimized(
    reserve_in: Uint128,
    reserve_out: Uint128,
    amount_in: Uint128,
) -> StdResult<Uint128> {
    // 直接整数运算，无 Decimal 转换
    // amount_out = (amount_in * reserve_out) / (reserve_in + amount_in)
    let numerator = amount_in.checked_mul(reserve_out)?;
    let denominator = reserve_in.checked_add(amount_in)?;
    numerator.checked_div(denominator)
}

// ✅ 推荐：预计算常数
// ❌ 不推荐运行时重复计算
// Decimal::percent(30) 每次调用都计算

// ✅ 推荐：编译时常量
pub const FEE_RATE: Decimal = Decimal::percent(30);
pub const BASIS_POINT: Uint128 = Uint128::new(10000);

// ❌ 不推荐：浮点数模拟
pub fn sqrt_naive(x: Uint128) -> Uint128 {
    // 牛顿迭代法实现 sqrt，每次迭代消耗 Gas
    let mut z = x;
    for _ in 0..10 {
        if z.is_zero() { break; }
        z = (z + x / z) / Uint128::new(2);
    }
    z
}

// ✅ 推荐：查表法 sqrt（精度可接受时）
const SQRT_TABLE: [(Uint128, Uint128); 32] = [
    (Uint128::new(0), Uint128::new(0)),
    (Uint128::new(1), Uint128::new(1)),
    // ... 预计算常用值的平方根
];

pub fn sqrt_lookup(x: Uint128) -> Uint128 {
    // 对小值使用查表，大值使用迭代
    if x < Uint128::new(1000) {
        SQRT_TABLE.iter()
            .find(|(k, _)| *k >= x)
            .map(|(_, v)| *v)
            .unwrap_or(x)
    } else {
        sqrt_newton(x)
    }
}

数学运算 Gas 对比：

3.3 避免不必要的内存分配

// ❌ 不推荐：频繁内存分配
pub fn process_tx_naive(tx: &Transaction) -> StdResult<TransactionResult> {
    let mut logs = Vec::new();  // 每次调用分配
    for event in &tx.events {
        let log = format!("event:{}", event.kind);  // String 分配
        logs.push(log);
    }

    let mut result = TransactionResult::default();
    result.logs = logs;
    result.hash = tx.hash.clone();  // 不必要的 clone
    Ok(result)
}

// ✅ 推荐：预分配 + 避免 clone
pub fn process_tx_optimized(tx: &Transaction) -> StdResult<TransactionResult> {
    let mut logs = Vec::with_capacity(tx.events.len()); // 预分配
    for event in &tx.events {
        logs.push(event.kind.to_string()); // 仅在需要时分配
    }

    Ok(TransactionResult {
        logs,
        hash: tx.hash.clone(), // 必要 clone（需要所有权）
    })
}

// ✅ 极致：使用引用
pub fn process_tx_ref<'a>(tx: &'a Transaction) -> TransactionResult<'a> {
    TransactionResult {
        logs: tx.events.iter().map(|e| &e.kind).collect(),
        hash: &tx.hash,
    }
}

3.4 字符串处理优化

// ❌ 不推荐：String 拼接
pub fn build_message_naive(parts: &[&str]) -> String {
    let mut result = String::new();
    for part in parts {
        result.push_str(part);
        result.push(',');
    }
    result.pop(); // 去掉最后的逗号
    result
}

// ✅ 推荐：预分配容量
pub fn build_message_optimized(parts: &[&str]) -> String {
    let total_len: usize = parts.iter().map(|s| s.len()).sum::<usize>() + parts.len();
    let mut result = String::with_capacity(total_len);
    for (i, part) in parts.iter().enumerate() {
        if i > 0 { result.push(','); }
        result.push_str(part);
    }
    result
}

// ❌ 不推荐：使用 String 作为 Map key
pub fn get_value(map: &Map<String, Value>, key: &str) -> Option<Value> {
    map.may_load(&STORAGE, &key.to_string()).unwrap() // to_string() 分配
}

// ✅ 推荐：使用 &str 或 &[u8]
pub fn get_value_opt(map: &Map<&[u8], Value>, key: &[u8]) -> Option<Value> {
    map.may_load(&STORAGE, key).unwrap()
}

3.5 内联小函数

// ❌ 不推荐：频繁调用小函数产生调用开销
pub fn is_valid_amount(amount: Uint128) -> bool {
    !amount.is_zero() && amount <= Uint128::new(1_000_000)
}

pub fn process_deposit(amount: Uint128) -> StdResult<()> {
    if !is_valid_amount(amount) {
        return Err(StdError::generic_err("invalid amount"));
    }
    // ...
}

// ✅ 推荐：手动内联（编译器可能不会内联跨 crate 函数）
pub fn process_deposit_opt(amount: Uint128) -> StdResult<()> {
    if amount.is_zero() || amount > Uint128::new(1_000_000) {
        return Err(StdError::generic_err("invalid amount"));
    }
    // ...
}

// ✅ Rust 中可以使用 #[inline(always)] 提示编译器
#[inline(always)]
pub fn is_valid_amount(amount: Uint128) -> bool {
    !amount.is_zero() && amount <= Uint128::new(1_000_000)
}

3.6 循环优化

// ❌ 不推荐：范围检查每次迭代
pub fn sum_array_naive(values: &[Uint128]) -> Uint128 {
    let mut sum = Uint128::zero();
    for i in 0..values.len() {
        sum += values[i]; // bounds check in debug
    }
    sum
}

// ✅ 推荐：迭代器避免边界检查
pub fn sum_array_optimized(values: &[Uint128]) -> Uint128 {
    values.iter().fold(Uint128::zero(), |acc, v| acc + *v)
}

// ✅ 极致：循环展开 (unrolling)
pub fn sum_array_unrolled(values: &[Uint128]) -> Uint128 {
    let len = values.len();
    let mut sum = Uint128::zero();
    let mut i = 0;

    // 每次处理 4 个元素
    while i + 3 < len {
        sum += values[i] + values[i + 1] + values[i + 2] + values[i + 3];
        i += 4;
    }

    // 处理剩余元素
    while i < len {
        sum += values[i];
        i += 1;
    }
    sum
}

// ❌ 不推荐：循环内重复查询
pub fn batch_load_naive(
    store: &dyn Storage,
    ids: &[u64],
) -> Vec<Option<Data>> {
    let mut results = Vec::with_capacity(ids.len());
    for id in ids {
        // 每次循环都通过 Map 接口查询
        results.push(DATA.may_load(store, *id).unwrap());
    }
    results
}

// ✅ 推荐：使用 range 批量查询
pub fn batch_load_optimized(
    store: &dyn Storage,
    ids: &[u64],
) -> Vec<Option<Data>> {
    // 排序后使用 range 查询
    let mut sorted_ids = ids.to_vec();
    sorted_ids.sort();

    let results: Vec<Option<Data>> = DATA
        .range(store, None, None, Order::Ascending)
        .filter(|r| {
            r.as_ref().map(|(k, _)| sorted_ids.binary_search(k).is_ok())
                .unwrap_or(false)
        })
        .map(|r| r.map(|(_, v)| v).ok())
        .collect();

    results
}

3.7 错误处理优化

// ❌ 不推荐：错误字符串分配
pub fn validate_input_naive(amount: Uint128) -> Result<(), ContractError> {
    if amount.is_zero() {
        return Err(ContractError::CustomError {
            msg: format!("zero amount is not allowed, got: {}", amount), // String 分配
        });
    }
    if amount > Uint128::new(1_000_000) {
        return Err(ContractError::CustomError {
            msg: format!("amount too large: {}, max: 1000000", amount), // String 分配
        });
    }
    Ok(())
}

// ✅ 推荐：无分配的错误类型
#[derive(Error, Debug)]
pub enum ContractError {
    #[error("Zero amount")]
    ZeroAmount,

    #[error("Amount exceeds max")]
    AmountTooHigh,

    #[error("Unauthorized")]
    Unauthorized,

    #[error("Storage error: {0}")]
    Std(#[from] StdError),
}

pub fn validate_input_opt(amount: Uint128) -> Result<(), ContractError> {
    if amount.is_zero() {
        return Err(ContractError::ZeroAmount); // 无分配
    }
    if amount > Uint128::new(1_000_000) {
        return Err(ContractError::AmountTooHigh); // 无分配
    }
    Ok(())
}

// ❌ 不推荐：热点路径中的 unwrap()
pub fn hot_path_unwrap(value: Option<Uint128>) -> Uint128 {
    value.unwrap() // panic 路径产生额外代码
}

// ✅ 推荐：提供默认值
pub fn hot_path_default(value: Option<Uint128>) -> Uint128 {
    value.unwrap_or_else(Uint128::zero) // 无 panic
}

// ✅ 或者使用 ? 操作符传播
pub fn hot_path_propagate(value: Option<Uint128>) -> StdResult<Uint128> {
    value.ok_or_else(|| StdError::generic_err("missing value"))
}

错误处理 Gas 对比：

3.8 条件执行优化

// ❌ 不推荐：每次调用都执行完整逻辑
pub fn execute_transfer(
    deps: DepsMut,
    info: MessageInfo,
    to: Addr,
    amount: Uint128,
) -> Result<Response, ContractError> {
    // 即使 amount 为 0 也会执行完整的读-改-写
    let mut balance = BALANCES.load(deps.storage, &info.sender)?;
    balance = balance.checked_sub(amount)?;
    BALANCES.save(deps.storage, &info.sender, &balance)?;

    let mut to_balance = BALANCES.load(deps.storage, &to)?;
    to_balance = to_balance.checked_add(amount)?;
    BALANCES.save(deps.storage, &to, &to_balance)?;

    Ok(Response::new()
        .add_attribute("action", "transfer")
        .add_attribute("from", &info.sender)
        .add_attribute("to", &to)
        .add_attribute("amount", amount.to_string()))
}

// ✅ 推荐：早期返回减少无效执行
pub fn execute_transfer_opt(
    deps: DepsMut,
    info: MessageInfo,
    to: Addr,
    amount: Uint128,
) -> Result<Response, ContractError> {
    // 早期返回
    if amount.is_zero() {
        return Ok(Response::new()
            .add_attribute("action", "transfer")
            .add_attribute("amount", "0"));
    }

    if info.sender == to {
        return Err(ContractError::SelfTransfer);
    }

    let mut balance = BALANCES.load(deps.storage, &info.sender)?;
    balance = balance.checked_sub(amount)?;
    BALANCES.save(deps.storage, &info.sender, &balance)?;

    let mut to_balance = BALANCES.load(deps.storage, &to)?;
    to_balance = to_balance.checked_add(amount)?;
    BALANCES.save(deps.storage, &to, &to_balance)?;

    Ok(Response::new()
        .add_attribute("action", "transfer")
        .add_attribute("amount", amount.to_string()))
}

3.9 减少类型转换

// ❌ 不推荐：String ↔ &str ↔ Addr 反复转换
pub fn process_addr_naive(deps: DepsMut, addr_str: &str) -> StdResult<Addr> {
    let addr_string = addr_str.to_string();  // allocation
    let addr = deps.api.addr_validate(&addr_string)?;
    Ok(addr)
}

// ✅ 推荐：直接使用 &str
pub fn process_addr_opt(deps: DepsMut, addr_str: &str) -> StdResult<Addr> {
    deps.api.addr_validate(addr_str)
}

// ❌ 不推荐：Uint128 <-> String <-> 数字多方转换
pub fn calculate_naive(amount_str: &str) -> StdResult<Uint128> {
    let amount = Uint128::from_str(amount_str)?;
    let result = amount.checked_mul(Uint128::new(2))?;
    Ok(result)
}

// ✅ 推荐：全程使用 Uint128
pub fn calculate_opt(amount: Uint128) -> StdResult<Uint128> {
    amount.checked_mul(Uint128::new(2))
}

4. 消息优化

4.1 批量消息

将多个原子操作合并为一条消息，减少交易开销。

use cosmwasm_std::{Response, CosmosMsg, BankMsg, WasmMsg, Coin};

// ❌ 不推荐：逐条转账（多条 BankMsg）
pub fn distribute_naive(
    recipients: &[(&Addr, Uint128)],
) -> Response {
    let mut response = Response::new();
    for (addr, amount) in recipients {
        response = response.add_message(BankMsg::Send {
            to_address: addr.to_string(),
            amount: vec![Coin::new(amount.u128(), "umsg")],
        });
    }
    response
}

// ✅ 推荐：批量消息合并（通过合约聚合）
pub fn distribute_optimized(
    recipients: &[(&Addr, Uint128)],
) -> Result<Response, ContractError> {
    // 验证总金额
    let total: Uint128 = recipients.iter()
        .map(|(_, a)| *a)
        .sum();

    // 合并：先扣总金额，再分发展开
    let mut msgs: Vec<CosmosMsg> = Vec::with_capacity(recipients.len() + 1);

    // 添加批量转账消息
    for (addr, amount) in recipients {
        msgs.push(BankMsg::Send {
            to_address: addr.to_string(),
            amount: vec![Coin::new(amount.u128(), "umsg")],
        }.into());
    }

    Ok(Response::new()
        .add_messages(msgs)
        .add_attribute("action", "batch_distribute")
        .add_attribute("count", recipients.len().to_string()))
}

批量 vs 逐条对比（N 笔转账）：

4.2 消息大小优化

// ❌ 不推荐：消息中包含冗余数据
#[derive(Serialize, Deserialize)]
pub struct TransferMsg {
    pub token_contract: String,  // 已知上下文，可省略
    pub from: String,            // 由 info.sender 提供
    pub to: String,
    pub amount: Uint128,
    pub memo: Option<String>,    // 非必要
}

// ✅ 推荐：最小化消息内容
#[derive(Serialize, Deserialize)]
pub struct TransferMsgOpt {
    pub to: String,
    pub amount: Uint128,
}

// ❌ 不推荐：Base64 编码的 Binary 过大
#[derive(Serialize, Deserialize)]
pub struct StoreDataMsg {
    pub data: Binary,  // JSON 中 Base64 编码，膨胀 ~33%
}

// ✅ 推荐：使用更紧凑的编码或分片
#[derive(Serialize, Deserialize)]
pub struct StoreDataMsgOpt {
    pub data_hash: [u8; 32],  // 仅存 hash，大数据通过外部存储
}

// ❌ 不推荐：消息中包含完整对象
#[derive(Serialize, Deserialize)]
pub struct CreatePositionMsg {
    pub owner: Addr,
    pub collateral: Coin,
    pub debt: Coin,
    pub interest_rate: Decimal,
    pub duration: u64,
    pub metadata: Metadata,  // 大对象
}

// ✅ 推荐：发送 minimal 消息，其余数据在合约内构造
#[derive(Serialize, Deserialize)]
pub struct CreatePositionMsgOpt {
    pub collateral: Coin,
    pub duration: u64,  // 仅包含用户指定的参数
}

消息大小对比：

4.3 Wasm-optimized 数据类型

// ❌ 不推荐：使用标准库类型
pub struct Proposal {
    pub id: u64,
    pub title: String,
    pub description: String,
    pub proposer: String,
    pub start_height: u64,
    pub end_height: u64,
}

// ✅ 推荐：使用 CosmWasm 优化类型
pub struct ProposalOpt {
    pub id: u64,
    pub title: String,           // 使用 short string optimization
    pub description: String,     // 大字符串使用 Box<str>
    pub proposer: Addr,          // 已验证地址，避免重复验证
    pub start_height: u64,
    pub end_height: u64,
}

// ✅ 推荐：使用 cosmwasm_std 类型
use cosmwasm_std::{Uint128, Decimal, Addr, Coin, Timestamp};

// Uint128 比 String 更高效
// ❌ 不推荐
let amount: String = "1000000".to_string();
// ✅ 推荐
let amount: Uint128 = Uint128::new(1_000_000);

// Addr 比 String 更高效（已验证）
// ❌ 不推荐
let addr: String = "msg1...".to_string();
// ✅ 推荐
let addr: Addr = deps.api.addr_validate("msg1...")?;

类型 Gas 对比：

4.4 子消息 Gas 管理

use cosmwasm_std::{SubMsg, WasmMsg, ReplyOn};

// ❌ 不推荐：所有子消息都使用 ReplyOn::Always
pub fn execute_with_subs_naive(
    contract: &Addr,
    msgs: &[WasmMsg],
) -> Response {
    let subs: Vec<SubMsg> = msgs.iter()
        .map(|msg| SubMsg::new(msg.clone()))
        .collect(); // 默认 ReplyOn::Always

    Response::new().add_submessages(subs)
}

// ✅ 推荐：仅在必要时 Reply
pub fn execute_with_subs_opt(
    contract: &Addr,
    msgs: &[WasmMsg],
) -> Response {
    let mut subs: Vec<SubMsg> = Vec::with_capacity(msgs.len());

    for (i, msg) in msgs.iter().enumerate() {
        let reply_on = if i == msgs.len() - 1 {
            // 只关心最后一个子消息的结果
            ReplyOn::Success
        } else {
            // 其他不需要回复
            ReplyOn::Never
        };
        subs.push(SubMsg {
            id: i as u64,
            msg: msg.clone().into(),
            reply_on,
            gas_limit: None,
        });
    }

    Response::new().add_submessages(subs)
}

// ✅ 推荐：设置子消息 Gas 限制
pub fn execute_with_gas_limit(
    contract: &Addr,
    msg: WasmMsg,
    gas_budget: u64,
) -> SubMsg {
    SubMsg {
        id: 1,
        msg: msg.into(),
        reply_on: ReplyOn::Success,
        gas_limit: Some(gas_budget), // 限制子消息 Gas，防止耗尽
    }
}

ReplyOn 模式 Gas 对比：

4.5 事件优化

// ❌ 不推荐：冗余事件属性
pub fn emit_events_naive(response: &mut Response) {
    response.add_attribute("action", "transfer");
    response.add_attribute("module", "token");
    response.add_attribute("version", "1.0");
    response.add_attribute("sender", &sender);
    response.add_attribute("recipient", &recipient);
    response.add_attribute("amount", amount.to_string());
    response.add_attribute("timestamp", env.block.time.to_string());
    response.add_attribute("height", env.block.height.to_string());
    response.add_attribute("tx_hash", env.transaction.unwrap().index.to_string());
}

// ✅ 推荐：最小化事件属性
pub fn emit_events_opt(response: &mut Response, sender: &Addr, recipient: &Addr, amount: Uint128) {
    response.add_attribute("a", "transfer");  // 短 key
    response.add_attribute("f", sender);      // 单字符 key
    response.add_attribute("t", recipient);
    response.add_attribute("a", amount);      // 复用 "a" 表示 amount
}

// ✅ 推荐：使用事件类型区分而非属性
pub struct TransferEvent {
    pub from: Addr,
    pub to: Addr,
    pub amount: Uint128,
}

impl From<TransferEvent> for cosmwasm_std::Event {
    fn from(e: TransferEvent) -> Self {
        cosmwasm_std::Event::new("transfer")
            .add_attribute("f", e.from)
            .add_attribute("t", e.to)
            .add_attribute("a", e.amount)
    }
}

事件 Gas 对比：

4.6 使用 CosmosMsg 而非自定义消息

// ❌ 不推荐：不必要的自定义消息包装
pub fn send_tokens_naive(
    contract: Addr,
    recipient: Addr,
    amount: Coin,
) -> CosmosMsg {
    CosmosMsg::Wasm(WasmMsg::Execute {
        contract_addr: contract.to_string(),
        msg: to_binary(&ExecuteMsg::Transfer {
            recipient: recipient.to_string(),
            amount,
        }).unwrap(),
        funds: vec![],
    })
}

// ✅ 推荐：使用原生 BankMsg（如果仅转账）
pub fn send_tokens_opt(
    recipient: Addr,
    amount: Coin,
) -> CosmosMsg {
    CosmosMsg::Bank(BankMsg::Send {
        to_address: recipient.to_string(),
        amount: vec![amount],
    })
}

// ✅ 推荐：使用原生 StakingMsg（如果涉及质押）
use cosmwasm_std::{StakingMsg, DistributionMsg};

pub fn delegate_opt(
    validator: Addr,
    amount: Coin,
) -> CosmosMsg {
    CosmosMsg::Staking(StakingMsg::Delegate {
        validator: validator.to_string(),
        amount,
    })
}

原生 vs 自定义消息 Gas 对比：

5. 合约架构优化

5.1 单合约 vs 工厂模式

// ❌ 不推荐：每个实例都部署独立合约
// 每个 LP Token 都是一个独立合约
// 100 个 LP = 100 次部署 = 100 × 存储开销

// ✅ 推荐：单合约 + ID 路由
pub struct SingleContract {
    // 所有池子共享一个合约
    pools: Map<&[u8], PoolInfo>,
    lp_balances: Map<(&[u8], &[u8]), Uint128>,
    lp_total_supply: Map<&[u8], Uint128>,
}

impl SingleContract {
    pub fn execute_swap(
        store: &mut dyn Storage,
        pool_id: &[u8],
        sender: &[u8],
        amount: Uint128,
    ) -> StdResult<Response> {
        let mut pool = POOLS.load(store, pool_id)?;
        // ... swap logic
        POOLS.save(store, pool_id, &pool)?;
        Ok(Response::new())
    }
}

工厂 vs 单合约对比：

5.2 共享存储模式

// ✅ 推荐：中央共享存储合约
//
// 架构：Registry 合约持有所有状态
//       功能合约通过查询 Registry 获取数据
//
// ┌─────────────┐     ┌──────────────┐
// │  Token A     │────▶│              │
// └─────────────┘     │   Registry   │
// ┌─────────────┐     │  (存储层)    │
// │  Token B     │────▶│              │
// └─────────────┘     └──────────────┘
// ┌─────────────┐
// │  Token C     │────▶
// └─────────────┘

pub struct RegistryContract {
    // 全局状态
    pub token_info: Map<&[u8], TokenInfo>,
    pub balances: Map<(&[u8], &[u8]), Uint128>,
    pub allowances: Map<(&[u8], &[u8], &[u8]), Uint128>,
}

// 功能合约通过 Registry 的 query 获取数据
pub fn get_balance_query(registry: &Addr, token: &[u8], owner: &[u8]) -> QueryMsg {
    QueryMsg::Balance {
        token: token.to_vec(),
        owner: owner.to_vec(),
    }
}

// 功能合约通过 Registry 的 execute 修改数据
pub fn transfer_execute(
    registry: &Addr,
    token: &[u8],
    from: &[u8],
    to: &[u8],
    amount: Uint128,
) -> CosmosMsg {
    CosmosMsg::Wasm(WasmMsg::Execute {
        contract_addr: registry.to_string(),
        msg: to_binary(&ExecuteMsg::Transfer {
            token: token.to_vec(),
            from: from.to_vec(),
            to: to.to_vec(),
            amount,
        }).unwrap(),
        funds: vec![],
    })
}

共享存储 Gas 节省：

5.3 Proxy 存储模式

// ✅ 推荐：Proxy 模式分离逻辑和存储
//
// ┌──────────────┐     ┌──────────────┐
// │   Proxy      │────▶│  Logic       │
// │  (存储层)    │     │  (无状态)    │
// │  - balances  │     │  - swap()    │
// │  - config    │     │  - add_lp()  │
// └──────────────┘     └──────────────┘

// Proxy 合约：永久存储
pub struct ProxyContract {
    pub balances: Map<&[u8], Uint128>,
    pub config: Item<Config>,
}

impl ProxyContract {
    // 委托调用 Logic 合约
    pub fn execute_delegate(
        deps: DepsMut,
        env: Env,
        info: MessageInfo,
        logic_addr: Addr,
        msg: Binary,
    ) -> Result<Response, ContractError> {
        // 验证 logic_addr 是授权逻辑合约
        let config = CONFIG.load(deps.storage)?;
        if logic_addr != config.logic_contract {
            return Err(ContractError::Unauthorized);
        }

        // 通过 WasmMsg 调用逻辑合约
        Ok(Response::new()
            .add_message(WasmMsg::Execute {
                contract_addr: logic_addr.to_string(),
                msg,
                funds: info.funds,
            }))
    }
}

// Logic 合约：通过查询 Proxy 获取状态
pub fn execute_swap_logic(
    deps: DepsMut,
    proxy_addr: Addr,
    user: &Addr,
    amount: Uint128,
) -> Result<Response, ContractError> {
    // 查询 Proxy 中的用户余额
    let balance: Uint128 = deps.querier.query_wasm_smart(
        proxy_addr.clone(),
        &ProxyQuery::Balance {
            owner: user.to_string(),
        },
    )?;

    // 执行计算
    let new_balance = balance.checked_sub(amount)?;

    // 通过子消息更新 Proxy 状态
    Ok(Response::new()
        .add_message(WasmMsg::Execute {
            contract_addr: proxy_addr.to_string(),
            msg: to_binary(&ProxyExecute::UpdateBalance {
                owner: user.to_string(),
                new_balance,
            })?,
            funds: vec![],
        }))
}

5.4 懒初始化

// ❌ 不推荐：在 instantiate 中初始化所有数据
#[entry_point]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult<Response> {
    // 即使可能永远不会用到，也全部初始化
    CONFIG.save(deps.storage, &Config {
        admin: deps.api.addr_validate(&msg.admin)?,
        fee_rate: msg.fee_rate,
        paused: msg.paused,
        max_tx_size: msg.max_tx_size,
        supported_tokens: msg.supported_tokens, // 大 Vec
        ... // 大量初始化
    })?;

    // 预初始化所有支持的代币余额
    for token in &msg.supported_tokens {
        BALANCES.save(deps.storage, (token, &msg.admin), &Uint128::zero())?;
    }

    Ok(Response::new()
        .add_attribute("action", "instantiate"))
}

// ✅ 推荐：懒初始化
#[entry_point]
pub fn instantiate_opt(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult<Response> {
    // 仅存储核心配置
    CONFIG.save(deps.storage, &Config {
        admin: deps.api.addr_validate(&msg.admin)?,
        fee_rate: msg.fee_rate,
        // 其他字段首次使用时初始化
    })?;

    Ok(Response::new()
        .add_attribute("action", "instantiate"))
}

// 首次使用时初始化
pub fn get_or_init_balance(
    store: &mut dyn Storage,
    token: &Addr,
    owner: &Addr,
) -> StdResult<Uint128> {
    let key = BALANCES.key((token.as_bytes(), owner.as_bytes()));
    match store.get(&key) {
        Some(data) => from_binary(&Binary(data)),
        None => {
            // 懒初始化：首次访问时创建
            let balance = Uint128::zero();
            BALANCES.save(store, (token.as_bytes(), owner.as_bytes()), &balance)?;
            Ok(balance)
        }
    }
}

// ✅ 推荐：使用 may_load 避免不必要的写入
pub fn get_balance(
    store: &dyn Storage,
    token: &Addr,
    owner: &Addr,
) -> StdResult<Uint128> {
    BALANCES
        .may_load(store, (token.as_bytes(), owner.as_bytes()))?
        .ok_or_else(|| StdError::generic_err("balance not initialized"))
}

pub fn get_or_default(
    store: &dyn Storage,
    token: &Addr,
    owner: &Addr,
) -> Uint128 {
    BALANCES
        .may_load(store, (token.as_bytes(), owner.as_bytes()))
        .unwrap_or(None)
        .unwrap_or(Uint128::zero())
}

5.5 状态压缩

// ❌ 不推荐：完整状态每次写入
pub struct FullState {
    pub initialized: bool,
    pub admin: Addr,
    pub paused: bool,
    pub version: u32,
    pub total_supply: Uint128,
    pub fee_collector: Addr,
    pub fee_rate: Decimal,
    pub min_deposit: Uint128,
    pub max_deposit: Uint128,
    pub lock_time: u64,
}

#[entry_point]
pub fn execute_withdraw(_deps: DepsMut, ...) -> ... {
    // 只修改了 fee_collector，但序列化整个状态
    let mut state = STATE.load(deps.storage)?;
    // 只修改了一个小字段
    state.fee_collector = new_collector;
    STATE.save(deps.storage, &state)?; // 写入 200+ 字节
}

// ✅ 推荐：分离变化频率不同的字段
// 不变状态（仅初始化时设置）：
pub const CONFIG: Item<Config> = Item::new("\x01");

// 频繁变化的状态：
pub const TOTAL_SUPPLY: Item<Uint128> = Item::new("\x02");
pub const FEE_COLLECTOR: Item<Addr> = Item::new("\x03");
pub const PAUSED: Item<bool> = Item::new("\x04");

// 修改时只写入变更的字段
pub fn update_fee_collector(
    store: &mut dyn Storage,
    new_collector: &Addr,
) -> StdResult<()> {
    FEE_COLLECTOR.save(store, new_collector) // 仅写入 ~35 字节
}

5.6 清理过期状态

// ❌ 不推荐：无限增长的存储
pub fn record_trade(
    store: &mut dyn Storage,
    trade: &Trade,
) -> StdResult<()> {
    let mut trades = TRADES.load(store)?;
    trades.push(trade.clone());  // 无限制增长
    TRADES.save(store, &trades)?;
    Ok(())
}

// ✅ 推荐：限制存储大小
pub const MAX_HISTORY: usize = 1000;

pub fn record_trade_opt(
    store: &mut dyn Storage,
    trade: &Trade,
) -> StdResult<()> {
    let mut trades = TRADES.load(store).unwrap_or_default();
    trades.push_back(trade.clone());

    // 保持固定大小
    while trades.len() > MAX_HISTORY {
        trades.pop_front();
    }

    TRADES.save(store, &trades)?;
    Ok(())
}

// ✅ 推荐：过期数据清理
pub const TTL_KEY: Map<&[u8], u64> = Map::new("\x10"); // 过期时间

pub fn set_with_ttl(
    store: &mut dyn Storage,
    key: &[u8],
    value: &[u8],
    ttl_blocks: u64,
    current_height: u64,
) {
    store.set(key, value);
    TTL_KEY.save(store, key, &(current_height + ttl_blocks)).ok();
}

#[entry_point]
pub fn sweep_expired(deps: DepsMut, env: Env) -> StdResult<Response> {
    let mut cleaned = 0u64;
    let to_remove: Vec<Vec<u8>> = TTL_KEY
        .range(deps.storage, None, None, Order::Ascending)
        .filter(|r| r.as_ref().map(|(_, t)| *t <= env.block.height).unwrap_or(false))
        .map(|r| r.map(|(k, _)| k).unwrap())
        .collect();

    for key in &to_remove {
        deps.storage.remove(key);
        TTL_KEY.remove(deps.storage, key);
        cleaned += 1;
    }

    Ok(Response::new()
        .add_attribute("action", "sweep")
        .add_attribute("cleaned", cleaned.to_string()))
}

6. 优化技术清单

6.1 数据类型选择

6.2 API 选择指南

// ✅ 存储 API 选择
// 优先级: Item > Map > IndexedMap > SnapshotMap

// ❌ 不推荐（功能过剩）
pub const BALANCES: SnapshotMap<&Addr, Uint128> = SnapshotMap::new(...);

// ✅ 推荐（刚好够用）
pub const BALANCES: Map<&[u8], Uint128> = Map::new("b");

// ✅ 需要快照功能时才使用
pub const HISTORICAL_BAL: SnapshotMap<&[u8], Uint128> = SnapshotMap::new(...);

6.3 序列化选择

use cosmwasm_std::{to_binary, from_binary, Binary};

// ✅ JSON 序列化（默认）
pub fn to_json<T: Serialize>(data: &T) -> StdResult<Vec<u8>> {
    to_binary(data).map(|b| b.0)
}

// ✅ 手动紧凑编码（极致优化）
pub fn encode_pair(a: u64, b: Uint128) -> [u8; 40] {
    let mut buf = [0u8; 40];
    buf[..8].copy_from_slice(&a.to_be_bytes());
    buf[8..].copy_from_slice(&b.to_be_bytes());
    buf
}

pub fn decode_pair(data: &[u8]) -> Option<(u64, Uint128)> {
    if data.len() != 40 { return None; }
    let a = u64::from_be_bytes(data[..8].try_into().ok()?);
    let b = Uint128::from_be_bytes(data[8..].try_into().ok()?);
    Some((a, b))
}

序列化方式选择：

6.4 避免 Clone

// ❌ 不推荐：不必要的 clone
pub fn process_naive(data: &LargeData) -> LargeData {
    let mut copy = data.clone(); // 大对象 clone，高 Gas
    copy.transform();
    copy
}

// ✅ 推荐：借用或构建
pub fn process_opt(data: &LargeData) -> LargeData {
    LargeData::build_from(data) // 仅复制需要的字段
}

// ❌ 不推荐：克隆整个 Vec
pub fn get_first_naive(items: &Vec<String>) -> String {
    items.first().cloned().unwrap_or_default() // clone String
}

// ✅ 推荐：返回引用
pub fn get_first_opt(items: &[String]) -> &str {
    items.first().map(|s| s.as_str()).unwrap_or("")
}

// ❌ 不推荐：方法链中的 clone
pub fn update_balance(deps: DepsMut, addr: &Addr, amount: Uint128) -> StdResult<()> {
    let mut bal = BALANCES.load(deps.storage, addr)?;
    bal = bal.checked_add(amount)?;
    BALANCES.save(deps.storage, addr, &bal)?; // 需要 &Addr，没问题
    deps.api.addr_humanize(&addr.as_bytes())?; // addr 已借用
    Ok(())
}

// ✅ 推荐：最小 clone
pub fn update_balance_opt(deps: DepsMut, addr: &Addr, amount: Uint128) -> StdResult<()> {
    let key = addr.as_bytes(); // 借用，无 clone
    let mut bal = BALANCES.load(deps.storage, key)?;
    bal = bal.checked_add(amount)?;
    BALANCES.save(deps.storage, key, &bal)?;
    Ok(())
}

Clone 成本：

6.5 使用 BTreeMap 而非 HashMap

use std::collections::{BTreeMap, HashMap};

// ❌ 不推荐：HashMap（非确定性迭代顺序 + 更高 Gas）
pub fn aggregate_hashmap(items: &[(String, Uint128)]) -> HashMap<String, Uint128> {
    let mut map = HashMap::with_capacity(items.len());
    for (k, v) in items {
        *map.entry(k.clone()).or_insert(Uint128::zero()) += *v;
    }
    map
}

// ✅ 推荐：BTreeMap（确定性迭代 + 更低 Gas）
pub fn aggregate_btreemap(items: &[(String, Uint128)]) -> BTreeMap<String, Uint128> {
    let mut map = BTreeMap::new();
    for (k, v) in items {
        *map.entry(k.clone()).or_insert(Uint128::zero()) += *v;
    }
    map
}

HashMap vs BTreeMap：

6.6 Query 优化

use cosmwasm_std::{QuerierWrapper, QueryRequest, BankQuery, WasmQuery};

// ❌ 不推荐：链式查询，一次等一次
pub fn get_full_info_naive(
    querier: &QuerierWrapper,
    user: &Addr,
) -> StdResult<FullInfo> {
    let balance = querier.query_balance(user, "umsg")?;
    let metadata = querier.query_wasm_smart::<Metadata>(
        CONTRACT,
        &QueryMsg::GetMetadata {},
    )?;
    let config = querier.query_wasm_smart::<Config>(
        CONTRACT,
        &QueryMsg::GetConfig {},
    )?;

    Ok(FullInfo { balance, metadata, config })
}

// ✅ 推荐：无法并行查询（CosmWasm query 是同步的）

// 减少查询 API 调用
pub fn get_balance_raw(
    querier: &QuerifierWrapper,
    user: &Addr,
) -> StdResult<Uint128> {
    // 使用 raw query 跳过反序列化
    let key = BALANCES.key(user.as_bytes());
    let raw = querier.query_wasm_raw(CONTRACT, &key)?;
    match raw {
        Some(data) => from_binary(&data),
        None => Ok(Uint128::zero()),
    }
}

6.7 避免重复验证

// ❌ 不推荐：多次验证同一地址
pub fn transfer_naive(
    deps: DepsMut,
    from: &str,
    to: &str,
) -> StdResult<()> {
    let from_addr = deps.api.addr_validate(from)?; // 验证 1
    let to_addr = deps.api.addr_validate(to)?;     // 验证 2

    // 在其他函数中再次验证
    process_from(deps, &from_addr)?;  // 验证 3
    process_to(deps, &to_addr)?;      // 验证 4
    Ok(())
}

fn process_from(deps: DepsMut, addr: &Addr) -> StdResult<()> {
    // 不需要再次验证
    BALANCES.load(deps.storage, addr)?;
    Ok(())
}

// ✅ 推荐：一次性验证，后续使用 Addr
pub fn transfer_opt(
    deps: DepsMut,
    from: &str,
    to: &str,
) -> StdResult<()> {
    let from_addr = deps.api.addr_validate(from)?; // 仅需一次
    let to_addr = deps.api.addr_validate(to)?;

    // 使用已验证的 Addr
    process_from_opt(deps, &from_addr)?;
    process_to_opt(deps, &to_addr)?;
    Ok(())
}

fn process_from_opt(deps: DepsMut, addr: &Addr) -> StdResult<()> {
    BALANCES.load(deps.storage, addr.as_bytes())?;
    Ok(())
}

6.8 预计算和常量化

// ✅ 推荐：编译时常量
pub const FEE_RATE: Decimal = Decimal::percent(30);
pub const MAX_SUPPLY: Uint128 = Uint128::new(1_000_000_000);
pub const DENOM: &str = "umsg";
pub const ONE_DAY: u64 = 86400;
pub const BLOCKS_PER_DAY: u64 = 17280; // 5s 块时间

// ✅ 推荐：预计算 key 前缀
pub const BAL_PREFIX: &[u8] = b"\x02";
pub const ALW_PREFIX: &[u8] = b"\x03";

pub fn balance_key(owner: &[u8]) -> Vec<u8> {
    let mut key = Vec::with_capacity(1 + owner.len());
    key.extend_from_slice(BAL_PREFIX);
    key.extend_from_slice(owner);
    key
}

// ✅ 推荐：预计算空值检查
pub const ZERO: Uint128 = Uint128::zero();
pub const ONE: Uint128 = Uint128::new(1);

// ✅ 推荐：预计算哈希
pub fn hash_address(addr: &Addr) -> [u8; 32] {
    use cosmwasm_std::Binary;
    let hash = Binary::from(addr.as_bytes());
    // 实际应使用 SHA-256
    sha256(addr.as_bytes())
}

6.9 编译优化

# Cargo.toml 优化配置
[profile.release]
# 针对 Wasm 的编译优化
opt-level = "z"       # 优化大小（最小化 Wasm 文件）
lto = true            # 链接时优化
codegen-units = 1     # 单代码生成单元（更多优化机会）
panic = "abort"       # panic = abort 避免 unwind 表
strip = "symbols"     # 去除符号表
overflow-checks = true # 保留溢出检查（安全）

编译优化影响：

6.10 Wasm 二进制优化

// ❌ 不推荐：不必要的依赖
// Cargo.toml 包含:
// cosmwasm-std = { version = "1.x", features = ["stargate", "iterator"] }
// 即使迭代器功能未使用

// ✅ 推荐：按需选择 feature
// Cargo.toml:
// cosmwasm-std = "1.x"  # 默认功能，无 iterator
// cw-storage-plus = "1.x"  # 选择使用

// ❌ 不推荐：大依赖
use serde_json;  // 如果只是为了 JSON，cosmwasm_std 已包含

// ✅ 推荐：使用 cosmwasm_std 内置功能
use cosmwasm_std::{to_binary, from_binary};  // 无额外依赖

// ❌ 不推荐：使用 chrono
use chrono::Utc;

// ✅ 推荐：使用 CosmWasm 时间
use cosmwasm_std::Timestamp;

// ❌ 不推荐：使用 regex
use regex::Regex;

// ✅ 推荐：简单字符串操作
pub fn validate_address(addr: &str) -> bool {
    addr.starts_with("msg") && addr.len() == 45  // 简单检查
}

依赖 Gas 开销：

6.11 函数内联决策

// ✅ 推荐：热点路径使用内联
#[inline(always)]
pub fn hot_function(x: Uint128) -> Uint128 {
    x.checked_add(Uint128::one()).unwrap()
}

// ✅ 推荐：大函数不应内联
#[inline(never)]
pub fn cold_function_complex() -> u64 {
    // 复杂的初始化或清理逻辑
    42
}

// ✅ 推荐：条件编译用于调试
#[cfg(not(target_arch = "wasm32"))]
pub fn debug_only_function() {
    // 仅在非 Wasm 环境下编译
}

6.12 迭代器优化

// ❌ 不推荐：collect + 多次迭代
pub fn process_items_naive(items: &[Item]) -> ProcessedResult {
    let filtered: Vec<&Item> = items.iter()           // 第一次迭代
        .filter(|i| i.is_active())
        .collect();

    let total: Uint128 = filtered.iter()              // 第二次迭代
        .map(|i| i.amount)
        .sum();
    let count = filtered.len();

    ProcessedResult { total, count }
}

// ✅ 推荐：单次迭代
pub fn process_items_opt(items: &[Item]) -> ProcessedResult {
    items.iter()
        .filter(|i| i.is_active())
        .fold(ProcessedResult::default(), |mut acc, i| {
            acc.total += i.amount;
            acc.count += 1;
            acc
        })
}

6.13 使用 cw-storage-plus 最佳实践

use cw_storage_plus::{Item, Map, IndexedMap, MultiIndex};

// ✅ 推荐：Item 用于单值存储
pub const STATE: Item<ContractState> = Item::new("s");

// ✅ 推荐：Map 短 Key
pub const BAL: Map<&[u8], Uint128> = Map::new("b");

// ✅ 推荐：复合 Key 时使用 Prefix
pub const ALLOWANCE: Map<(&[u8], &[u8]), Uint128> = Map::new("a");

// 使用 prefix 高效查询某人的所有授权
pub fn get_owner_allowances<'a>(
    store: &'a dyn Storage,
    owner: &[u8],
) -> impl Iterator<Item = StdResult<(Vec<u8>, Uint128)>> + 'a {
    ALLOWANCE.prefix(owner).range(store, None, None, Order::Ascending)
}

// ✅ 推荐：使用 may_load 避免 unwrap
pub fn safe_load<T: serde::de::DeserializeOwned>(
    store: &dyn Storage,
    key: &[u8],
) -> Option<T> {
    store.get(key)
        .and_then(|data| from_binary::<T>(&Binary(data)).ok())
}

// ✅ 推荐：使用 keys() 获取所有 key
pub fn get_all_holders<'a>(
    store: &'a dyn Storage,
) -> Vec<Vec<u8>> {
    BAL.keys(store, None, None, Order::Ascending)
        .filter_map(|r| r.ok())
        .collect()
}

6.14 内存管理

// ✅ 推荐：预分配容量
pub fn collect_addresses(iter: impl Iterator<Item = Addr>) -> Vec<Addr> {
    let (lower, upper) = iter.size_hint();
    let capacity = upper.unwrap_or(lower);
    let mut result = Vec::with_capacity(capacity);
    for addr in iter {
        result.push(addr);
    }
    result
}

// ✅ 推荐：使用缩短的生命周期
pub fn process_temp_data() -> Uint128 {
    // 临时数据在函数返回后自动释放
    let temp = vec![Uint128::one(); 100];
    temp.iter().sum()
}

// ✅ 推荐：重用缓冲区（如果可能）
pub struct BufferReuser {
    buffer: Vec<u8>,
}

impl BufferReuser {
    pub fn encode(&mut self, data: &[u8]) -> &[u8] {
        self.buffer.clear();
        self.buffer.extend_from_slice(data);
        &self.buffer
    }
}

6.15 错误码汇总

// ❌ 不推荐：字符串错误
#[derive(Error, Debug)]
pub enum MyError {
    #[error("{0}")]
    Generic(String), // 每次分配字符串
}

// ✅ 推荐：无分配错误
#[derive(Error, Debug)]
pub enum MyErrorOpt {
    #[error("unauthorized")]
    Unauthorized,
    #[error("zero amount")]
    ZeroAmount,
    #[error("insufficient funds: have {0}, need {1}")]
    InsufficientFunds(Uint128, Uint128), // 仅数值，无分配
    #[error("storage error: {0}")]
    Std(#[from] StdError),
}

7. Gas 分析工具

7.1 msg-chain-devkit gas-estimate

MSG Chain 提供 msg-chain-devkit 命令行工具用于 Gas 估算：

# 估算合约部署 Gas
msg-chain-devkit gas-estimate deploy \
    --code-id 1 \
    --msg '{"admin":"msg1..."}' \
    --label "my_contract" \
    --funds "1000000umsg"

# 估算合约执行 Gas
msg-chain-devkit gas-estimate execute \
    --contract "msg1contract..." \
    --msg '{"transfer":{"recipient":"msg1...","amount":"1000"}}' \
    --from "msg1sender..."

# 使用不同 Gas 价格估算费用
msg-chain-devkit gas-estimate execute \
    --contract "msg1contract..." \
    --msg '{"swap":{"pool_id":"01","amount":"1000"}}' \
    --gas-price "1000000000umsg"

# 输出示例:
# Gas Used: 234,567
# Fee: 5,864 umsg (at 1000000000 attoMSG/gas)
# Low Fee: 2,345 umsg
# Avg Fee: 5,864 umsg
# High Fee: 9,382 umsg

7.2 交易模拟

# 模拟交易但不广播
msg-chain-devkit tx simulate \
    --from "msg1sender..." \
    --node "https://rpc.msgchain.org" \
    --chain-id "msg-chain-1" \
    --gas-adjustment "1.3" \
    --fees "50000umsg" \
    '{"@type":"/cosmwasm.wasm.v1.MsgExecuteContract","contract":"msg1contract...","msg":{...}}'

# 批量模拟（比较不同输入）
msg-chain-devkit gas-estimate batch \
    --file "./test_cases.json" \
    --output "./gas_report.csv"

# test_cases.json 格式:
# [
#   {"name": "transfer_10", "msg": {"transfer": {"amount": "10", ...}}},
#   {"name": "transfer_1000", "msg": {"transfer": {"amount": "1000", ...}}},
#   ...
# ]

7.3 Rust 基准测试

// 在测试文件中添加 Gas 基准测试

#[cfg(test)]
mod gas_benchmarks {
    use super::*;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::{from_binary, to_binary};

    struct GasBenchmark {
        name: &'static str,
        setup: Box<dyn Fn() -> (DepsMut, Env, MessageInfo)>,
        execute: Box<dyn Fn(DepsMut, Env, MessageInfo) -> Result<Response, ContractError>>,
        iterations: u32,
    }

    impl GasBenchmark {
        fn run(&self) -> GasReport {
            let mut total_gas = 0u64;
            let mut min_gas = u64::MAX;
            let mut max_gas = 0u64;

            for _ in 0..self.iterations {
                let (deps, env, info) = (self.setup)();
                let start = gas_meter_read(deps.storage);
                let _ = (self.execute)(deps, env, info);
                let gas_used = gas_meter_read(deps.storage) - start;

                total_gas += gas_used;
                min_gas = min_gas.min(gas_used);
                max_gas = max_gas.max(gas_used);
            }

            GasReport {
                name: self.name,
                avg_gas: total_gas / self.iterations as u64,
                min_gas,
                max_gas,
                iterations: self.iterations,
            }
        }
    }

    struct GasReport {
        name: &'static str,
        avg_gas: u64,
        min_gas: u64,
        max_gas: u64,
        iterations: u32,
    }

    #[test]
    fn benchmark_transfer() {
        let benchmark = GasBenchmark {
            name: "transfer_naive",
            setup: Box::new(|| {
                let mut deps = mock_dependencies();
                // 初始化测试数据
                let info = mock_info("sender", &[]);
                let env = mock_env();
                (deps.as_mut(), env, info)
            }),
            execute: Box::new(|deps, env, info| {
                execute_transfer_naive(deps, env, info, "recipient".to_string(), Uint128::new(1000))
            }),
            iterations: 100,
        };

        let report = benchmark.run();
        println!("{:#?}", report);
        assert!(report.avg_gas < 200_000, "Gas too high!");
    }

    #[test]
    fn benchmark_transfer_opt() {
        let benchmark = GasBenchmark {
            name: "transfer_optimized",
            setup: Box::new(|| {
                let mut deps = mock_dependencies();
                let info = mock_info("sender", &[]);
                let env = mock_env();
                (deps.as_mut(), env, info)
            }),
            execute: Box::new(|deps, env, info| {
                execute_transfer_optimized(deps, env, info, Addr::unchecked("recipient"), Uint128::new(1000))
            }),
            iterations: 100,
        };

        let report = benchmark.run();
        println!("{:#?}", report);
    }

    // 批量比较
    #[test]
    fn compare_implementations() {
        let implementations = vec![
            ("naive", execute_transfer_naive as fn(...)),
            ("optimized", execute_transfer_optimized as fn(...)),
            ("extreme", execute_transfer_extreme as fn(...)),
        ];

        for (name, func) in &implementations {
            let mut total = 0u64;
            for _ in 0..50 {
                let (deps, env, info) = setup();
                let start = gas_meter_read(deps.storage);
                func(deps, env, info).unwrap();
                total += gas_meter_read(deps.storage) - start;
            }
            println!("{}: avg {} gas", name, total / 50);
        }
    }
}

// 模拟 Gas Meter（测试用）
fn gas_meter_read(storage: &dyn Storage) -> u64 {
    // 在真实环境中应使用 cosmwasm_vm 的 gas meter
    // 这里用简化方法：统计存储操作次数
    0 // placeholder
}

7.4 CosmWasm Gas Profiling

// 手动 Gas 追踪宏
macro_rules! trace_gas {
    ($label:expr, $code:block) => {{
        #[cfg(feature = "gas_trace")]
        {
            let start = gas_counter();
            let result = $code;
            let gas = gas_counter() - start;
            cosmwasm_std::debug_print(&format!("GAS_TRACE: {} = {} gas", $label, gas));
            result
        }
        #[cfg(not(feature = "gas_trace"))]
        {
            $code
        }
    }};
}

// 使用 Gas 追踪
pub fn execute_swap_traced(
    deps: DepsMut,
    pool_id: &[u8],
    amount: Uint128,
) -> StdResult<Response> {
    let pool = trace_gas!("load_pool", {
        POOLS.load(deps.storage, pool_id)?
    });

    let result = trace_gas!("compute_swap", {
        compute_swap(&pool, amount)?
    });

    trace_gas!("save_pool", {
        POOLS.save(deps.storage, pool_id, &pool)?
    });

    Ok(Response::new())
}

7.5 Gas Diff 工具

# 比较两个合约版本的 Gas 差异
msg-chain-devkit gas-diff \
    --old "./contract_v1.wasm" \
    --new "./contract_v2.wasm" \
    --test-file "./benchmark.json" \
    --format "table"

# 输出示例:
# ┌──────────────────┬──────────┬──────────┬──────────┐
# │ Operation        │ v1 Gas   │ v2 Gas   │ Δ        │
# ├──────────────────┼──────────┼──────────┼──────────┤
# │ transfer         │ 234,567  │ 198,345  │ -15.4%   │
# │ approve          │ 145,678  │ 145,678  │ 0.0%     │
# │ transfer_from    │ 267,890  │ 212,345  │ -20.7%   │
# │ burn             │ 89,012   │ 89,012   │ 0.0%     │
# │ mint             │ 312,456  │ 256,789  │ -17.8%   │
# └──────────────────┴──────────┴──────────┴──────────┘

# 持续集成中使用
msg-chain-devkit gas-diff \
    --old "./main.wasm" \
    --new "./feature.wasm" \
    --threshold 5 \
    # 如果 Gas 增加超过 5%，返回非 0 退出码

7.6 在 CI/CD 中集成 Gas 检查

# .github/workflows/gas_check.yml
name: Gas Benchmark Check

on:
  pull_request:
    paths:
      - 'contracts/**/*.rs'
      - 'contracts/**/Cargo.toml'

jobs:
  gas-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Build contracts
        run: cargo wasm

      - name: Compare gas benchmarks
        run: |
          # 检出主分支的 Wasm
          git checkout main -- artifacts/*.wasm
          mv artifacts/*.wasm ./baseline/

          # 比较 Gas
          msg-chain-devkit gas-diff \
            --old ./baseline/contract.wasm \
            --new ./artifacts/contract.wasm \
            --benchmark ./tests/gas_benchmark.json \
            --threshold 5.0

7.7 Wasm 二进制分析

# 分析 Wasm 文件大小
wasm-strip contract.wasm -o contract_stripped.wasm
ls -lh contract*.wasm

# 查看 Wasm 段信息
wasm-objdump -h contract.wasm

# 反编译 Wasm（查看优化效果）
wasm2wat contract.wasm > contract.wat
wc -l contract.wat  # Wasm 指令数

# 检查未使用的导出函数
wasm-nm contract.wasm | grep -v "camelCase"

# 检查 panic 和 debug 符号
wasm-objdump -x contract.wasm | grep "name"
wasm-objdump -x contract.wasm | grep "import"

7.8 Gas 可视化

# 生成 Gas 报告
msg-chain-devkit gas-report \
    --contract "./contract.wasm" \
    --output "./gas_report.html" \
    --format "html"

# Gas 火焰图（识别热点）
msg-chain-devkit gas-flamegraph \
    --contract "./contract.wasm" \
    --input "./trace_data.json" \
    --output "./flamegraph.svg"

8. 实战案例

8.1 案例一：Token 转账优化

优化前代码：

pub fn execute_transfer_naive(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    recipient: String,
    amount: String,
) -> Result<Response, ContractError> {
    // 验证地址
    let to_addr = deps.api.addr_validate(&recipient)?;
    let from_addr = info.sender.clone();

    // 解析金额
    let amount = Uint128::from_str(&amount)
        .map_err(|_| ContractError::InvalidAmount)?;

    if amount.is_zero() {
        return Err(ContractError::ZeroAmount);
    }

    // 读取余额
    let mut from_balance = BALANCES.load(deps.storage, &from_addr)?;
    let mut to_balance = BALANCES.load(deps.storage, &to_addr)?;

    // 更新余额
    from_balance = from_balance.checked_sub(amount)
        .map_err(|_| ContractError::InsufficientFunds)?;
    to_balance = to_balance.checked_add(amount)?;

    // 写入
    BALANCES.save(deps.storage, &from_addr, &from_balance)?;
    BALANCES.save(deps.storage, &to_addr, &to_balance)?;

    // 事件
    Ok(Response::new()
        .add_attribute("action", "transfer")
        .add_attribute("from", info.sender.as_str())
        .add_attribute("to", &recipient)
        .add_attribute("amount", amount.to_string())
        .add_attribute("height", env.block.height.to_string()))
}

优化后代码：

pub fn execute_transfer_opt(
    deps: DepsMut,
    _env: Env,
    info: MessageInfo,
    recipient: Addr,
    amount: Uint128,
) -> Result<Response, ContractError> {
    if amount.is_zero() {
        return Ok(Response::new().add_attribute("a", "xfer_zero"));
    }
    if info.sender == recipient {
        return Err(ContractError::SelfTransfer);
    }

    let from = info.sender.as_bytes();
    let to = recipient.as_bytes();

    let mut from_bal = BAL.load(deps.storage, from)?;
    let mut to_bal = BAL.load(deps.storage, to)?;

    from_bal = from_bal.checked_sub(amount)?;
    to_bal = to_bal.checked_add(amount)?;

    BAL.save(deps.storage, from, &from_bal)?;
    BAL.save(deps.storage, to, &to_bal)?;

    Ok(Response::new()
        .add_attribute("a", "xfer")
        .add_attribute("f", info.sender)
        .add_attribute("t", recipient)
        .add_attribute("v", amount))
}

Gas 对比：

8.2 案例二：AMM Swap 优化

优化前：

pub fn execute_swap_naive(
    deps: DepsMut,
    info: MessageInfo,
    pool_id: String,
    token_in: String,
    amount_in: String,
    min_amount_out: Option<String>,
) -> Result<Response, ContractError> {
    let pool_id = pool_id.as_bytes();
    let sender = info.sender.clone();

    let amount_in = Uint128::from_str(&amount_in)?;
    let min_out = match min_amount_out {
        Some(s) => Some(Uint128::from_str(&s)?),
        None => None,
    };

    let mut pool = POOLS.load(deps.storage, pool_id)?;
    let (reserve_in, reserve_out) = match token_in.as_str() {
        "token_a" => (pool.reserve_a, pool.reserve_b),
        "token_b" => (pool.reserve_b, pool.reserve_a),
        _ => return Err(ContractError::InvalidToken),
    };

    // Decimal 计算的 swap
    let amount_out = {
        let numerator = Uint128::from(amount_in.u128())
            .checked_mul(reserve_out.u128().into())?;
        let denominator = Uint128::from(reserve_in.u128())
            .checked_add(amount_in.u128().into())?;
        numerator.checked_div(denominator)?
    };

    if let Some(min) = min_out {
        if amount_out < min {
            return Err(ContractError::SlippageExceeded);
        }
    }

    // 更新储备
    match token_in.as_str() {
        "token_a" => {
            pool.reserve_a = reserve_in.checked_add(amount_in)?;
            pool.reserve_b = reserve_out.checked_sub(amount_out)?;
        }
        "token_b" => {
            pool.reserve_b = reserve_in.checked_add(amount_in)?;
            pool.reserve_a = reserve_out.checked_sub(amount_out)?;
        }
        _ => unreachable!(),
    }

    POOLS.save(deps.storage, pool_id, &pool)?;

    // 事件
    Ok(Response::new()
        .add_attribute("action", "swap")
        .add_attribute("pool", String::from_utf8_lossy(pool_id))
        .add_attribute("sender", sender)
        .add_attribute("token_in", &token_in)
        .add_attribute("amount_in", amount_in.to_string())
        .add_attribute("amount_out", amount_out.to_string()))
}

优化后：

pub const FEE_BASIS: Uint128 = Uint128::new(997); // 0.3% fee
pub const BASIS: Uint128 = Uint128::new(1000);

pub fn execute_swap_opt(
    deps: DepsMut,
    _info: MessageInfo,
    pool_id: &[u8],
    token_in_is_a: bool,
    amount_in: Uint128,
    min_out: Uint128,
) -> Result<Response, ContractError> {
    let mut pool = POOLS.load(deps.storage, pool_id)?;

    let (reserve_in, reserve_out) = if token_in_is_a {
        (pool.reserve_a, pool.reserve_b)
    } else {
        (pool.reserve_b, pool.reserve_a)
    };

    // 整数 swap: amount_out = (amount_in * reserve_out * 997) / (reserve_in * 1000 + amount_in * 997)
    let amount_in_after_fee = amount_in.checked_mul(FEE_BASIS)?;
    let numerator = amount_in_after_fee.checked_mul(reserve_out)?;
    let denominator = reserve_in.checked_mul(BASIS)?
        .checked_add(amount_in_after_fee)?;
    let amount_out = numerator.checked_div(denominator)?;

    if amount_out < min_out {
        return Err(ContractError::SlippageExceeded);
    }

    if token_in_is_a {
        pool.reserve_a = pool.reserve_a.checked_add(amount_in)?;
        pool.reserve_b = pool.reserve_b.checked_sub(amount_out)?;
    } else {
        pool.reserve_b = pool.reserve_b.checked_add(amount_in)?;
        pool.reserve_a = pool.reserve_a.checked_sub(amount_out)?;
    }

    POOLS.save(deps.storage, pool_id, &pool)?;

    Ok(Response::new()
        .add_attribute("a", "swap")
        .add_attribute("p", pool_id)
        .add_attribute("i", amount_in)
        .add_attribute("o", amount_out))
}

Gas 对比：

8.3 案例三：NFT 铸造优化

优化前：

pub fn execute_mint_naive(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    token_id: String,
    owner: String,
    metadata: Metadata,
) -> Result<Response, ContractError> {
    let owner_addr = deps.api.addr_validate(&owner)?;

    if !is_admin(deps.as_ref(), &info)? {
        return Err(ContractError::Unauthorized);
    }

    let token_info = TokenInfo {
        id: token_id.clone(),
        owner: owner_addr.clone(),
        metadata: metadata.clone(),
        minted_at: env.block.time,
        minted_by: info.sender.clone(),
    };

    TOKENS.save(deps.storage, &token_id, &token_info)?;
    OWNER_TOKENS.save(deps.storage, (&owner_addr, &token_id), &true)?;

    TOTAL_SUPPLY.update(deps.storage, |s| -> StdResult<_> {
        Ok(s + 1u64)
    })?;

    Ok(Response::new()
        .add_attribute("action", "mint")
        .add_attribute("token_id", &token_id)
        .add_attribute("owner", &owner)
        .add_attribute("time", env.block.time.to_string()))
}

优化后：

pub const MAX_METADATA_SIZE: usize = 256;

pub fn execute_mint_opt(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    token_id: u64,
    compact_metadata: [u8; 256],
    meta_len: u32,
) -> Result<Response, ContractError> {
    // 管理员检查简化
    if info.sender != ADMIN {
        return Err(ContractError::Unauthorized);
    }

    // 存储压缩版 TokenInfo
    let token_key = token_id.to_be_bytes();
    let token_data = CompactToken {
        o: env.block.time.seconds(),  // owner = creator at mint
        m: compact_metadata,          // fixed-size metadata
        l: meta_len,
        t: env.block.time.seconds(),
    };

    TOKENS.save(deps.storage, &token_key, &token_data)?;

    // 更新供应量
    let mut supply = SUPPLY.load(deps.storage)?;
    supply += 1;
    SUPPLY.save(deps.storage, &supply)?;

    Ok(Response::new()
        .add_attribute("a", "mint")
        .add_attribute("i", token_id)
        .add_attribute("o", supply))
}

Gas 对比：

8.4 案例四：批量空投优化

优化前：

pub fn execute_airdrop_naive(
    deps: DepsMut,
    info: MessageInfo,
    recipients: Vec<(String, String)>, // (addr, amount) strings
) -> Result<Response, ContractError> {
    let sender = info.sender;
    let mut total = Uint128::zero();

    for (addr_str, amount_str) in &recipients {
        let addr = deps.api.addr_validate(addr_str)?;
        let amount = Uint128::from_str(amount_str)?;
        total += amount;

        let mut bal = BALANCES.load(deps.storage, &sender)?;
        bal = bal.checked_sub(amount)?;
        BALANCES.save(deps.storage, &sender, &bal)?;

        let mut recv_bal = BALANCES.load(deps.storage, &addr)?;
        recv_bal = recv_bal.checked_add(amount)?;
        BALANCES.save(deps.storage, &addr, &recv_bal)?;
    }

    Ok(Response::new()
        .add_attribute("action", "airdrop")
        .add_attribute("count", recipients.len().to_string()))
}

优化后：

pub fn execute_airdrop_opt(
    deps: DepsMut,
    info: MessageInfo,
    recipients: Vec<(Addr, Uint128)>,
) -> Result<Response, ContractError> {
    let sender = info.sender.as_bytes().to_vec();

    // 1. 计算总额
    let total: Uint128 = recipients.iter().map(|(_, a)| *a).sum();

    // 2. 单次读取发送方余额
    let mut sender_bal = BAL.load(deps.storage, &sender)?;
    sender_bal = sender_bal.checked_sub(total)?;
    BAL.save(deps.storage, &sender, &sender_bal)?;

    // 3. 批量更新接收方
    for (addr, amount) in &recipients {
        let key = addr.as_bytes().to_vec();
        let mut bal = BAL.load(deps.storage, &key)?;
        bal = bal.checked_add(*amount)?;
        BAL.save(deps.storage, &key, &bal)?;
    }

    Ok(Response::new()
        .add_attribute("a", "drop")
        .add_attribute("n", recipients.len()))
}

Gas 对比（100 个接收者）：

8.5 案例五：跨合约调用优化

优化前：

pub fn execute_cross_call_naive(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    token_contract: String,
    spender: String,
    amount: String,
) -> Result<Response, ContractError> {
    let token_addr = deps.api.addr_validate(&token_contract)?;
    let spender_addr = deps.api.addr_validate(&spender)?;
    let amount = Uint128::from_str(&amount)?;

    // 子消息：approve
    let approve_msg = WasmMsg::Execute {
        contract_addr: token_addr.to_string(),
        msg: to_binary(&Cw20ExecuteMsg::Approve {
            spender: spender_addr.to_string(),
            amount,
        })?,
        funds: vec![],
    };

    // 子消息：transfer_from
    let transfer_msg = WasmMsg::Execute {
        contract_addr: token_addr.to_string(),
        msg: to_binary(&Cw20ExecuteMsg::TransferFrom {
            owner: info.sender.to_string(),
            recipient: env.contract.address.to_string(),
            amount,
        })?,
        funds: vec![],
    };

    Ok(Response::new()
        .add_message(approve_msg)
        .add_message(transfer_msg)
        .add_attribute("action", "cross_call"))
}

优化后：

pub fn execute_cross_call_opt(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    token_addr: Addr,
    amount: Uint128,
) -> Result<Response, ContractError> {
    // 合并为一条 TransferFrom 消息
    // 前提：用户已授权本合约
    let transfer_msg = WasmMsg::Execute {
        contract_addr: token_addr.to_string(),
        msg: to_binary(&Cw20ExecuteMsg::TransferFrom {
            owner: info.sender.to_string(),
            recipient: env.contract.address.to_string(),
            amount,
        })?,
        funds: vec![],
    };

    Ok(Response::new()
        .add_message(transfer_msg)
        .add_attribute("a", "xcall")
        .add_attribute("v", amount))
}

Gas 对比：

8.6 实际项目 Gas 优化汇总

9. 优化陷阱与反模式

9.1 过早优化

// ❌ 反模式：为了微小的 Gas 节省而牺牲可读性
pub fn x(a: &[u8], b: &[u8]) -> bool {
    // 位运算魔法，但没人能理解
    let r = a.len() ^ b.len();
    a.iter().zip(b.iter()).fold(r, |acc, (x, y)| acc | (x ^ y)) == 0
}

// ✅ 正确做法：先写出正确代码，确认是热点后再优化
pub fn eq_safe(a: &[u8], b: &[u8]) -> bool {
    a == b
}

何时应该优化：

1. 合约已经正常工作并通过测试
2. 通过 Gas profiling 确认了热点
3. 优化带来的节省 > 可读性的损失
4. 用户实际反馈 Gas 费用过高

9.2 安全 vs 优化

// ❌ 反模式：为了 Gas 牺牲安全

// 不安全：使用 unchecked 运算
pub fn transfer_unsafe(
    bal: &mut Uint128,
    amount: Uint128,
) {
    *bal = Uint128::new(bal.u128() - amount.u128()); // 可能下溢
}

// ✅ 安全做法：使用 checked 运算
pub fn transfer_safe(
    bal: &mut Uint128,
    amount: Uint128,
) -> StdResult<()> {
    *bal = bal.checked_sub(amount)?;
    Ok(())
}

// ❌ 反模式：跳过输入验证
pub fn execute_no_validate(
    deps: DepsMut,
    recipient: String,
) -> StdResult<()> {
    // 未验证地址格式
    let key = recipient.as_bytes();
    BAL.save(deps.storage, key, &Uint128::new(100))?;
    Ok(())
}

// ✅ 安全做法：始终验证输入
pub fn execute_validated(
    deps: DepsMut,
    recipient: String,
) -> StdResult<()> {
    let addr = deps.api.addr_validate(&recipient)?;
    BAL.save(deps.storage, addr.as_bytes(), &Uint128::new(100))?;
    Ok(())
}

安全-优化平衡表：

// ✅ 安全的 unchecked 运算示例
pub fn safe_unchecked_add(a: Uint128, b: Uint128) -> Uint128 {
    // 当 b 总是很小时使用
    debug_assert!(b < Uint128::new(1000), "b should be small");
    a + b // Debug 模式下检查，Release 下 unchecked
}

// ✅ 可控的跳过验证
pub fn skip_validation_when_safe(
    deps: DepsMut,
    recipient: &Addr,
) -> StdResult<()> {
    // recipient 已经是 Addr 类型，说明已经验证过
    BAL.save(deps.storage, recipient.as_bytes(), &Uint128::new(100))
}

9.3 过度优化导致代码膨胀

// ❌ 反模式：过度内联导致 Wasm 膨胀
#[inline(always)]
pub fn tiny_op(a: Uint128) -> Uint128 { a + Uint128::one() }

#[inline(always)]
pub fn another_tiny_op(a: Uint128) -> Uint128 { a * Uint128::new(2) }

#[inline(always)]
pub fn third_tiny_op(a: Uint128) -> Uint128 { a / Uint128::new(3) }

pub fn do_many_things(a: Uint128) -> Uint128 {
    // 三个函数都被内联，但每个只用一次
    let a = tiny_op(a);
    let a = another_tiny_op(a);
    third_tiny_op(a)
}

// ✅ 正确做法：仅在热点路径内联
pub fn do_many_things_opt(a: Uint128) -> Uint128 {
    // 内联在唯一调用点
    let a = a + Uint128::one();
    let a = a * Uint128::new(2);
    a / Uint128::new(3)
}

9.4 忽视 Wasm 特性

// ❌ 反模式：使用 Wasm 不友好的模式
pub fn large_stack_array() {
    // 大数组分配在栈上，可能超过 Wasm 栈限制
    let buf = [0u8; 65536]; // Wasm 页大小为 64KB
    // ...
}

// ✅ 正确做法：使用堆分配
pub fn large_heap_allocation() {
    let buf = vec![0u8; 65536]; // 堆分配
    // ...
}

// ❌ 反模式：递归深度过大
pub fn recursive(n: u64) -> u64 {
    if n == 0 { return 0; }
    recursive(n - 1) + 1 // Wasm 没有尾递归优化
}

// ✅ 正确做法：使用迭代
pub fn iterative(n: u64) -> u64 {
    (0..n).count() as u64
}

9.5 忽视批量限制

// ❌ 反模式：无限批量
pub fn execute_airdrop_no_limit(
    deps: DepsMut,
    recipients: Vec<(Addr, Uint128)>,
) -> Result<Response, ContractError> {
    // 可能接收 10000 个接收者，Gas 远超限制
    for (addr, amount) in &recipients {
        let mut bal = BAL.load(deps.storage, addr.as_bytes())?;
        bal = bal.checked_add(*amount)?;
        BAL.save(deps.storage, addr.as_bytes(), &bal)?;
    }
    Ok(Response::new())
}

// ✅ 正确做法：设置批量限制
pub const MAX_BATCH: usize = 200;

pub fn execute_airdrop_limited(
    deps: DepsMut,
    recipients: Vec<(Addr, Uint128)>,
) -> Result<Response, ContractError> {
    if recipients.len() > MAX_BATCH {
        return Err(ContractError::BatchTooLarge {
            max: MAX_BATCH,
            got: recipients.len(),
        });
    }
    for (addr, amount) in &recipients {
        let mut bal = BAL.load(deps.storage, addr.as_bytes())?;
        bal = bal.checked_add(*amount)?;
        BAL.save(deps.storage, addr.as_bytes(), &bal)?;
    }
    Ok(Response::new())
}

9.6 存储膨胀陷阱

// ❌ 反模式：存储可推导的数据
pub struct StoredData {
    pub hash: [u8; 32],       // 可推导
    pub timestamp: u64,        // 可推导
    pub sender: Addr,          // 可推导
    pub block_height: u64,     // 可从 env 获取
}

// ✅ 正确做法：仅存储必要数据
pub struct MinimalData {
    pub hash: [u8; 32],  // 核心数据
}

// ❌ 反模式：存储查询结果
pub fn cache_query_result(deps: DepsMut) -> StdResult<()> {
    // 查询外部合约结果并存储
    let result = deps.querier.query_wasm_smart::<TokenInfo>(
        OTHER_CONTRACT,
        &QueryMsg::Info {},
    )?;
    CACHED_RESULT.save(deps.storage, &result)?; // 可能过时
    Ok(())
}

// ✅ 正确做法：查询时实时获取
pub fn get_query_result(deps: Deps) -> StdResult<TokenInfo> {
    deps.querier.query_wasm_smart(
        OTHER_CONTRACT,
        &QueryMsg::Info {},
    )
}

9.7 常见反模式清单

9.8 优化备忘录

存储优化优先级：
1. 减少写入次数（最重要）
2. 缩短 Key 长度
3. 紧凑序列化格式
4. 分离冷热存储
5. 清理过期数据

执行优化优先级：
1. 减少 Decimal 运算（用整数替代）
2. 避免字符串分配
3. 预计算常量
4. 使用迭代器
5. 批量操作

编译优化：
1. opt-level = "z"
2. lto = true
3. codegen-units = 1
4. panic = "abort"
5. strip = "symbols"

安全检查（永不关闭）：
1. overflow-checks = true
2. checked_* 运算
3. 地址验证
4. 输入边界检查
5. 权限验证

10. 附录

A. Gas 快速参考表

B. 优化检查清单

合约编写时：

• [ ] Key 使用最短命名（"b" 而非 "balances"）
• [ ] Map Key 使用 &[u8] 而非 &Addr 或 &String
• [ ] 存储使用 Item + Map 而非 Singleton + Bucket
• [ ] 数据使用紧凑编码
• [ ] 分离热数据和冷数据
• [ ] 输入使用 Uint128/Addr 而非 String
• [ ] 错误使用无分配枚举
• [ ] 循环使用预分配容量
• [ ] 使用 BTreeMap 而非 HashMap
• [ ] 避免不必要的 clone()
• [ ] 预计算常量和 Key 前缀
• [ ] 批量读写替代逐条操作
• [ ] 懒初始化而非预初始化

合约测试时：

• [ ] 对每个入口函数运行 Gas 估算
• [ ] Gas profiling 识别热点
• [ ] 比较不同实现的 Gas 差异
• [ ] 边界情况（大输入、大量写入）的 Gas 测试
• [ ] 极限批量操作的 Gas 验证

合约部署前：

• [ ] 最终 Wasm 文件大小 < 150KB
• [ ] 编译配置使用 opt-level = "z"
• [ ] 无冗余依赖
• [ ] panic = "abort" 已设置
• [ ] overflow-checks = true
• [ ] strip = "symbols"

性能基准：

C. Cargo.toml 模板

[package]
name = "optimized-contract"
version = "0.1.0"
edition = "2021"
rust-version = "1.75"

[lib]
crate-type = ["cdylib", "rlib"]

[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
panic = "abort"
strip = "symbols"
overflow-checks = true

[dependencies]
cosmwasm-std = "1.5"
cw-storage-plus = "1.2"
cw2 = "1.1"
serde = { version = "1", features = ["derive"] }
thiserror = "1"

[features]
gas_trace = []

D. Gas 计算器

/// Gas 费用计算辅助函数
pub struct GasCalculator {
    gas_price: Decimal,
    avg_gas_price: Decimal,
    high_gas_price: Decimal,
}

impl GasCalculator {
    pub fn new() -> Self {
        Self {
            gas_price: Decimal::from_atomics(Uint128::new(1_000_000_000), 0).unwrap(),   // 1e9 attoMSG
            avg_gas_price: Decimal::from_atomics(Uint128::new(1_000_000_000), 0).unwrap(), // 1e9 attoMSG
            high_gas_price: Decimal::from_atomics(Uint128::new(1_000_000_000), 0).unwrap(), // 1e9 attoMSG
        }
    }

    pub fn fee_at_price(&self, gas: u64, price: Decimal) -> Uint128 {
        let gas_dec = Uint128::from(gas);
        // fee = gas * price
        gas_dec.multiply_ratio(price.numerator(), price.denominator())
    }

    pub fn fee_low(&self, gas: u64) -> Uint128 {
        self.fee_at_price(gas, self.gas_price)
    }

    pub fn fee_avg(&self, gas: u64) -> Uint128 {
        self.fee_at_price(gas, self.avg_gas_price)
    }

    pub fn fee_high(&self, gas: u64) -> Uint128 {
        self.fee_at_price(gas, self.high_gas_price)
    }

    pub fn format_msg(&self, gas: u64) -> String {
        let low = self.fee_low(gas);
        let avg = self.fee_avg(gas);
        let high = self.fee_high(gas);
        format!(
            "Gas: {}, Fee: {} / {} / {} umsg",
            gas, low, avg, high
        )
    }
}

// 使用示例
// let calc = GasCalculator::new();
// let gas = execute_transfer(/*...*/);
// println!("{}", calc.format_msg(gas));
// // 输出: Gas: 234567, Fee: 2345 / 5864 / 9382 umsg

E. 参考资源

F. 术语对照表

本文档遵循 MSG Chain 合约开发最佳实践，建议结合 msg-chain-devkit 工具进行实际 Gas 测试和验证。所有数据基于模拟环境和测试网估算，实际 Gas 消耗可能有所不同。