RWA实操指南（三）：流动性提供与用户交互，完成生态闭环

  1// go代码：RWA流动性管理系统 - Uniswap V3集成
  2package main
  3
  4import (
  5	"crypto/ecdsa"
  6	"errors"
  7	"fmt"
  8	"math/big"
  9	"time"
 10
 11	// 注意：实际使用时需要导入以太坊相关包
 12	// "github.com/ethereum/go-ethereum"
 13	// "github.com/ethereum/go-ethereum/common"
 14	// "github.com/ethereum/go-ethereum/crypto"
 15)
 16
 17// Token 代币信息结构
 18type Token struct {
 19	Address     string  // 代币合约地址
 20	Symbol      string  // 代币符号
 21	Decimals    uint8   // 小数位数
 22	TotalSupply *big.Int // 总供应量
 23	Name        string  // 代币名称
 24}
 25
 26// PoolFee Uniswap V3支持的费率
 27type PoolFee int
 28
 29const (
 30	Fee0_01    PoolFee = 100    // 0.01%
 31	Fee0_05    PoolFee = 500    // 0.05%
 32	Fee0_3     PoolFee = 3000   // 0.3%
 33	Fee1       PoolFee = 10000  // 1%
 34)
 35
 36// TickRange 集中流动性的价格区间
 37type TickRange struct {
 38	LowerTick int // 下界价格刻度
 39	UpperTick int // 上界价格刻度
 40}
 41
 42// Pool Uniswap V3 流动性池
 43type Pool struct {
 44	Address       string   // 池合约地址
 45	Token0        Token    // 代币0
 46	Token1        Token    // 代币1
 47	Fee           PoolFee  // 交易费率
 48	Liquidity     *big.Int // 当前流动性
 49	SqrtRatioX96  *big.Int // 当前价格的sqrt值乘以2^96
 50}
 51
 52// Position 流动性头寸
 53type Position struct {
 54	Owner         string   // 头寸所有者
 55	Token0Amount  *big.Int // 投入的token0数量
 56	Token1Amount  *big.Int // 投入的token1数量
 57	TickRange     TickRange // 价格区间
 58	FeeGrowthInside *big.Int // 已累计的手续费增长
 59	Liquidity     *big.Int // 提供的流动性
 60}
 61
 62// LiquidityManager 流动性管理接口
 63type LiquidityManager interface {
 64	CreatePool(token0, token1 Token, fee PoolFee) (*Pool, error)
 65	MintPosition(pool *Pool, owner string, token0Amount, token1Amount *big.Int, tickRange TickRange) (*Position, error)
 66	CollectFees(position *Position) (*big.Int, *big.Int, error)
 67	IncreaseLiquidity(position *Position, token0Amount, token1Amount *big.Int) error
 68}
 69
 70// UniswapManager Uniswap V3流动性管理器实现
 71type UniswapManager struct {
 72	Pools     map[string]*Pool
 73	Positions map[string]*Position
 74	ChainID   *big.Int
 75}
 76
 77// NewUniswapManager 创建新的Uniswap管理器
 78func NewUniswapManager(chainID *big.Int) *UniswapManager {
 79	return &UniswapManager{
 80		Pools:     make(map[string]*Pool),
 81		Positions: make(map[string]*Position),
 82		ChainID:   chainID,
 83	}
 84}
 85
 86// GeneratePoolAddress 生成池地址（模拟）
 87func GeneratePoolAddress(token0, token1 Token, fee PoolFee) string {
 88	// 实际实现中应使用Uniswap V3工厂合约的create2逻辑
 89	return fmt.Sprintf("0x%s%040x", token0.Address[:8], token1.Address[:8])[:42]
 90}
 91
 92// CreatePool 创建Uniswap V3流动性池
 93func (m *UniswapManager) CreatePool(token0, token1 Token, fee PoolFee) (*Pool, error) {
 94	// 验证代币地址
 95	if token0.Address == "" || token1.Address == "" {
 96		return nil, errors.New("无效的代币地址")
 97	}
 98	
 99	if token0.Address == token1.Address {
100		return nil, errors.New("不能为相同代币创建交易对")
101	}
102	
103	// 确保token0的地址小于token1的地址（Uniswap V3要求）
104	if token0.Address > token1.Address {
105		token0, token1 = token1, token0
106	}
107	
108	// 生成池地址
109	poolAddress := GeneratePoolAddress(token0, token1, fee)
110	
111	// 检查是否已存在
112	if _, exists := m.Pools[poolAddress]; exists {
113		return nil, fmt.Errorf("池 %s 已存在", poolAddress)
114	}
115	
116	// 创建池
117	pool := &Pool{
118		Address:      poolAddress,
119		Token0:       token0,
120		Token1:       token1,
121		Fee:          fee,
122		Liquidity:    big.NewInt(0),
123		SqrtRatioX96: big.NewInt(0), // 初始为0，首次添加流动性时设置
124	}
125	
126	m.Pools[poolAddress] = pool
127	
128	fmt.Printf("成功创建Uniswap V3池: %s\n", poolAddress)
129	fmt.Printf("交易对: %s (%s) / %s (%s)\n", 
130		token0.Symbol, token0.Address, 
131		token1.Symbol, token1.Address)
132	fmt.Printf("费率: %.4f%%\n", float64(fee)/10000)
133	
134	return pool, nil
135}
136
137// MintPosition 添加流动性头寸
138func (m *UniswapManager) MintPosition(pool *Pool, owner string, token0Amount, token1Amount *big.Int, tickRange TickRange) (*Position, error) {
139	if pool == nil {
140		return nil, errors.New("池不存在")
141	}
142	
143	if tickRange.LowerTick >= tickRange.UpperTick {
144		return nil, errors.New("价格区间无效：下界必须小于上界")
145	}
146	
147	// 模拟创建头寸ID
148	positionID := fmt.Sprintf("POS-%d", time.Now().UnixNano())
149	
150	// 创建头寸
151	position := &Position{
152		Owner:         owner,
153		Token0Amount:  token0Amount,
154		Token1Amount:  token1Amount,
155		TickRange:     tickRange,
156		FeeGrowthInside: big.NewInt(0),
157		Liquidity:     big.NewInt(1000000), // 模拟流动性值
158	}
159	
160	m.Positions[positionID] = position
161	
162	// 更新池流动性
163	pool.Liquidity.Add(pool.Liquidity, position.Liquidity)
164	
165	fmt.Printf("成功添加流动性头寸: %s\n", positionID)
166	fmt.Printf("所有者: %s\n", owner)
167	fmt.Printf("提供的流动性: %s %s, %s %s\n", 
168		token0Amount.String(), pool.Token0.Symbol,
169		token1Amount.String(), pool.Token1.Symbol)
170	fmt.Printf("价格区间: tick %d 至 tick %d\n", 
171		tickRange.LowerTick, tickRange.UpperTick)
172	
173	return position, nil
174}
175
176// CollectFees 收取手续费
177func (m *UniswapManager) CollectFees(position *Position) (*big.Int, *big.Int, error) {
178	// 模拟计算手续费
179	token0Fees := new(big.Int).Div(position.Token0Amount, big.NewInt(100)) // 模拟1%的手续费
180	token1Fees := new(big.Int).Div(position.Token1Amount, big.NewInt(100))
181	
182	return token0Fees, token1Fees, nil
183}
184
185// IncreaseLiquidity 增加流动性
186func (m *UniswapManager) IncreaseLiquidity(position *Position, token0Amount, token1Amount *big.Int) error {
187	position.Token0Amount.Add(position.Token0Amount, token0Amount)
188	position.Token1Amount.Add(position.Token1Amount, token1Amount)
189	position.Liquidity.Add(position.Liquidity, big.NewInt(500000)) // 模拟增加流动性
190	return nil
191}
192
193// CalculateOptimalTicks 计算优化的价格区间刻度
194func CalculateOptimalTicks(basePrice float64, percentRange float64) TickRange {
195	// 简化的tick计算，实际应根据Uniswap V3的tickSpacing规则计算
196	// 这里假设在1%范围内集中流动性
197	lowerPrice := basePrice * (1 - percentRange)
198	upperPrice := basePrice * (1 + percentRange)
199	
200	// 简化的tick计算
201	lowerTick := int(lowerPrice*1000) - 887220 // 偏移量模拟
202	upperTick := int(upperPrice*1000) - 887220
203	
204	return TickRange{
205		LowerTick: lowerTick,
206		UpperTick: upperTick,
207	}
208}
209
210func main() {
211	// 创建Uniswap管理器
212	manager := NewUniswapManager(big.NewInt(1)) // 主网
213	
214	// 定义代币
215	rwaToken := Token{
216		Address:     "0x1234567890123456789012345678901234567890",
217		Symbol:      "RWA",
218		Decimals:    18,
219		TotalSupply: big.NewInt(10000000 * 1e18), // 1000万枚
220		Name:        "中关村租金收益代币",
221	}
222	
223	usdcToken := Token{
224		Address:     "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
225		Symbol:      "USDC",
226		Decimals:    6,
227		TotalSupply: big.NewInt(5000000000 * 1e6), // 50亿枚
228		Name:        "USD Coin",
229	}
230	
231	// 创建流动性池
232	pool, err := manager.CreatePool(rwaToken, usdcToken, Fee0_3)
233	if err != nil {
234		fmt.Printf("创建池失败: %v\n", err)
235		return
236	}
237	
238	// 计算优化的价格区间 (当前价格约1美元，在0.95-1.05区间集中流动性)
239	tickRange := CalculateOptimalTicks(1.0, 0.05) // 5%价格范围
240	
241	// 添加流动性
242	owner := "0xabcdef1234567890abcdef1234567890abcdef123"
243	token0Amount := new(big.Int).Mul(big.NewInt(500000), new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(rwaToken.Decimals)), nil))
244	token1Amount := new(big.Int).Mul(big.NewInt(500000), new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(usdcToken.Decimals)), nil))
245	
246	position, err := manager.MintPosition(pool, owner, token0Amount, token1Amount, tickRange)
247	if err != nil {
248		fmt.Printf("添加流动性失败: %v\n", err)
249		return
250	}
251	
252	// 模拟收取手续费
253	token0Fees, token1Fees, _ := manager.CollectFees(position)
254	fmt.Printf("\n预计可收取手续费:\n %s %s\n %s %s\n", 
255		token0Fees.String(), rwaToken.Symbol,
256		token1Fees.String(), usdcToken.Symbol)
257	
258	fmt.Println("\n流动性管理提示:")
259	fmt.Println("1. RWA代币建议在窄价格区间(±5%)提供流动性，减少无常损失")
260	fmt.Println("2. 定期调整价格区间以适应当前市场价格")
261	fmt.Println("3. 考虑使用自动做市策略管理流动性")
262}

  1// go代码：RWA资产管理API服务
  2package main
  3
  4import (
  5	"context"
  6	"database/sql"
  7	"encoding/json"
  8	"errors"
  9	"fmt"
 10	"log"
 11	"net/http"
 12	"os"
 13	"strconv"
 14	"time"
 15
 16	"github.com/gorilla/mux"
 17	_ "github.com/mattn/go-sqlite3"
 18)
 19
 20// AssetHoldings 用户资产持仓
 21type AssetHoldings struct {
 22	AssetID       string  `json:"asset_id"`
 23	TokenSymbol   string  `json:"token_symbol"`
 24	TokenName     string  `json:"token_name"`
 25	Holdings      float64 `json:"holdings"`      // 持仓数量
 26	HoldingsValue float64 `json:"holdings_value"` // 持仓价值(USD)
 27	APY           float64 `json:"apy"`           // 年化收益率
 28}
 29
 30// UserPortfolio 用户投资组合
 31type UserPortfolio struct {
 32	UserAddress     string         `json:"user_address"`
 33	TotalValue      float64        `json:"total_value"`      // 总资产价值
 34	TotalYield      float64        `json:"total_yield"`      // 累计收益
 35	UnclaimedYield  float64        `json:"unclaimed_yield"`  // 未领取收益
 36	AssetHoldings   []AssetHoldings `json:"asset_holdings"`   // 资产持仓列表
 37	LastUpdated     time.Time      `json:"last_updated"`     // 最后更新时间
 38}
 39
 40// AssetPerformance 资产表现数据
 41type AssetPerformance struct {
 42	AssetID        string    `json:"asset_id"`
 43	CurrentPrice   float64   `json:"current_price"`   // 当前价格
 44	PriceChange24h float64   `json:"price_change_24h"` // 24小时价格变化
 45	Volume24h      float64   `json:"volume_24h"`      // 24小时交易量
 46	LastYieldDate  time.Time `json:"last_yield_date"` // 上次分红日期
 47	NextYieldDate  time.Time `json:"next_yield_date"` // 下次分红日期
 48}
 49
 50// DistributionEvent 分红事件
 51type DistributionEvent struct {
 52	EventID        string    `json:"event_id"`
 53	AssetID        string    `json:"asset_id"`
 54	DistributionDate time.Time `json:"distribution_date"`
 55	AmountPerToken float64   `json:"amount_per_token"` // 每单位代币分红金额
 56	TotalDistribution float64 `json:"total_distribution"` // 总分红金额
 57	Status         string    `json:"status"`         // 状态：scheduled/completed/failed
 58}
 59
 60// YieldHistory 收益历史记录
 61type YieldHistory struct {
 62	Timestamp time.Time `json:"timestamp"`
 63	Amount    float64   `json:"amount"`
 64	EventType string    `json:"event_type"` // distribution/claim/reinvestment
 65}
 66
 67// ErrorResponse 错误响应
 68type ErrorResponse struct {
 69	Error   string `json:"error"`
 70	Code    int    `json:"code"`
 71	Message string `json:"message"`
 72}
 73
 74// RWAAPIServer RWA资产管理API服务器
 75type RWAAPIServer struct {
 76	DB          *sql.DB
 77	Router      *mux.Router
 78	Server      *http.Server
 79	EthClient   interface{} // 以太坊客户端接口
 80	Port        string
 81}
 82
 83// NewRWAAPIServer 创建新的API服务器
 84func NewRWAAPIServer(port string) (*RWAAPIServer, error) {
 85	// 初始化数据库
 86	db, err := initDB()
 87	if err != nil {
 88		return nil, fmt.Errorf("初始化数据库失败: %w", err)
 89	}
 90
 91	// 创建路由器
 92	router := mux.NewRouter()
 93	
 94	// 创建服务器实例
 95	server := &RWAAPIServer{
 96		DB:     db,
 97		Router: router,
 98		Port:   port,
 99	}
100
101	// 设置路由
102	server.setupRoutes()
103
104	// 配置HTTP服务器
105	server.Server = &http.Server{
106		Addr:    ":" + port,
107		Handler: router,
108	}
109
110	return server, nil
111}
112
113// 初始化数据库（使用SQLite模拟）
114func initDB() (*sql.DB, error) {
115	// 在实际应用中，应该连接到生产级数据库
116	db, err := sql.Open("sqlite3", ":memory:")
117	if err != nil {
118		return nil, err
119	}
120
121	// 创建表（模拟）
122	_, err = db.Exec(`
123		CREATE TABLE IF NOT EXISTS users (
124			address TEXT PRIMARY KEY,
125			total_value REAL,
126			total_yield REAL,
127			unclaimed_yield REAL,
128			last_updated TIMESTAMP
129		);
130		CREATE TABLE IF NOT EXISTS asset_holdings (
131			id INTEGER PRIMARY KEY AUTOINCREMENT,
132			user_address TEXT,
133			asset_id TEXT,
134			token_symbol TEXT,
135			token_name TEXT,
136			holdings REAL,
137			holdings_value REAL,
138			apy REAL,
139			FOREIGN KEY(user_address) REFERENCES users(address)
140		);
141		CREATE TABLE IF NOT EXISTS yield_history (
142			id INTEGER PRIMARY KEY AUTOINCREMENT,
143			user_address TEXT,
144			timestamp TIMESTAMP,
145			amount REAL,
146			event_type TEXT,
147			FOREIGN KEY(user_address) REFERENCES users(address)
148		);
149	`)
150
151	// 插入模拟数据
152	_, err = db.Exec(`
153		INSERT OR IGNORE INTO users (address, total_value, total_yield, unclaimed_yield, last_updated)
154		VALUES ('0x1234567890abcdef1234567890abcdef123456789', 15000.0, 1050.0, 350.0, datetime('now'));
155		
156		INSERT OR IGNORE INTO asset_holdings (user_address, asset_id, token_symbol, token_name, holdings, holdings_value, apy)
157		VALUES 
158		('0x1234567890abcdef1234567890abcdef123456789', 'ASSET-RE-2025-001', 'RWA-RENT', '中关村租金收益代币', 5000.0, 5000.0, 0.07),
159		('0x1234567890abcdef1234567890abcdef123456789', 'ASSET-RE-2025-002', 'RWA-COMM', '商业区收益代币', 10000.0, 10000.0, 0.065);
160		
161		INSERT OR IGNORE INTO yield_history (user_address, timestamp, amount, event_type)
162		VALUES
163		('0x1234567890abcdef1234567890abcdef123456789', datetime('now', '-30 days'), 175.0, 'distribution'),
164		('0x1234567890abcdef1234567890abcdef123456789', datetime('now', '-20 days'), 175.0, 'claim'),
165		('0x1234567890abcdef1234567890abcdef123456789', datetime('now', '-10 days'), 325.0, 'distribution'),
166		('0x1234567890abcdef1234567890abcdef123456789', datetime('now'), 375.0, 'distribution');
167	`)
168
169	return db, err
170}
171
172// 设置路由
173func (s *RWAAPIServer) setupRoutes() {
174	// 添加CORS中间件
175	s.Router.Use(corsMiddleware)
176	
177	// API版本组
178	v1 := s.Router.PathPrefix("/api/v1").Subrouter()
179
180	// 用户相关路由
181	v1.HandleFunc("/portfolio/{address}", s.getPortfolioHandler).Methods("GET")
182	v1.HandleFunc("/portfolio/{address}/yield/history", s.getYieldHistoryHandler).Methods("GET")
183	v1.HandleFunc("/portfolio/{address}/yield/claim", s.claimYieldHandler).Methods("POST")
184
185	// 资产相关路由
186	v1.HandleFunc("/assets", s.getAssetsHandler).Methods("GET")
187	v1.HandleFunc("/assets/{asset_id}", s.getAssetDetailsHandler).Methods("GET")
188	v1.HandleFunc("/assets/{asset_id}/performance", s.getAssetPerformanceHandler).Methods("GET")
189	v1.HandleFunc("/assets/{asset_id}/distributions", s.getDistributionsHandler).Methods("GET")
190
191	// 健康检查
192	s.Router.HandleFunc("/health", s.healthCheckHandler).Methods("GET")
193}
194
195// CORS中间件
196func corsMiddleware(next http.Handler) http.Handler {
197	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
198		w.Header().Set("Access-Control-Allow-Origin", "*")
199		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
200		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
201
202		if r.Method == "OPTIONS" {
203			w.WriteHeader(http.StatusNoContent)
204			return
205		}
206
207		next.ServeHTTP(w, r)
208	})
209}
210
211// getPortfolioHandler 获取用户投资组合
212func (s *RWAAPIServer) getPortfolioHandler(w http.ResponseWriter, r *http.Request) {
213	vars := mux.Vars(r)
214	address := vars["address"]
215
216	if address == "" {
217		s.respondWithError(w, http.StatusBadRequest, "用户地址不能为空")
218		return
219	}
220
221	// 开始数据库事务
222	tx, err := s.DB.Begin()
223	if err != nil {
224		s.respondWithError(w, http.StatusInternalServerError, "数据库错误")
225		return
226	}
227	defer tx.Rollback()
228
229	// 查询用户基本信息
230	var portfolio UserPortfolio
231	err = tx.QueryRow(`
232		SELECT address, total_value, total_yield, unclaimed_yield, last_updated
233		FROM users WHERE address = ?
234	`, address).Scan(
235		&portfolio.UserAddress,
236		&portfolio.TotalValue,
237		&portfolio.TotalYield,
238		&portfolio.UnclaimedYield,
239		&portfolio.LastUpdated,
240	)
241
242	if err != nil {
243		if errors.Is(err, sql.ErrNoRows) {
244			s.respondWithError(w, http.StatusNotFound, "用户不存在")
245		} else {
246			s.respondWithError(w, http.StatusInternalServerError, "查询用户信息失败")
247		}
248		return
249	}
250
251	// 查询用户资产持仓
252	rows, err := tx.Query(`
253		SELECT asset_id, token_symbol, token_name, holdings, holdings_value, apy
254		FROM asset_holdings WHERE user_address = ?
255	`, address)
256	if err != nil {
257		s.respondWithError(w, http.StatusInternalServerError, "查询资产持仓失败")
258		return
259	}
260	defer rows.Close()
261
262	// 填充资产持仓数据
263	for rows.Next() {
264		var holding AssetHoldings
265		if err := rows.Scan(
266			&holding.AssetID,
267			&holding.TokenSymbol,
268			&holding.TokenName,
269			&holding.Holdings,
270			&holding.HoldingsValue,
271			&holding.APY,
272		); err != nil {
273			s.respondWithError(w, http.StatusInternalServerError, "处理资产数据失败")
274			return
275		}
276		portfolio.AssetHoldings = append(portfolio.AssetHoldings, holding)
277	}
278
279	// 提交事务
280	if err := tx.Commit(); err != nil {
281		s.respondWithError(w, http.StatusInternalServerError, "数据库提交失败")
282		return
283	}
284
285	// 返回成功响应
286	s.respondWithJSON(w, http.StatusOK, portfolio)
287}
288
289// getYieldHistoryHandler 获取用户收益历史
290func (s *RWAAPIServer) getYieldHistoryHandler(w http.ResponseWriter, r *http.Request) {
291	vars := mux.Vars(r)
292	address := vars["address"]
293
294	if address == "" {
295		s.respondWithError(w, http.StatusBadRequest, "用户地址不能为空")
296		return
297	}
298
299	// 解析查询参数
300	limitStr := r.URL.Query().Get("limit")
301	limit := 10 // 默认限制10条
302	if limitStr != "" {
303		if parsedLimit, err := strconv.Atoi(limitStr); err == nil && parsedLimit > 0 {
304			limit = parsedLimit
305		}
306	}
307
308	// 查询收益历史
309	rows, err := s.DB.Query(`
310		SELECT timestamp, amount, event_type
311		FROM yield_history 
312		WHERE user_address = ? 
313		ORDER BY timestamp DESC 
314		LIMIT ?
315	`, address, limit)
316	if err != nil {
317		s.respondWithError(w, http.StatusInternalServerError, "查询收益历史失败")
318		return
319	}
320	defer rows.Close()
321
322	// 填充历史数据
323	var history []YieldHistory
324	for rows.Next() {
325		var record YieldHistory
326		if err := rows.Scan(
327			&record.Timestamp,
328			&record.Amount,
329			&record.EventType,
330		); err != nil {
331			s.respondWithError(w, http.StatusInternalServerError, "处理历史数据失败")
332			return
333		}
334		history = append(history, record)
335	}
336
337	// 返回成功响应
338	s.respondWithJSON(w, http.StatusOK, map[string]interface{}{
339		"address": address,
340		"history": history,
341		"total":   len(history),
342	})
343}
344
345// claimYieldHandler 处理用户领取收益
346func (s *RWAAPIServer) claimYieldHandler(w http.ResponseWriter, r *http.Request) {
347	vars := mux.Vars(r)
348	address := vars["address"]
349
350	if address == "" {
351		s.respondWithError(w, http.StatusBadRequest, "用户地址不能为空")
352		return
353	}
354
355	// 开始事务
356	tx, err := s.DB.Begin()
357	if err != nil {
358		s.respondWithError(w, http.StatusInternalServerError, "数据库错误")
359		return
360	}
361	defer tx.Rollback()
362
363	// 查询用户未领取收益
364	var unclaimedYield float64
365	err = tx.QueryRow(`
366		SELECT unclaimed_yield FROM users WHERE address = ?
367	`, address).Scan(&unclaimedYield)
368
369	if err != nil {
370		if errors.Is(err, sql.ErrNoRows) {
371			s.respondWithError(w, http.StatusNotFound, "用户不存在")
372		} else {
373			s.respondWithError(w, http.StatusInternalServerError, "查询未领取收益失败")
374		}
375		return
376	}
377
378	if unclaimedYield <= 0 {
379		s.respondWithError(w, http.StatusBadRequest, "没有可领取的收益")
380		return
381	}
382
383	// 更新用户未领取收益为0
384	_, err = tx.Exec(`
385		UPDATE users SET unclaimed_yield = 0, last_updated = datetime('now')
386		WHERE address = ?
387	`, address)
388	if err != nil {
389		s.respondWithError(w, http.StatusInternalServerError, "更新收益状态失败")
390		return
391	}
392
393	// 记录领取事件
394	_, err = tx.Exec(`
395		INSERT INTO yield_history (user_address, timestamp, amount, event_type)
396		VALUES (?, datetime('now'), ?, 'claim')
397	`, address, unclaimedYield)
398	if err != nil {
399		s.respondWithError(w, http.StatusInternalServerError, "记录领取事件失败")
400		return
401	}
402
403	// 提交事务
404	if err := tx.Commit(); err != nil {
405		s.respondWithError(w, http.StatusInternalServerError, "数据库提交失败")
406		return
407	}
408
409	// 模拟调用智能合约处理链上转账（实际应用中应实现）
410	// 这里只是返回成功响应
411	s.respondWithJSON(w, http.StatusOK, map[string]interface{}{
412		"status":         "success",
413		"claimed_amount": unclaimedYield,
414		"timestamp":      time.Now(),
415		"message":        "收益领取成功，将在区块链确认后到账",
416	})
417}
418
419// getAssetsHandler 获取资产列表
420func (s *RWAAPIServer) getAssetsHandler(w http.ResponseWriter, r *http.Request) {
421	// 模拟返回资产列表
422	assets := []map[string]interface{}{
423		{
424			"asset_id":    "ASSET-RE-2025-001",
425			"name":        "中关村租金收益代币",
426			"symbol":      "RWA-RENT",
427			"type":        "商业地产",
428			"description": "北京市海淀区中关村科技大厦租金收益权代币",
429			"current_price": 1.0,
430			"apy":         0.07,
431			"total_value": 10000000.0,
432		},
433		{
434			"asset_id":    "ASSET-RE-2025-002",
435			"name":        "商业区收益代币",
436			"symbol":      "RWA-COMM",
437			"type":        "商业综合体",
438			"description": "上海市浦东新区商业综合体收益权代币",
439			"current_price": 1.0,
440			"apy":         0.065,
441			"total_value": 20000000.0,
442		},
443	}
444
445	s.respondWithJSON(w, http.StatusOK, map[string]interface{}{
446		"assets": assets,
447		"total":  len(assets),
448	})
449}
450
451// getAssetDetailsHandler 获取资产详情
452func (s *RWAAPIServer) getAssetDetailsHandler(w http.ResponseWriter, r *http.Request) {
453	vars := mux.Vars(r)
454	assetID := vars["asset_id"]
455
456	if assetID == "" {
457		s.respondWithError(w, http.StatusBadRequest, "资产ID不能为空")
458		return
459	}
460
461	// 模拟资产详情数据
462	assetDetails := map[string]interface{}{
463		"asset_id":       assetID,
464		"name":           "中关村租金收益代币",
465		"symbol":         "RWA-RENT",
466		"contract_address": "0x1234567890123456789012345678901234567890",
467		"asset_type":     "商业地产",
468		"location":       "北京市海淀区中关村南大街",
469		"total_value":    10000000.0,
470		"token_supply":   10000000.0,
471		"current_price":  1.0,
472		"apy":            0.07,
473		"vacancy_rate":   0.08,
474		"description":    "该资产代表北京市海淀区中关村科技大厦的租金收益权份额，建筑总面积约20,000平方米，主要租户为科技企业。",
475		"spv_info": map[string]string{
476			"name":     "中关村租金收益专项计划",
477			"type":     "有限责任公司",
478			"location": "深圳前海",
479		},
480		"risk_factors": []string{
481			"商业地产市场波动风险",
482			"租户集中度过高风险",
483			"政策监管变化风险",
484		},
485		"distribution_frequency": "月度",
486		"next_distribution_date": time.Now().AddDate(0, 1, 0).Format("2006-01-02"),
487	}
488
489	s.respondWithJSON(w, http.StatusOK, assetDetails)
490}
491
492// getAssetPerformanceHandler 获取资产表现数据
493func (s *RWAAPIServer) getAssetPerformanceHandler(w http.ResponseWriter, r *http.Request) {
494	vars := mux.Vars(r)
495	assetID := vars["asset_id"]
496
497	if assetID == "" {
498		s.respondWithError(w, http.StatusBadRequest, "资产ID不能为空")
499		return
500	}
501
502	// 模拟资产表现数据
503	performance := AssetPerformance{
504		AssetID:        assetID,
505		CurrentPrice:   1.0,
506		PriceChange24h: 0.005,
507		Volume24h:      500000.0,
508		LastYieldDate:  time.Now().AddDate(0, 0, -15),
509		NextYieldDate:  time.Now().AddDate(0, 1, -15),
510	}
511
512	s.respondWithJSON(w, http.StatusOK, performance)
513}
514
515// getDistributionsHandler 获取分红事件列表
516func (s *RWAAPIServer) getDistributionsHandler(w http.ResponseWriter, r *http.Request) {
517	vars := mux.Vars(r)
518	assetID := vars["asset_id"]
519
520	if assetID == "" {
521		s.respondWithError(w, http.StatusBadRequest, "资产ID不能为空")
522		return
523	}
524
525	// 模拟分红事件数据
526	distributions := []DistributionEvent{
527		{
528			EventID:          "DIST-2025-03",
529			AssetID:          assetID,
530			DistributionDate: time.Now().AddDate(0, 1, -15),
531			AmountPerToken:   0.0058,
532			TotalDistribution: 58000.0,
533			Status:           "scheduled",
534		},
535		{
536			EventID:          "DIST-2025-02",
537			AssetID:          assetID,
538			DistributionDate: time.Now().AddDate(0, 0, -15),
539			AmountPerToken:   0.0058,
540			TotalDistribution: 58000.0,
541			Status:           "completed",
542		},
543		{
544			EventID:          "DIST-2025-01",
545			AssetID:          assetID,
546			DistributionDate: time.Now().AddDate(0, -1, -15),
547			AmountPerToken:   0.0058,
548			TotalDistribution: 58000.0,
549			Status:           "completed",
550		},
551	}
552
553	s.respondWithJSON(w, http.StatusOK, map[string]interface{}{
554		"asset_id":      assetID,
555		"distributions": distributions,
556		"total":         len(distributions),
557	})
558}
559
560// healthCheckHandler 健康检查
561func (s *RWAAPIServer) healthCheckHandler(w http.ResponseWriter, r *http.Request) {
562	s.respondWithJSON(w, http.StatusOK, map[string]interface{}{
563		"status":    "healthy",
564		"timestamp": time.Now(),
565		"service":   "RWA资产管理API服务",
566		"version":   "1.0.0",
567	})
568}
569
570// respondWithJSON 返回JSON响应
571func (s *RWAAPIServer) respondWithJSON(w http.ResponseWriter, code int, payload interface{}) {
572	response, _ := json.Marshal(payload)
573	w.Header().Set("Content-Type", "application/json")
574	w.WriteHeader(code)
575	w.Write(response)
576}
577
578// respondWithError 返回错误响应
579func (s *RWAAPIServer) respondWithError(w http.ResponseWriter, code int, message string) {
580	s.respondWithJSON(w, code, ErrorResponse{
581		Error:   http.StatusText(code),
582		Code:    code,
583		Message: message,
584	})
585}
586
587// Start 启动API服务器
588func (s *RWAAPIServer) Start() error {
589	log.Printf("RWA资产管理API服务启动，监听端口: %s\n", s.Port)
590	log.Printf("健康检查: http://localhost:%s/health\n", s.Port)
591	log.Printf("API文档: http://localhost:%s/api/v1/assets\n", s.Port)
592
593	// 在单独的goroutine中启动服务器
594	go func() {
595		if err := s.Server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
596			log.Fatalf("启动服务器失败: %v\n", err)
597		}
598	}()
599
600	return nil
601}
602
603// Stop 停止API服务器
604func (s *RWAAPIServer) Stop(ctx context.Context) error {
605	log.Println("正在关闭API服务器...")
606	return s.Server.Shutdown(ctx)
607}
608
609func main() {
610	// 从环境变量获取端口，默认8080
611	port := os.Getenv("PORT")
612	if port == "" {
613		port = "8080"
614	}
615
616	// 创建API服务器
617	server, err := NewRWAAPIServer(port)
618	if err != nil {
619		log.Fatalf("初始化服务器失败: %v\n", err)
620	}
621
622	// 启动服务器
623	if err := server.Start(); err != nil {
624		log.Fatalf("启动服务器失败: %v\n", err)
625	}
626
627	// 等待中断信号以优雅地关闭服务器
628	// 在实际应用中，这里应该处理信号量
629	log.Println("服务器已启动，按Ctrl+C关闭")
630	
631	// 阻止主goroutine退出
632	select {}
633}