共享物品租借合约程序，借出归还自动记录，超时自动计算，损坏按规则赔偿，无需人工盯守。

一、 实际应用场景描述

想象一个基于区块链的“邻里借物”或“无人租赁”场景：

1. 借充电宝：你在商场借了一个共享充电宝，无需扫码付押金。系统通过你的数字身份（私钥）锁定一笔保证金（Gas费）。

2. 借专业设备：你向社区里的摄影师借一台无人机。你们双方签署一个链上租借合约，约定租期3天，租金50元，押金2000元。

3. 自动执行：

* 如果你按时归还且设备完好，合约自动将押金退还给你，租金转给摄影师。

* 如果你超时未还，合约自动扣除超时费。

* 如果你弄坏了设备，你归还时，合约通过预言机获取“损坏评级”，自动计算赔偿金并从押金中扣除，无需摄影师手动索赔。

二、 引入痛点（传统租借模式的弊端）

1. 信任成本高：借出方担心东西回不来，借入方担心押金退不回来。

2. 人工盯守累：借出后需要时刻记着催还，或者反复沟通赔偿标准。

3. 执行难：东西坏了，对方耍赖不赔钱，走法律程序成本太高。

4. 中心化平台抽成：传统租赁平台（如共享单车、充电宝）通常要收取高额手续费和管理费。

三、 核心逻辑讲解（区块链思维的应用）

本系统的核心是“智能合约（Smart Contract）+ 状态机（State Machine）”。

1. 状态机模型：租借合约不再是简单的记录，而是一个有生命周期的对象。状态流转如下：

"CREATED (已创建) -> ACTIVE (租借中) -> RETURNED (已归还) -> SETTLED (已结算)"每一步状态变更都由代码严格触发，不允许越级操作。

2. 自动执行（Deterministic Execution）：合约部署时就写死了规则（租金、押金、超时费率、损坏赔偿比例）。一旦条件满足（如

"current_time > due_date"），合约自动执行扣款逻辑，无需人工介入，杜绝赖账。

3. 预言机（Oracle）接入：如何判断物品是否损坏？在高级模型中，我们会引入“预言机”来桥接链下世界。例如，借入方上传照片，AI鉴定接口返回“损坏等级”，该数据上链触发合约赔付逻辑。

四、 代码模块化实现

项目结构：

leasechain/

├── contract.py # 智能合约逻辑（状态机）

├── blockchain.py # 链与账户管理

├── oracle.py # 预言机（模拟损坏评估）

├── app.py # Flask API

└── requirements.txt

1.

"contract.py" - 租借智能合约

# contract.py

from datetime import datetime, timedelta

from enum import Enum

class LeaseStatus(Enum):

"""租借合约状态枚举"""

CREATED = "Created"

ACTIVE = "Active"

RETURNED = "Returned"

SETTLED = "Settled"

class LeaseContract:

"""

租借智能合约类

这是一个状态机，管理整个租借生命周期

"""

def __init__(self, contract_id, lender, borrower, item_desc, deposit, rent, duration_hours):

self.contract_id = contract_id

self.lender = lender # 出借人地址（公钥）

self.borrower = borrower # 借入人地址（公钥）

self.item_desc = item_desc

self.deposit = deposit # 押金

self.rent = rent # 租金

self.duration = duration_hours # 租期（小时）

self.status = LeaseStatus.CREATED

self.start_time = None

self.return_time = None

self.damage_level = 0 # 损坏等级 0-10

def activate(self, current_time):

"""激活合约（借出物品）"""

if self.status != LeaseStatus.CREATED:

raise ValueError("合约状态错误")

self.status = LeaseStatus.ACTIVE

self.start_time = current_time

print(f"合约 {self.contract_id} 已激活，租期开始。")

def return_item(self, damage_level, current_time):

"""归还物品"""

if self.status != LeaseStatus.ACTIVE:

raise ValueError("合约未在活跃状态")

self.status = LeaseStatus.RETURNED

self.return_time = current_time

self.damage_level = damage_level

print(f"合约 {self.contract_id} 物品已归还，损坏等级: {damage_level}")

def settle(self, current_time):

"""

结算合约（核心逻辑）

自动计算超时费和损坏赔偿

"""

if self.status != LeaseStatus.RETURNED:

raise ValueError("物品尚未归还")

# 1. 计算超时费

due_date = self.start_time + timedelta(hours=self.duration)

overtime_fee = 0

if self.return_time > due_date:

overtime_hours = (self.return_time - due_date).total_seconds() / 3600

overtime_fee = int(overtime_hours * (self.rent * 0.5)) # 超时费=租金的50%/小时

# 2. 计算损坏赔偿 (假设 damage_level 0-10, 每级扣10%押金)

damage_fee = int(self.deposit * (self.damage_level / 10))

# 3. 计算最终退款

total_deduction = self.rent + overtime_fee + damage_fee

refund = self.deposit - total_deduction

if refund < 0:

refund = 0 # 押金不够扣

self.status = LeaseStatus.SETTLED

return {

"refund_to_borrower": refund,

"payment_to_lender": self.rent + overtime_fee + damage_fee,

"overtime_fee": overtime_fee,

"damage_fee": damage_fee

}

2.

"blockchain.py" - 链与账户

# blockchain.py

import hashlib

import json

from datetime import datetime

from contract import LeaseContract, LeaseStatus

class LeaseChain:

"""

租借区块链

管理所有租借合约和账户余额

"""

def __init__(self):

self.contracts = {} # {contract_id: LeaseContract}

self.accounts = {} # {address: balance} 模拟账户余额

def create_account(self, address, initial_balance):

self.accounts[address] = initial_balance

def deploy_contract(self, contract_params):

"""部署新的租借合约"""

contract = LeaseContract(**contract_params)

self.contracts[contract.contract_id] = contract

return contract

def execute_contract(self, contract_id, action, params=None):

"""执行合约动作"""

contract = self.contracts.get(contract_id)

if not contract:

raise ValueError("合约不存在")

current_time = params.get("current_time", datetime.now()) if params else datetime.now()

if action == "activate":

contract.activate(current_time)

elif action == "return":

contract.return_item(params["damage_level"], current_time)

elif action == "settle":

result = contract.settle(current_time)

# 模拟资金流转

self._transfer_funds(contract, result)

return result

return {"status": contract.status.value}

def _transfer_funds(self, contract, settlement_result):

"""模拟链上资金划转"""

borrower_refund = settlement_result["refund_to_borrower"]

lender_payment = settlement_result["payment_to_lender"]

# 从合约中释放资金

self.accounts[contract.borrower] += borrower_refund

self.accounts[contract.lender] += lender_payment

print(f"资金已划转：借入人 {contract.borrower} 收到 {borrower_refund}, 出借人 {contract.lender} 收到 {lender_payment}")

3.

"app.py" - Web API

# app.py

from flask import Flask, request, jsonify

from blockchain import LeaseChain

from datetime import datetime

app = Flask(__name__)

lease_chain = LeaseChain()

# 模拟账户

LEASE_CHAIN.create_account("lender_alice", 10000)

LEASE_CHAIN.create_account("borrower_bob", 5000)

@app.route('/contract/create', methods=['POST'])

def create_contract():

"""创建租借合约"""

data = request.json

contract_params = {

"contract_id": data["contract_id"],

"lender": data["lender_address"],

"borrower": data["borrower_address"],

"item_desc": data["item_desc"],

"deposit": data["deposit"],

"rent": data["rent"],

"duration_hours": data["duration_hours"]

}

lease_chain.deploy_contract(contract_params)

return jsonify({"message": "合约创建成功", "contract_id": data["contract_id"]})

@app.route('/contract/<contract_id>/<action>', methods=['POST'])

def interact_contract(contract_id, action):

"""与合约交互（激活、归还、结算）"""

params = request.json or {}

params["current_time"] = datetime.now()

try:

result = lease_chain.execute_contract(contract_id, action, params)

return jsonify(result)

except ValueError as e:

return jsonify({"error": str(e)}), 400

@app.route('/account/<address>', methods=['GET'])

def get_account(address):

"""查询账户余额"""

balance = lease_chain.accounts.get(address, 0)

return jsonify({"address": address, "balance": balance})

if __name__ == '__main__':

app.run(debug=True, port=5004)

五、 README 文件与使用说明

README.md

# LeaseChain - 共享物品租借合约系统

## 🤝 项目简介

LeaseChain 是一个基于区块链的智能合约应用，旨在实现物品租借的自动化与去信任化。通过代码强制执行租借规则，自动计算超时费和损坏赔偿，无需人工盯守，杜绝扯皮。

## ✨ 核心特性

* **代码即法律**：规则写在合约里，机器自动执行，没有情面可讲。

* **全自动结算**：超时、损坏赔偿自动从押金扣除，即时到账。

* **状态机管理**：清晰的租借生命周期（Created -> Active -> Returned -> Settled）。

* **零人工干预**：适合无人值守租赁柜、社区共享经济。

## 🚀 快速开始

### 1. 运行服务

bash

python app.py

### 2. API 使用示例

**a) 创建租借合约**

bash

curl -X POST http://127.0.0.1:5004/contract/create \

-H "Content-Type: application/json" \

-d '{

"contract_id": "DRONE_001",

"lender_address": "lender_alice",

"borrower_address": "borrower_bob",

"item_desc": "DJI Mini 3 Pro",

"deposit": 2000,

"rent": 100,

"duration_hours": 48

}'

**b) 激活合约（借出物品）**

bash

curl -X POST http://127.0.0.1:5004/contract/DRONE_001/activate

**c) 归还物品并申报损坏**

bash

curl -X POST http://127.0.0.1:5004/contract/DRONE_001/return \

-H "Content-Type: application/json" \

-d '{"damage_level": 3}' # 假设损坏等级为3

**d) 结算合约**

bash

curl -X POST http://127.0.0.1:5004/contract/DRONE_001/settle

**e) 查询账户余额**

bash

curl http://127.0.0.1:5004/account/borrower_bob

## 🧠 创新点

利用状态机和确定性逻辑，将复杂的“人际信任”问题转化为简单的“数学执行”问题。

六、 核心知识点卡片 (Flash Cards)

概念 解释 在本项目中的应用

智能合约 (Smart Contract) 运行在区块链上的自动化脚本，满足条件即执行。 租借规则（租金、押金、超时费）被编码进合约。

状态机 (State Machine) 对象在不同状态间转换的模型。 合约的

"CREATED -> ACTIVE -> RETURNED -> SETTLED" 流转。

预言机 (Oracle) 将链下真实世界数据引入链上的中间件。 本例中简化为

"damage_level"，实际应为AI鉴定接口。

去中心化自治组织 (DAO) 基于智能合约的组织形式。 未来可扩展为租赁DAO，由社区投票决定仲裁规则。

原子性 (Atomicity) 交易要么完全成功，要么完全失败，不存在中间状态。 结算时，扣款和转账必须同时发生。

七、 总结

作为全栈工程师，通过这个 LeaseChain 项目，我们不仅仅是写了几个API，而是构建了一套“数字化协作协议”。

* 创新思维突破：我们打破了“借东西靠人情”的传统认知，引入了“算法执法”的概念。在Web3.0时代，信任不应该建立在熟人或抵押品之上，而应建立在透明的代码之上。

* 技术价值：这种架构非常适合物联网（IoT）租赁。想象一下，一辆共享单车就是一个智能合约终端，你扫码即调用

"activate()"，锁车即调用

"return()"，整个过程无需任何人工客服介入。

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！