区块链国赛笔记 06｜Solidity 存证合约：存储、接口与工具库

## 接口合约设计

### 接口合约设计

接口合约是只包含函数声明而不包含实现的抽象合约，用于定义合约之间的交互标准。

设计原则：

- 强制标准化：过接口约束外部合约的调用规范，例如代币协议（ERC20/ERC721）必须实现标准函数。
- 无状态性：接口内禁止定义状态变量或构造函数，仅声明函数签名。
- 全外部可见性：**外部可见性**：所有函数必须为 `external`；实现合约中可以用 public 函数实现对应的 external 接口。

- 明确职责分离
- 保持接口最小化

---

接口类型：

- 代币标准接口
- Defi协议接口
- Oracle 预言机接口

- 错误处理接口
- 跨链桥接口
- 多继承接口
- 治理接口
- 实用工具接口
- 跨链桥接口


接口代码示例

```solidity
// 支持多继承的Difi组合接口
interface IAvancedDefi is IERC20, IUniswapV2Pair {
	// 闪电贷功能（代币和NFT混合抵押）
	function flashLoan(
		address asset,
		uint256 amount,
		bytes calldata data
	) external payable returns (bool);

	// 跨链调用扩展 （需要预言机）
	function crossChainCall(
		uint256 targetChainId,
		address targetContract,
		bytes calldata payload
	) external payable;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// ERC20标准合约示例
interface IERC20 {
	function totalSupply() external view returns (uint256);
	function balanceOf(address account) external view returns (uint256);
	function transfer(address recipient, uint256 amount) external returns(bool);

}

require(

    IInterface(target).supportsInterface(type(IStandard).interfaceId),

    "Invalid interface"

);

pragma solidity ^0.4.24;

library Address {


	// 检查地址是否为合约
    function isContract(address addr) internal view returns(bool) {
        uint256 size;
        assembly { size := extcodesize(addr) }
        // 这里使用了 assembly 对 EVM 进行字节码级操作
        // extcodesize是 EVM 内置函数，返回指定地址的合约代码大小
        // 如果 size > 0 那说明这个地址的确是个合约
        return size > 0;
    }

    function isEmptyAddress(address addr) internal pure returns(bool){
        return addr == address(0); // 一目了然 检查合约是不是空地址
    }
}

function bytesToString(bytes memory _bytes) internal pure returns (string memory){
    bytes memory bytesArray = new bytes(_bytes.length);
    for (uint256 i; i < _bytes.length; i++) {
        bytesArray[i] = _bytes[i];
    }
    return string(_bytes);  // ❌ 这里应该是return string(bytesArray);
}

function bytesToString(bytes memory _bytes) internal pure returns (string memory){
    bytes memory bytesArray = new bytes(_bytes.length); // 无用的复制
    for (uint256 i; i < _bytes.length; i++) {
        bytesArray[i] = _bytes[i];
    }
    return string(_bytes);
}
function bytes32ToString(bytes32 _bytes32) internal pure returns(string memory){
    bytes memory bytesString = new bytes(32);
    uint charCount = 0 ;
    for(uint i = 0 ; i<32;i++){
        byte char = byte(bytes32(uint(_bytes32) *2 **(8*i))); //错误的位操作** (8 * i)))
        if(char !=0){
            bytesString[charCount] = char;
            charCount++;
        }
    }
    bytes memory bytesStringTrimmed = new bytes(charCount);
    for(uint j=0;j<charCount;j++){
        bytesStringTrimmed[j]=bytesString[j];
    }
    return string(bytesStringTrimmed);
}

function bytesToString(bytes memory _bytes) internal pure returns (string memory){
    return string(_bytes);
}
function bytes32ToString(bytes32 _bytes32) public pure returns (string) {
    uint8 length;
    while (length < 32 && _bytes32[length] != 0) {
        length++;
    }
    bytes memory bytesString = new bytes(length);
    for (uint i = 0; i < length; i++) {
        bytesString[i] = _bytes32[i];
    }
    return string(bytesString);
}

function testLetterA() public pure returns (string result, string correct, bool isEqual) {
    bytes32 input = bytes32(uint(65)); // 'A'
    result = bytes32ToString(input);
    correct = bytes32ToStringCorrect(input);
    isEqual = keccak256(result) == keccak256(correct);
}