区块链溯源：实现区块链技术在房地产交易中的应用

    // 生成区块链身份标识符
    function generateId() {
      return crypto.createHash('sha256').update(Math.random().toString()).digest('hex');
    }
    
    // 初始化链
    const blockchain = new Blockchain();
    
    // 创建新区块
    async function createNewBlock(blockData) {
      const previousBlock = await getLatestBlock();
    
      // 生成新的区块
      const block = blockchain.generateNextBlock(previousBlock, blockData);
    
      // 将区块添加至链上
      addBlockToChain(block);
    
      console.log(`Block ${block.index} has been added to the chain.`);
      return block;
    }
    
    // 添加区块到链上
    function addBlockToChain(newBlock) {
      if (isValidNewBlock(newBlock, getLatestBlock())) {
    blockchain.addBlock(newBlock);
    console.log("Congratulations! The block was forged successfully.");
      } else {
    console.error("The block cannot be added to the chain. Reason: Invalid block or block is already present.");
      }
    }
    
    // 检测区块是否有效
    function isValidNewBlock(newBlock, previousBlock) {
      if (!previousBlock) {
    return true;
      }
    
      return (previousBlock.index + 1 === newBlock.index && 
      previousBlock.hash === newBlock.previousHash);
    }
    
    // 获取最新区块
    function getLatestBlock() {
      return blockchain.getBlockByIndex(blockchain.length - 1);
    }
    
    // 插入房屋信息
    createNewBlock({
      type: 'property',
      id: generateId(),
      address: "29 King Street, London NW1",
      size: 200,
      direction: "East",
      floor: 7,
      description: "A beautiful two bedroom property in a quaint village with amazing views.",
      pictures: [
    "https://images.unsplash.com/photo-1517611522570-b4e3f71d1ae9?ixlib=rb-1.2.1&auto=format&fit=crop&w=1200&q=80"
      ],
      features: ["kitchenette", "garden"],
      location: {lat: 51.5073219, lng: -0.1276474},
      owner: "John Smith"
    });

    // 创建房屋抵押合同
    async function createMortgageContract(id) {
      const mortgageContract = new MortgageContract(id);
      const signedMortgageContract = await signContract(mortgageContract);
    
      addContractToLedger(signedMortgageContract);
    
      return signedMortgageContract;
    }
    
    // 对区块链合同签名
    async function signContract(contract) {
      contract.sign(await getUserSignature());
      return contract;
    }
    
    // 添加合同至区块链
    function addContractToLedger(contract) {
      writeContractToDatabase(contract);
      broadcastContract(contract);
    }
    
    // 广播合同至区块链网络
    function broadcastContract(contract) {
      io.emit('broadcast-contract', contract);
    }
    
    // 从数据库读取合同
    function readContractFromDatabase(id) {
      return contracts[id];
    }
    
    // 将合同写入数据库
    function writeContractToDatabase(contract) {
      contracts[contract.id] = contract;
    }
    
    // 根据合同ID创建担保合同
    async function createGuarantorContract(ownerAddress, mortgageId, periodInMonths, interestRatePerMonth) {
      const guarantorContract = new GuarantorContract(ownerAddress, mortgageId, periodInMonths, interestRatePerMonth);
      const signedGuarantorContract = await signContract(guarantorContract);
    
      addGuarantorContractToLedger(signedGuarantorContract);
    
      return signedGuarantorContract;
    }
    
    // 将担保合同写入区块链
    function addGuarantorContractToLedger(guarantorContract) {
      writeGuarantorContractToDatabase(guarantorContract);
      broadcastGuarantorContract(guarantorContract);
    }
    
    // 广播担保合同至区块链
    function broadcastGuarantorContract(guarantorContract) {
      io.emit('broadcast-guarantor-contract', guarantorContract);
    }
    
    // 从数据库读取担保合同
    function readGuarantorContractFromDatabase(mortgageId) {
      return guarantorContracts[mortgageId];
    }
    
    // 将担保合同写入数据库
    function writeGuarantorContractToDatabase(guarantorContract) {
      guarantorContracts[guarantorContract.mortgageId] = guarantorContract;
    }
    
    // 查询区块链上担保人列表
    async function queryGuarantorList(mortgageId) {
      const latestBlock = getLatestBlock();
      let start = Date.now() / 1000 - GUARANTOR_CONTRACT_EXPIRATION_TIME * 365 * 24 * 60 * 60; // 两年前
    
      try {
    while(!latestBlock ||!latestBlock.hasTransactions()) {
      latestBlock = await getNextBlock();
    }
    
    const transactions = await searchByTransactionType(latestBlock.transactions, TransactionTypes.GUARANTEE_SIGNED);
    
    if (transactions.some((t) => t.data.mortgageId === mortgageId)) {
      const foundTransaction = transactions.find((t) => t.data.mortgageId === mortgageId);
      start = Math.max(foundTransaction.timestamp, start);
    
      const guarantors = [];
    
      while(true) {
        latestBlock = await getNextBlock();
    
        if (latestBlock.timestamp < start) {
          break;
        }
    
        const transactions = latestBlock.transactions.filter((t) => 
          t.type === TransactionTypes.GUARANTER_SIGNED &&
          t.data.mortgageId === mortgageId &&
          t.timestamp >= start
        );
    
        guarantors.push(...transactions.map((t) => t.data));
    
        start = transactions.reduce((acc, curr) => Math.min(acc, curr.timestamp), Number.MAX_SAFE_INTEGER);
    
        if (start <= Math.floor(Date.now() / 1000) - GUARANTOR_CONTRACT_EXPIRATION_TIME * 365 * 24 * 60 * 60) {
          break;
        }
      }
    
      return guarantors;
    }
    
    throw Error("No guarantee transaction found");
    
      } catch(err) {
    console.error(err);
    return null;
      }
    }

    // 配置充值接口
    app.post('/api/v1/recharge/:address', async (req, res) => {
      const amount = req.body.amount;
    
      try {
    // 通过区块链查询余额
    const balance = await getBalance(req.params.address);
    
    // 判断余额是否足够
    if (balance < amount) {
      throw Error("Insufficient funds");
    }
    
    // 执行充值业务
    const txHash = await rechargeUserAccount(req.params.address, amount);
    
    // 返回交易哈希
    res.status(200).json({txHash});
    
      } catch(err) {
    console.error(err);
    res.status(400).json({message: err.message});
      }
    })
    
    // 配置支付接口
    app.post('/api/v1/pay/:fromAddress/:toAddress', async (req, res) => {
      const fromAddress = req.params.fromAddress;
      const toAddress = req.params.toAddress;
      const amount = req.body.amount;
    
      try {
    // 通过区块链查询余额
    const fromBalance = await getBalance(fromAddress);
    const toBalance = await getBalance(toAddress);
    
    // 判断余额是否足够
    if (fromBalance < amount) {
      throw Error("Insufficient funds");
    }
    
    // 执行支付业务
    const txHash = await payUser(fromAddress, toAddress, amount);
    
    // 更新用户账户余额
    updateUserBalances(fromAddress, fromBalance - amount, toAddress, toBalance + amount);
    
    // 返回交易哈希
    res.status(200).json({txHash});
    
      } catch(err) {
    console.error(err);
    res.status(400).json({message: err.message});
      }
    })
    
    // 配置抵押贷款支付通道
    async function configureMortgagePaymentChannel(propertyId, ownerAddress, borrowerAddress) {
      const mortgageContract = await readContractFromDatabase(propertyId);
      const paymentChannel = new PaymentChannel(mortgageContract.loanAmount, mortgageContract.interestRatePerMonth);
    
      // 为借款人创建一个支付通道
      paymentChannels[borrowerAddress] = paymentChannel;
    
      // 向区块链网络广播支付通道配置消息
      broadcastPaymentChannelConfiguration(paymentChannel);
    }
    
    // 使用支付通道支付
    async function usePaymentChannel(fromAddress, toAddress, amount) {
      const paymentChannel = paymentChannels[fromAddress];
    
      if (!paymentChannel) {
    throw Error("Payment channel not configured yet");
      }
    
      const transferRequestResult = paymentChannel.transfer(toAddress, amount);
    
      // 如果余额不足，则立即发起充值交易
      if (transferRequestResult === TransferRequestsResults.INSUFFICIENT_FUNDS) {
    const requiredAmount = calculateRequiredDepositAmount(amount);
    const depositTxHash = await rechargeUserAccount(fromAddress, requiredAmount);
    sendDepositConfirmation(depositTxHash, fromAddress, requiredAmount);
    
    return false;
      }
    
      // 更新用户余额
      updateUserBalances(fromAddress, paymentChannel.getSenderBalance(), toAddress, paymentChannel.getReceiverBalance());
    
      // 更新支付通道状态
      broadcastPaymentChannelStatusUpdate(paymentChannel);
    
      return true;
    }

    // 客户端登录获取链上数据
    async function loginAndSyncBlockchain() {
      const walletAddress = localStorage.getItem('walletAddress') || '';
    
      if (!isLoggedIn() ||!walletAddress) {
    alert("Please log in first.");
    window.location.href = '/login';
      }
    
      try {
    // 通过区块链查询用户持有的房屋
    const ownedProperties = await getAllOwnedProperties(walletAddress);
    
    // 缓存数据至本地
    cacheOwnedProperties(ownedProperties);
    
    // 获取链上数据更新本地数据
    syncBlockchainDataWithLocalCache();
    
      } catch(err) {
    console.error(err);
    showErrorModal(err.message);
      }
    }
    
    // 查询区块链持有房屋列表
    async function getAllOwnedProperties(walletAddress) {
      const propertiesMap = {};
    
      let latestBlock = await getLatestBlock();
    
      while(!latestBlock ||!latestBlock.hasTransactions()) {
    latestBlock = await getNextBlock();
      }
    
      const transactions = await searchByTransactionType(latestBlock.transactions, TransactionTypes.PROPERTY_TRANSFERRED);
    
      for (let i = 0; i < transactions.length; i++) {
    const tx = transactions[i].data;
    
    if ((tx.from === walletAddress && propertiesMap[tx.to]) || 
      (tx.to === walletAddress && propertiesMap[tx.from])) {
      continue;
    }
    
    propertiesMap[tx.to] = getPropertyById(tx.to);
    propertiesMap[tx.from] = getPropertyById(tx.from);
      }
    
      return Object.values(propertiesMap);
    }
    
    // 通过id查找房屋信息
    function getPropertyById(id) {
      return properties[id];
    }
    
    // 同步本地缓存数据至链上
    async function synchronizeLocalCacheWithBlockchain() {
      const cachedProperties = loadCachedProperties();
      const ownedProperties = getAllOwnedProperties(getCurrentWalletAddress());
    
      for (let i = 0; i < cachedProperties.length; i++) {
    const cachedProperty = cachedProperties[i];
    
    if (ownedProperties.some((p) => p.id!== cachedProperty.id && p.description === cachedProperty.description)) {
      throw Error("Duplicate property found on blockchain.");
    }
      }
    
      const createdPropertiesIds = [];
    
      for (let i = 0; i < cachedProperties.length; i++) {
    const cachedProperty = cachedProperties[i];
    let existingPropertyIndex = ownedProperties.findIndex((p) => p.id === cachedProperty.id);
    
    if (existingPropertyIndex > -1) {
      ownedProperties.splice(existingPropertyIndex, 1);
      updatedProperties.push(cachedProperty);
    } else {
      createdProperties.push(cachedProperty);
      createdPropertiesIds.push(cachedProperty.id);
    }
      }
    
      deleteProperties(createdPropertiesIds);
    
      const deletedPropertiesCount = insertProperties(createdProperties);
    
      alert(`${deletedPropertiesCount} properties deleted and ${createdProperties.length} properties inserted`);
    }