区块链 + 智能合约在合同管理系统中的应用前景与落地路径

// 一个简单的电子合同存证智能合约
pragma solidity ^0.8.0;

contract DocumentRegistry {
    // 存储文档哈希值及其元数据
    struct Document {
        address owner;
        uint256 timestamp;
        string documentHash;
    }
    
    // 映射：文档ID => 文档详情
    mapping(uint256 => Document) public documents;
    
    // 事件：用于日志记录和前端通知
    event DocumentRegistered(uint256 indexed docId, address owner, uint256 timestamp);
    
    /**
     * @dev 注册新的文档哈希到区块链
     * @param _docId 文档唯一标识符
     * @param _documentHash 文档内容的哈希值
     */
    function registerDocument(uint256 _docId, string memory _documentHash) external {
        require(bytes(_documentHash).length > 0, "Invalid document hash");
        require(documents[_docId].timestamp == 0, "Document ID already exists");
        
        documents[_docId] = Document({
            owner: msg.sender,
            timestamp: block.timestamp,
            documentHash: _documentHash
        });
        
        emit DocumentRegistered(_docId, msg.sender, block.timestamp);
    }
    
    /**
     * @dev 验证文档哈希是否与链上记录一致
     * @param _docId 要验证的文档ID
     * @param _documentHash 待验证的文档哈希
     */
    function verifyDocument(uint256 _docId, string memory _documentHash) external view returns (bool) {
        Document memory doc = documents[_docId];
        if (doc.timestamp == 0) return false;
        
        // 比较字符串哈希（实际项目中需使用更安全的比较方式）
        return keccak256(abi.encodePacked(doc.documentHash)) == keccak256(abi.encodePacked(_documentHash));
    }
}

// 前端使用Web3.js与智能合约交互示例
import Web3 from 'web3';

class ContractManager {
  constructor(contractAddress, contractABI) {
    this.web3 = new Web3(Web3.givenProvider || 'http://localhost:8545');
    this.contract = new this.web3.eth.Contract(contractABI, contractAddress);
    this.account = null;
  }

  // 连接钱包并获取账户
  async connectWallet() {
    const accounts = await window.ethereum.request({ 
      method: 'eth_requestAccounts' 
    });
    this.account = accounts[0];
    return this.account;
  }

  /**
   * 注册文档到区块链
   * @param {number} docId - 文档ID
   * @param {string} content - 文档内容
   */
  async registerDocument(docId, content) {
    // 计算文档内容的SHA-256哈希
    const hash = this.web3.utils.sha3(content);
    
    try {
      const result = await this.contract.methods
        .registerDocument(docId, hash)
        .send({ from: this.account });
      
      console.log('文档注册成功，交易哈希:', result.transactionHash);
      return result;
    } catch (error) {
      console.error('文档注册失败:', error);
      throw error;
    }
  }

  /**
   * 验证文档完整性
   * @param {number} docId - 文档ID
   * @param {string} content - 待验证的文档内容
   */
  async verifyDocument(docId, content) {
    const hash = this.web3.utils.sha3(content);
    
    try {
      const isValid = await this.contract.methods
        .verifyDocument(docId, hash)
        .call({ from: this.account });
      
      return isValid;
    } catch (error) {
      console.error('验证过程中出错:', error);
      return false;
    }
  }
}

// 使用示例
// const manager = new ContractManager('0x1234...', abi);
// await manager.connectWallet();
// await manager.registerDocument(1001, '合同内容...');

// 后端合同处理服务示例
using System;
using System.Security.Cryptography;
using System.Text;
using Nethereum.Web3;

namespace ContractManagementService
{
    public class BlockchainService
    {
        private readonly Web3 _web3;
        private readonly string _contractAddress;
        private readonly string _abi;
        
        public BlockchainService(string nodeUrl, string contractAddress, string abi)
        {
            _web3 = new Web3(nodeUrl);
            _contractAddress = contractAddress;
            _abi = abi;
        }
        
        /// 

        /// 生成文档内容的SHA256哈希
        /// 
        public string ComputeDocumentHash(string content)
        {
            using (var sha256 = SHA256.Create())
            {
                var bytes = Encoding.UTF8.GetBytes(content);
                var hashBytes = sha256.ComputeHash(bytes);
                return BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
            }
        }
        
        /// 

        /// 将合同注册到区块链
        /// 
        public async Task RegisterContractAsync(int contractId, string contractContent, string privateKey)
        {
            try
            {
                var account = new Nethereum.Web3.Accounts.Account(privateKey);
                var web3 = new Web3(account, _web3.Client);
                
                var contract = web3.Eth.GetContract(_abi, _contractAddress);
                var registerFunction = contract.GetFunction("registerDocument");
                
                var hash = ComputeDocumentHash(contractContent);
                
                var transactionHash = await registerFunction.SendTransactionAsync(
                    account.Address, 
                    contractId, 
                    hash
                );
                
                return transactionHash;
            }
            catch (Exception ex)
            {
                // 记录日志并处理异常
                throw new ApplicationException("区块链注册失败", ex);
            }
        }
        
        /// 

        /// 验证合同内容是否与链上记录一致
        /// 
        public async Task VerifyContractAsync(int contractId, string contractContent)
        {
            try
            {
                var contract = _web3.Eth.GetContract(_abi, _contractAddress);
                var verifyFunction = contract.GetFunction("verifyDocument");
                
                var hash = ComputeDocumentHash(contractContent);
                
                var isValid = await verifyFunction.CallAsync(contractId, hash);
                return isValid;
            }
            catch (Exception ex)
            {
                // 处理验证过程中的异常
                return false;
            }
        }
    }
}