区块链扫链测试完整指南
📚 目录
什么是扫链测试
扫链测试（Blockchain Scanning Testing） 是指通过程序化方式扫描、分析和验证区块链上的数据，以确保数据的完整性、一致性和正确性的测试过程。
简单理解
想象区块链是一个巨大的账本，扫链测试就像是：
- 📖 账本审计员：检查每一笔交易是否正确记录
- 🔍 数据验证员：确认所有数据都是真实有效的
- 🛡️ 安全检测员：发现异常交易和潜在风险
- 📊 数据统计员：收集和分析链上数据
扫链测试的目的和重要性
主要目的
-
数据完整性验证
- 确保所有交易都被正确记录
- 验证区块之间的链接关系
- 检查数据是否被篡改
-
交易正确性检查
- 验证交易金额是否正确
- 检查交易签名是否有效
- 确认交易状态（成功/失败）
-
地址余额验证
- 核对钱包地址的余额
- 验证代币转账记录
- 检查余额变化是否符合预期
-
异常检测
- 发现异常大额交易
- 识别可疑地址活动
- 监控智能合约调用
-
性能监控
- 统计交易数量
- 分析区块生成速度
- 监控网络拥堵情况
为什么重要？
- ✅ 保障资金安全：及时发现异常交易，防止资金损失
- ✅ 确保数据准确：验证链上数据的正确性
- ✅ 合规要求：满足监管和审计需求
- ✅ 系统稳定性：发现潜在问题，提高系统可靠性
扫链测试的主要内容
1. 区块扫描
1.1 区块基本信息
- 区块高度（Block Height）：区块在链上的位置
- 区块哈希（Block Hash）：区块的唯一标识
- 时间戳（Timestamp）：区块生成时间
- 交易数量（Transaction Count）：区块包含的交易数
- 区块大小（Block Size）：区块数据大小
1.2 区块验证
# 示例：验证区块信息
区块验证项目：
- 前一个区块哈希是否正确
- 区块哈希计算是否正确
- 时间戳是否合理（不能早于前一个区块）
- 交易数量是否在合理范围内
- Merkle根是否正确
2. 交易扫描
2.1 交易基本信息
- 交易哈希（Tx Hash）：交易的唯一标识
- 发送地址（From Address）：交易发起方
- 接收地址（To Address）：交易接收方
- 交易金额（Amount）：转账金额
- Gas费用（Gas Fee）：交易手续费
- 交易状态（Status）：成功/失败/待确认
- 确认数（Confirmations）：交易确认次数
2.2 交易验证
# 示例：交易验证检查项
交易验证项目：
- 交易签名是否有效
- 发送方余额是否充足
- 交易金额是否为正数
- Gas费用是否合理
- 交易是否被成功执行
- 交易是否被双花
3. 地址扫描
3.1 地址余额
- 主币余额：ETH、BTC等主链币余额
- 代币余额：ERC-20、BEP-20等代币余额
- NFT资产：ERC-721、ERC-1155等NFT资产
3.2 地址交易历史
- 所有转入交易
- 所有转出交易
- 交易时间线
- 交易金额统计
4. 智能合约扫描
4.1 合约调用
- 合约地址
- 调用方法（Function）
- 调用参数
- 调用结果
- Gas消耗
4.2 合约事件（Events）
- 事件名称
- 事件参数
- 事件触发时间
- 事件触发者
5. 代币扫描
5.1 代币转账
- 代币合约地址
- 代币符号（Symbol）
- 代币精度（Decimals）
- 转账金额
- 转账双方地址
5.2 代币余额
- 地址持有的代币列表
- 每种代币的余额
- 代币价值（如果可获取）
扫链测试的实施方法
方法一：使用区块链浏览器API
1. 准备工作
需要的工具：
- 编程语言：Python、JavaScript、Go等
- API密钥：从区块链浏览器获取（如Etherscan、BscScan）
- HTTP请求库：requests（Python）、axios（JavaScript）
2. 获取API密钥
Etherscan（以太坊）：
- 访问 https://etherscan.io/
- 注册账号并登录
- 进入 API-KEYs 页面
- 创建新的API密钥
BscScan（币安智能链）：
- 访问 https://bscscan.com/
- 注册账号并登录
- 进入 API-KEYs 页面
- 创建新的API密钥
3. Python示例代码
import requests
import time
import json
class BlockchainScanner:
def __init__(self, api_key, base_url):
"""
初始化扫链器
:param api_key: API密钥
:param base_url: API基础URL
"""
self.api_key = api_key
self.base_url = base_url
def get_latest_block(self):
"""获取最新区块号"""
url = f"{self.base_url}/api"
params = {
'module': 'proxy',
'action': 'eth_blockNumber',
'apikey': self.api_key
}
response = requests.get(url, params=params)
data = response.json()
if data['status'] == '1':
return int(data['result'], 16) # 十六进制转十进制
return None
def get_block_info(self, block_number):
"""获取区块信息"""
url = f"{self.base_url}/api"
params = {
'module': 'proxy',
'action': 'eth_getBlockByNumber',
'tag': hex(block_number),
'boolean': 'true',
'apikey': self.api_key
}
response = requests.get(url, params=params)
return response.json()
def get_transaction(self, tx_hash):
"""获取交易信息"""
url = f"{self.base_url}/api"
params = {
'module': 'proxy',
'action': 'eth_getTransactionByHash',
'txhash': tx_hash,
'apikey': self.api_key
}
response = requests.get(url, params=params)
return response.json()
def get_address_balance(self, address):
"""获取地址余额"""
url = f"{self.base_url}/api"
params = {
'module': 'account',
'action': 'balance',
'address': address,
'tag': 'latest',
'apikey': self.api_key
}
response = requests.get(url, params=params)
data = response.json()
if data['status'] == '1':
# 余额是Wei单位，需要转换为ETH（除以10^18）
balance_wei = int(data['result'])
balance_eth = balance_wei / 10**18
return balance_eth
return None
def get_address_transactions(self, address, start_block=0, end_block=99999999):
"""获取地址的所有交易"""
url = f"{self.base_url}/api"
params = {
'module': 'account',
'action': 'txlist',
'address': address,
'startblock': start_block,
'endblock': end_block,
'sort': 'asc',
'apikey': self.api_key
}
response = requests.get(url, params=params)
data = response.json()
if data['status'] == '1':
return data['result']
return []
def scan_blocks(self, start_block, end_block):
"""扫描指定范围的区块"""
results = []
for block_num in range(start_block, end_block + 1):
print(f"正在扫描区块 {block_num}...")
block_info = self.get_block_info(block_num)
if block_info and 'result' in block_info:
block_data = block_info['result']
results.append({
'block_number': block_num,
'block_hash': block_data.get('hash'),
'timestamp': int(block_data.get('timestamp', '0'), 16),
'transaction_count': len(block_data.get('transactions', [])),
'transactions': block_data.get('transactions', [])
})
# 避免请求过快，添加延迟
time.sleep(0.2)
return results
# 使用示例
if __name__ == "__main__":
# 初始化扫链器（以Etherscan为例）
scanner = BlockchainScanner(
api_key="YOUR_API_KEY_HERE",
base_url="https://api.etherscan.io"
)
# 获取最新区块
latest_block = scanner.get_latest_block()
print(f"最新区块号: {latest_block}")
# 获取地址余额
address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
balance = scanner.get_address_balance(address)
print(f"地址 {address} 的余额: {balance} ETH")
# 获取地址交易历史
transactions = scanner.get_address_transactions(address)
print(f"该地址共有 {len(transactions)} 笔交易")
# 扫描最近10个区块
if latest_block:
start_block = max(0, latest_block - 9)
blocks_data = scanner.scan_blocks(start_block, latest_block)
print(f"扫描完成，共扫描 {len(blocks_data)} 个区块")
方法二：直接连接节点（RPC）
1. 使用Web3.py（以太坊）
from web3 import Web3
import json
# 连接到以太坊节点（可以使用Infura、Alchemy等）
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_PROJECT_ID'))
# 检查连接
if w3.is_connected():
print("连接成功！")
# 获取最新区块号
latest_block = w3.eth.block_number
print(f"最新区块号: {latest_block}")
# 获取区块信息
block = w3.eth.get_block(latest_block, full_transactions=True)
print(f"区块哈希: {block['hash'].hex()}")
print(f"交易数量: {len(block['transactions'])}")
# 获取交易信息
if block['transactions']:
tx = block['transactions'][0]
print(f"交易哈希: {tx['hash'].hex()}")
print(f"发送方: {tx['from']}")
print(f"接收方: {tx['to']}")
print(f"金额: {w3.from_wei(tx['value'], 'ether')} ETH")
# 获取地址余额
address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
balance = w3.eth.get_balance(address)
balance_eth = w3.from_wei(balance, 'ether')
print(f"地址余额: {balance_eth} ETH")
2. 使用Bitcoin Core RPC（比特币）
import requests
import json
class BitcoinRPC:
def __init__(self, rpc_url, rpc_user, rpc_password):
self.rpc_url = rpc_url
self.rpc_user = rpc_user
self.rpc_password = rpc_password
def call(self, method, params=[]):
"""调用RPC方法"""
payload = {
"method": method,
"params": params,
"jsonrpc": "2.0",
"id": 1
}
response = requests.post(
self.rpc_url,
json=payload,
auth=(self.rpc_user, self.rpc_password)
)
return response.json()
def get_block_count(self):
"""获取区块数量"""
result = self.call("getblockcount")
return result.get('result')
def get_block(self, block_hash):
"""获取区块信息"""
result = self.call("getblock", [block_hash, 2]) # 2表示包含完整交易
return result.get('result')
def get_transaction(self, tx_id):
"""获取交易信息"""
result = self.call("getrawtransaction", [tx_id, True])
return result.get('result')
# 使用示例
rpc = BitcoinRPC(
rpc_url="http://localhost:8332",
rpc_user="your_rpc_user",
rpc_password="your_rpc_password"
)
block_count = rpc.get_block_count()
print(f"当前区块高度: {block_count}")
方法三：使用现成的扫链工具
1. Blockchair API
- 支持多链：Bitcoin、Ethereum、Litecoin等
- 提供丰富的查询接口
- 有免费和付费版本
2. The Graph
- 去中心化的索引协议
- 可以查询历史数据
- 支持GraphQL查询
3. Moralis API
- 提供统一的区块链API
- 支持多链查询
- 有免费额度
常用工具和平台
1. 区块链浏览器
| 链 | 浏览器 | API文档 |
|---|---|---|
| 以太坊 | Etherscan | https://docs.etherscan.io/ |
| 币安智能链 | BscScan | https://docs.bscscan.com/ |
| Polygon | PolygonScan | https://docs.polygonscan.com/ |
| 比特币 | Blockchain.com | https://www.blockchain.com/api |
| 波场 | TronScan | https://tronscan.org/ |
2. 开发库
Python:
web3.py- 以太坊交互bitcoinrpc- 比特币RPCrequests- HTTP请求
JavaScript:
web3.js- 以太坊交互ethers.js- 以太坊交互（更现代）axios- HTTP请求
Go:
go-ethereum- 以太坊客户端btcd- 比特币客户端
3. 节点服务提供商
- Infura - 以太坊节点服务
- Alchemy - 多链节点服务
- QuickNode - 多链节点服务
- GetBlock - 多链节点服务
实战案例
案例1：监控钱包地址余额变化
import time
from datetime import datetime
class BalanceMonitor:
def __init__(self, scanner, address):
self.scanner = scanner
self.address = address
self.last_balance = None
def monitor(self, interval=60):
"""监控余额变化"""
print(f"开始监控地址: {self.address}")
print(f"检查间隔: {interval} 秒\n")
while True:
current_balance = self.scanner.get_address_balance(self.address)
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if self.last_balance is not None:
if current_balance != self.last_balance:
change = current_balance - self.last_balance
print(f"[{current_time}] 余额变化!")
print(f" 之前余额: {self.last_balance} ETH")
print(f" 当前余额: {current_balance} ETH")
print(f" 变化量: {change:+.6f} ETH\n")
else:
print(f"[{current_time}] 余额: {current_balance} ETH (无变化)")
else:
print(f"[{current_time}] 初始余额: {current_balance} ETH")
self.last_balance = current_balance
time.sleep(interval)
# 使用示例
scanner = BlockchainScanner(
api_key="YOUR_API_KEY",
base_url="https://api.etherscan.io"
)
monitor = BalanceMonitor(scanner, "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb")
# monitor.monitor(interval=60) # 每60秒检查一次
案例2：扫描大额交易
class LargeTransactionScanner:
def __init__(self, scanner, min_amount_eth=10):
self.scanner = scanner
self.min_amount_wei = min_amount_eth * 10**18
def scan_recent_blocks(self, block_count=100):
"""扫描最近N个区块的大额交易"""
latest_block = self.scanner.get_latest_block()
if not latest_block:
return []
start_block = max(0, latest_block - block_count + 1)
large_txs = []
print(f"扫描区块 {start_block} 到 {latest_block}...")
for block_num in range(start_block, latest_block + 1):
block_info = self.scanner.get_block_info(block_num)
if block_info and 'result' in block_info:
transactions = block_info['result'].get('transactions', [])
for tx in transactions:
if tx and 'value' in tx:
value = int(tx['value'], 16) # 十六进制转整数
if value >= self.min_amount_wei:
large_txs.append({
'block': block_num,
'tx_hash': tx.get('hash'),
'from': tx.get('from'),
'to': tx.get('to'),
'value_wei': value,
'value_eth': value / 10**18
})
if block_num % 10 == 0:
print(f"已扫描到区块 {block_num}...")
return large_txs
# 使用示例
scanner = BlockchainScanner(
api_key="YOUR_API_KEY",
base_url="https://api.etherscan.io"
)
large_tx_scanner = LargeTransactionScanner(scanner, min_amount_eth=10)
large_transactions = large_tx_scanner.scan_recent_blocks(block_count=100)
print(f"\n找到 {len(large_transactions)} 笔大额交易（>= 10 ETH）:")
for tx in large_transactions:
print(f"区块 {tx['block']}: {tx['value_eth']:.2f} ETH")
print(f" 从 {tx['from']} 到 {tx['to']}")
print(f" 交易哈希: {tx['tx_hash']}\n")
案例3：验证交易状态
class TransactionValidator:
def __init__(self, scanner):
self.scanner = scanner
def validate_transaction(self, tx_hash):
"""验证交易状态"""
tx_info = self.scanner.get_transaction(tx_hash)
if not tx_info or 'result' not in tx_info:
return {
'valid': False,
'error': '交易不存在'
}
tx = tx_info['result']
# 检查交易是否成功
# 注意：需要通过eth_getTransactionReceipt获取交易收据
# 这里简化处理
result = {
'valid': True,
'tx_hash': tx_hash,
'from': tx.get('from'),
'to': tx.get('to'),
'value': int(tx.get('value', '0'), 16) / 10**18,
'gas_price': int(tx.get('gasPrice', '0'), 16),
'gas_limit': int(tx.get('gas', '0'), 16),
'nonce': int(tx.get('nonce', '0'), 16),
'block_number': int(tx.get('blockNumber', '0'), 16) if tx.get('blockNumber') else None
}
if result['block_number'] is None:
result['status'] = 'pending'
else:
result['status'] = 'confirmed'
return result
# 使用示例
scanner = BlockchainScanner(
api_key="YOUR_API_KEY",
base_url="https://api.etherscan.io"
)
validator = TransactionValidator(scanner)
tx_hash = "0x..." # 替换为实际的交易哈希
result = validator.validate_transaction(tx_hash)
print(f"交易验证结果:")
print(json.dumps(result, indent=2, ensure_ascii=False))
案例4：统计地址交易数据
class AddressAnalyzer:
def __init__(self, scanner):
self.scanner = scanner
def analyze_address(self, address):
"""分析地址的交易数据"""
transactions = self.scanner.get_address_transactions(address)
if not transactions:
return {
'address': address,
'total_transactions': 0,
'message': '该地址暂无交易记录'
}
total_in = 0 # 总转入
total_out = 0 # 总转出
tx_count = len(transactions)
for tx in transactions:
value_wei = int(tx.get('value', 0))
value_eth = value_wei / 10**18
if tx.get('from', '').lower() == address.lower():
total_out += value_eth
if tx.get('to', '').lower() == address.lower():
total_in += value_eth
current_balance = self.scanner.get_address_balance(address)
return {
'address': address,
'total_transactions': tx_count,
'total_in_eth': total_in,
'total_out_eth': total_out,
'net_flow_eth': total_in - total_out,
'current_balance_eth': current_balance,
'first_tx_time': transactions[0].get('timeStamp') if transactions else None,
'last_tx_time': transactions[-1].get('timeStamp') if transactions else None
}
# 使用示例
scanner = BlockchainScanner(
api_key="YOUR_API_KEY",
base_url="https://api.etherscan.io"
)
analyzer = AddressAnalyzer(scanner)
address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
analysis = analyzer.analyze_address(address)
print(f"地址分析结果:")
print(json.dumps(analysis, indent=2, ensure_ascii=False))
注意事项和最佳实践
1. API限制
问题：
- 大多数API都有请求频率限制
- 免费API通常限制更严格
解决方案：
- 添加请求延迟（如
time.sleep(0.2)） - 使用API密钥（通常有更高的限制）
- 实现重试机制
- 考虑使用付费API
import time
from functools import wraps
def rate_limit(max_calls=5, period=1):
"""API限流装饰器"""
min_interval = period / max_calls
last_called = [0.0]
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
elapsed = time.time() - last_called[0]
left_to_wait = min_interval - elapsed
if left_to_wait > 0:
time.sleep(left_to_wait)
ret = func(*args, **kwargs)
last_called[0] = time.time()
return ret
return wrapper
return decorator
# 使用示例
@rate_limit(max_calls=5, period=1) # 每秒最多5次请求
def api_call():
# API调用代码
pass
2. 错误处理
import requests
from requests.exceptions import RequestException, Timeout
def safe_api_call(func):
"""安全的API调用装饰器"""
def wrapper(*args, **kwargs):
max_retries = 3
retry_count = 0
while retry_count < max_retries:
try:
return func(*args, **kwargs)
except Timeout:
retry_count += 1
print(f"请求超时，重试 {retry_count}/{max_retries}")
time.sleep(2 ** retry_count) # 指数退避
except RequestException as e:
print(f"请求错误: {e}")
retry_count += 1
if retry_count >= max_retries:
raise
time.sleep(2 ** retry_count)
return None
return wrapper
3. 数据存储
建议：
- 将扫描结果保存到数据库（MySQL、PostgreSQL、MongoDB）
- 使用缓存减少重复请求（Redis）
- 定期备份重要数据
import sqlite3
from datetime import datetime
class DataStorage:
def __init__(self, db_path="blockchain_data.db"):
self.conn = sqlite3.connect(db_path)
self.create_tables()
def create_tables(self):
"""创建数据表"""
cursor = self.conn.cursor()
# 区块表
cursor.execute('''
CREATE TABLE IF NOT EXISTS blocks (
block_number INTEGER PRIMARY KEY,
block_hash TEXT,
timestamp INTEGER,
transaction_count INTEGER,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
# 交易表
cursor.execute('''
CREATE TABLE IF NOT EXISTS transactions (
tx_hash TEXT PRIMARY KEY,
block_number INTEGER,
from_address TEXT,
to_address TEXT,
value_wei INTEGER,
value_eth REAL,
gas_price INTEGER,
gas_limit INTEGER,
status TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
self.conn.commit()
def save_block(self, block_data):
"""保存区块数据"""
cursor = self.conn.cursor()
cursor.execute('''
INSERT OR REPLACE INTO blocks
(block_number, block_hash, timestamp, transaction_count)
VALUES (?, ?, ?, ?)
''', (
block_data['block_number'],
block_data['block_hash'],
block_data['timestamp'],
block_data['transaction_count']
))
self.conn.commit()
def save_transaction(self, tx_data):
"""保存交易数据"""
cursor = self.conn.cursor()
cursor.execute('''
INSERT OR REPLACE INTO transactions
(tx_hash, block_number, from_address, to_address,
value_wei, value_eth, gas_price, gas_limit, status)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
''', (
tx_data['tx_hash'],
tx_data['block_number'],
tx_data['from_address'],
tx_data['to_address'],
tx_data['value_wei'],
tx_data['value_eth'],
tx_data['gas_price'],
tx_data['gas_limit'],
tx_data['status']
))
self.conn.commit()
4. 性能优化
建议：
- 使用多线程/多进程处理（注意API限制）
- 批量请求数据
- 使用异步请求（asyncio）
- 缓存常用数据
import asyncio
import aiohttp
async def fetch_block_async(session, url, params):
"""异步获取区块数据"""
async with session.get(url, params=params) as response:
return await response.json()
async def scan_blocks_async(scanner, start_block, end_block):
"""异步扫描区块"""
async with aiohttp.ClientSession() as session:
tasks = []
for block_num in range(start_block, end_block + 1):
url = f"{scanner.base_url}/api"
params = {
'module': 'proxy',
'action': 'eth_getBlockByNumber',
'tag': hex(block_num),
'boolean': 'true',
'apikey': scanner.api_key
}
tasks.append(fetch_block_async(session, url, params))
results = await asyncio.gather(*tasks)
return results
5. 安全性
重要提醒：
- ⚠️ 永远不要泄露API密钥
- ⚠️ 使用环境变量存储敏感信息
- ⚠️ 不要将私钥硬编码在代码中
- ⚠️ 验证返回数据的完整性
import os
from dotenv import load_dotenv
# 使用环境变量
load_dotenv()
API_KEY = os.getenv('ETHERSCAN_API_KEY')
RPC_URL = os.getenv('RPC_URL')
常见问题解答
Q1: 扫链测试需要什么技术基础？
A:
- 基础的编程知识（Python/JavaScript推荐）
- HTTP请求的基本概念
- JSON数据格式
- 区块链基础知识（区块、交易、地址等概念）
Q2: 扫链测试需要运行节点吗？
A:
- 不需要：可以使用区块链浏览器API或第三方节点服务
- 可选：如果需要更快的响应或更多控制，可以运行自己的节点
Q3: 扫链测试会消耗很多费用吗？
A:
- 大多数区块链浏览器API有免费额度
- 读取操作（查询）通常是免费的
- 只有写入操作（发送交易）才需要Gas费
Q4: 如何选择扫链方法？
A:
- API方式：适合快速开发、小规模测试
- RPC方式：适合大规模扫描、需要实时数据
- 现成工具：适合非技术人员、快速查询
Q5: 扫链测试的准确性如何保证？
A:
- 交叉验证：使用多个数据源对比
- 验证签名：检查交易签名的有效性
- 检查余额：确保余额计算正确
- 监控异常：设置阈值检测异常情况
Q6: 如何处理链分叉？
A:
- 等待确认：等待足够的区块确认
- 检查重组：监控区块重组情况
- 使用最终确认：只处理最终确认的交易
Q7: 扫链测试的性能瓶颈在哪里？
A:
- API限制：请求频率限制
- 网络延迟：网络请求的延迟
- 数据处理：大量数据的处理速度
- 存储I/O：数据库读写速度
Q8: 如何测试智能合约？
A:
- 使用合约ABI解析调用数据
- 监听合约事件（Events）
- 验证合约状态变化
- 测试合约方法的返回值
总结
扫链测试是区块链开发中非常重要的一环，通过系统化的扫描和验证，可以：
- ✅ 保障数据准确性：确保链上数据的正确性
- ✅ 提高系统安全性：及时发现异常和风险
- ✅ 满足合规要求：提供完整的审计数据
- ✅ 优化用户体验：确保交易和余额显示正确
快速开始步骤
- 选择目标链：确定要扫描的区块链（如以太坊、BSC等）
- 获取API密钥：从对应的区块链浏览器注册并获取API密钥
- 编写基础代码：使用提供的示例代码开始
- 测试验证：先用小范围数据测试
- 扩展功能：根据需求添加更多功能
- 优化性能：处理大量数据时进行优化
学习资源
- 官方文档：各区块链的官方文档
- API文档：区块链浏览器的API文档
- 社区论坛：Stack Overflow、Reddit等
- GitHub：查看开源项目的实现
祝您扫链测试顺利！ 🚀
如有问题，欢迎查阅相关文档或寻求社区帮助。
评论区