代理模式

use openzeppelin_stylus::proxy::IProxy;
use stylus_sdk::prelude::*;

pub unsafe trait IProxy: TopLevelStorage + Sized {
    /// Delegates the current call to a specific implementation
    /// 将当前调用委托给特定的实现
    fn delegate(
        &mut self,
        implementation: Address,
        calldata: &[u8],
    ) -> Result<Vec<u8>, Error>;

    /// Returns the address of the implementation contract
    /// 返回实现合约的地址
    fn implementation(&self) -> Result<Address, Vec<u8>>;

    /// Fallback function that delegates calls to the implementation
    /// 将调用委托给实现的 Fallback 函数
    fn do_fallback(&mut self, calldata: &[u8]) -> Result<Vec<u8>, Vec<u8>>;
}

use openzeppelin_stylus::proxy::IProxy;
use stylus_sdk::{
    alloy_primitives::Address,
    prelude::*,
    storage::StorageAddress,
    ArbResult,
};

#[entrypoint]
#[storage]
struct MyProxy {
    implementation: StorageAddress,
}

#[public]
impl MyProxy {
    #[constructor]
    fn constructor(&mut self, implementation: Address) {
        self.implementation.set(implementation);
    }

    /// Fallback function that delegates all calls to the implementation
    /// 将所有调用委托给实现的 Fallback 函数
    #[fallback]
    fn fallback(&mut self, calldata: &[u8]) -> ArbResult {
        unsafe { self.do_fallback(calldata) }
    }
}

impl IProxy for MyProxy {
    fn implementation(&self) -> Result<Address, Vec<u8>> {
        Ok(self.implementation.get())
    }
}

#[entrypoint]
#[storage]
struct MyToken {
    // ⚠️ The storage layout here must match the proxy's storage layout exactly.
    // ⚠️ 这里的存储布局必须与代理的存储布局完全匹配。
    // For example, if the proxy defines implementation and admin addresses,
    // 例如，如果代理定义了实现和 admin 地址，
    // the implementation must define them in the same order and type.
    // 则实现必须以相同的顺序和类型定义它们。
    // This prevents storage collisions when using delegatecall.
    // 这可以防止在使用 delegatecall 时发生存储冲突。
    implementation: StorageAddress,
    admin: StorageAddress,
    // Now you can set the actual implementation-specific state fields.
    // 现在你可以设置实际的特定于实现的状态字段。
    erc20: Erc20,
}

#[public]
#[implements(IErc20<Error = erc20::Error>)]
impl MyToken {
    #[constructor]
    fn constructor(&mut self, name: String, symbol: String) {
        // Initialize the ERC-20 with metadata
        // 使用元数据初始化 ERC-20
        self.erc20.constructor(name, symbol);
    }

    /// Mint tokens to a specific address (only for demonstration)
    /// 将 Token 铸造到特定地址（仅用于演示）
    fn mint(&mut self, to: Address, amount: U256) -> Result<(), erc20::Error> {
        self.erc20._mint(to, amount)
    }
}

#[public]
impl IErc20 for MyToken {
    // ...
}

#[storage]
struct MyUpgradeableProxy {
    // Proxy-specific storage
    // 代理特定的存储
    implementation: StorageAddress,
    admin: StorageAddress,

    // Implementation storage (shared with the implementation contract)
    // 实现存储（与实现合约共享）
    // These fields must exactly match the implementation contract's storage layout
    // 这些字段必须与实现合约的存储布局完全匹配
    // They are automatically initialized to default values (0, empty mappings, etc.)
    // 它们会自动初始化为默认值（0、空映射等）
    balances: StorageMapping<Address, U256>,
    allowances: StorageMapping<(Address, Address), U256>,
    total_supply: StorageU256,
    // ... any additional state used by the implementation
    // ... 实现使用的任何其他状态
}