NAC_Blockchain/charter-std-zh/acc/acc20.ch

///!
///! 资产凭证合约 - 20 (ACC-20)
///! NAC的可替代资产协议（专为RWA设计）
///!
///! **版本**: v1.0
///! **模块**: charter-std-zh/acc/acc20.ch

使用 资产::gnacs::GNACS编码;
使用 主权::规则::主权类型;

// ============================================================================
// ACC-20接口定义
// ============================================================================

/// ACC-20可替代资产接口
///
/// 定义可替代资产的标准操作
接口 ACC20 {
    // ========== 查询函数 ==========
    
    /// 查询资产总供应量
    ///
    /// # 返回
    /// - `u256`: 总供应量
    函数 总供应量() -> u256;
    
    /// 查询账户持有量
    ///
    /// # 参数
    /// - `持有者`: 账户地址
    ///
    /// # 返回
    /// - `u256`: 持有量
    函数 持有量(持有者: 地址) -> u256;
    
    /// 查询资产名称
    ///
    /// # 返回
    /// - `字符串`: 资产名称
    函数 名称() -> 字符串;
    
    /// 查询资产符号
    ///
    /// # 返回
    /// - `字符串`: 资产符号
    函数 符号() -> 字符串;
    
    /// 查询小数位数
    ///
    /// # 返回
    /// - `u8`: 小数位数
    函数 小数位() -> u8;
    
    /// 查询GNACS编码
    ///
    /// # 返回
    /// - `GNACS编码`: 资产分类编码
    函数 GNACS编码() -> GNACS编码;
    
    /// 查询主权类型
    ///
    /// # 返回
    /// - `主权类型`: 资产主权类型
    函数 主权类型() -> 主权类型;
    
    /// 查询授权额度
    ///
    /// # 参数
    /// - `持有者`: 资产持有者地址
    /// - `代理人`: 被授权的代理人地址
    ///
    /// # 返回
    /// - `u256`: 授权额度
    函数 授权额度(持有者: 地址, 代理人: 地址) -> u256;
    
    // ========== 交易函数 ==========
    
    /// 转移资产
    ///
    /// # 参数
    /// - `接收者`: 接收地址
    /// - `数额`: 转移数额
    ///
    /// # 返回
    /// - `bool`: 是否成功
    ///
    /// # 事件
    /// - `转移事件(发送者, 接收者, 数额)`
    函数 转移(接收者: 地址, 数额: u256) -> bool;
    
    /// 授权代理
    ///
    /// # 参数
    /// - `代理人`: 被授权的代理人地址
    /// - `数额`: 授权数额
    ///
    /// # 返回
    /// - `bool`: 是否成功
    ///
    /// # 事件
    /// - `授权事件(持有者, 代理人, 数额)`
    函数 授权(代理人: 地址, 数额: u256) -> bool;
    
    /// 代理转移
    ///
    /// # 参数
    /// - `发送者`: 资产持有者地址
    /// - `接收者`: 接收地址
    /// - `数额`: 转移数额
    ///
    /// # 返回
    /// - `bool`: 是否成功
    ///
    /// # 事件
    /// - `转移事件(发送者, 接收者, 数额)`
    函数 代理转移(发送者: 地址, 接收者: 地址, 数额: u256) -> bool;
    
    /// 增发资产
    ///
    /// # 参数
    /// - `接收者`: 接收地址
    /// - `数额`: 增发数额
    ///
    /// # 返回
    /// - `bool`: 是否成功
    ///
    /// # 权限
    /// - 仅发行者
    ///
    /// # 事件
    /// - `增发事件(接收者, 数额)`
    函数 增发(接收者: 地址, 数额: u256) -> bool;
    
    /// 销毁资产
    ///
    /// # 参数
    /// - `数额`: 销毁数额
    ///
    /// # 返回
    /// - `bool`: 是否成功
    ///
    /// # 事件
    /// - `销毁事件(持有者, 数额)`
    函数 销毁(数额: u256) -> bool;
}

// ============================================================================
// ACC-20事件定义
// ============================================================================

/// 转移事件
///
/// 当资产转移时触发
事件 转移事件 {
    发送者: 地址,
    接收者: 地址,
    数额: u256,
}

/// 授权事件
///
/// 当授权代理时触发
事件 授权事件 {
    持有者: 地址,
    代理人: 地址,
    数额: u256,
}

/// 增发事件
///
/// 当增发资产时触发
事件 增发事件 {
    接收者: 地址,
    数额: u256,
}

/// 销毁事件
///
/// 当销毁资产时触发
事件 销毁事件 {
    持有者: 地址,
    数额: u256,
}

// ============================================================================
// ACC-20基础实现
// ============================================================================

/// ACC-20基础实现合约
///
/// 提供ACC-20接口的标准实现
合约 ACC20基础 实现 ACC20 {
    // ========== 状态变量 ==========
    
    /// 资产名称
    私有 _名称: 字符串;
    
    /// 资产符号
    私有 _符号: 字符串;
    
    /// 小数位数
    私有 _小数位: u8;
    
    /// GNACS编码
    私有 _gnacs编码: GNACS编码;
    
    /// 主权类型
    私有 _主权类型: 主权类型;
    
    /// 总供应量
    私有 _总供应量: u256;
    
    /// 持有量映射
    私有 _持有量: 映射<地址, u256>;
    
    /// 授权映射
    私有 _授权: 映射<地址, 映射<地址, u256>>;
    
    /// 发行者地址
    私有 _发行者: 地址;
    
    // ========== 构造函数 ==========
    
    /// 构造函数
    ///
    /// # 参数
    /// - `名称`: 资产名称
    /// - `符号`: 资产符号
    /// - `小数位`: 小数位数
    /// - `gnacs编码`: GNACS分类编码
    /// - `主权类型`: 主权类型
    /// - `初始供应量`: 初始供应量
    构造函数(
        名称: 字符串,
        符号: 字符串,
        小数位: u8,
        gnacs编码: GNACS编码,
        主权类型: 主权类型,
        初始供应量: u256
    ) {
        _名称 = 名称;
        _符号 = 符号;
        _小数位 = 小数位;
        _gnacs编码 = gnacs编码;
        _主权类型 = 主权类型;
        _发行者 = 消息.发送者;
        
        如果 初始供应量 > 0 {
            _总供应量 = 初始供应量;
            _持有量[消息.发送者] = 初始供应量;
            触发 转移事件 {
                发送者: 地址::零地址(),
                接收者: 消息.发送者,
                数额: 初始供应量,
            };
        }
    }
    
    // ========== 查询函数实现 ==========
    
    函数 总供应量() -> u256 {
        返回 _总供应量;
    }
    
    函数 持有量(持有者: 地址) -> u256 {
        返回 _持有量[持有者];
    }
    
    函数 名称() -> 字符串 {
        返回 _名称;
    }
    
    函数 符号() -> 字符串 {
        返回 _符号;
    }
    
    函数 小数位() -> u8 {
        返回 _小数位;
    }
    
    函数 GNACS编码() -> GNACS编码 {
        返回 _gnacs编码;
    }
    
    函数 主权类型() -> 主权类型 {
        返回 _主权类型;
    }
    
    函数 授权额度(持有者: 地址, 代理人: 地址) -> u256 {
        返回 _授权[持有者][代理人];
    }
    
    // ========== 交易函数实现 ==========
    
    函数 转移(接收者: 地址, 数额: u256) -> bool {
        要求(接收者 != 地址::零地址(), "ACC20: 不能转移到零地址");
        要求(_持有量[消息.发送者] >= 数额, "ACC20: 余额不足");
        
        _持有量[消息.发送者] -= 数额;
        _持有量[接收者] += 数额;
        
        触发 转移事件 {
            发送者: 消息.发送者,
            接收者: 接收者,
            数额: 数额,
        };
        
        返回 真;
    }
    
    函数 授权(代理人: 地址, 数额: u256) -> bool {
        要求(代理人 != 地址::零地址(), "ACC20: 不能授权给零地址");
        
        _授权[消息.发送者][代理人] = 数额;
        
        触发 授权事件 {
            持有者: 消息.发送者,
            代理人: 代理人,
            数额: 数额,
        };
        
        返回 真;
    }
    
    函数 代理转移(发送者: 地址, 接收者: 地址, 数额: u256) -> bool {
        要求(接收者 != 地址::零地址(), "ACC20: 不能转移到零地址");
        要求(_持有量[发送者] >= 数额, "ACC20: 余额不足");
        要求(_授权[发送者][消息.发送者] >= 数额, "ACC20: 授权额度不足");
        
        _持有量[发送者] -= 数额;
        _持有量[接收者] += 数额;
        _授权[发送者][消息.发送者] -= 数额;
        
        触发 转移事件 {
            发送者: 发送者,
            接收者: 接收者,
            数额: 数额,
        };
        
        返回 真;
    }
    
    函数 增发(接收者: 地址, 数额: u256) -> bool {
        要求(消息.发送者 == _发行者, "ACC20: 仅发行者可以增发");
        要求(接收者 != 地址::零地址(), "ACC20: 不能增发到零地址");
        
        _总供应量 += 数额;
        _持有量[接收者] += 数额;
        
        触发 增发事件 {
            接收者: 接收者,
            数额: 数额,
        };
        
        触发 转移事件 {
            发送者: 地址::零地址(),
            接收者: 接收者,
            数额: 数额,
        };
        
        返回 真;
    }
    
    函数 销毁(数额: u256) -> bool {
        要求(_持有量[消息.发送者] >= 数额, "ACC20: 余额不足");
        
        _持有量[消息.发送者] -= 数额;
        _总供应量 -= 数额;
        
        触发 销毁事件 {
            持有者: 消息.发送者,
            数额: 数额,
        };
        
        触发 转移事件 {
            发送者: 消息.发送者,
            接收者: 地址::零地址(),
            数额: 数额,
        };
        
        返回 真;
    }
}