Ganache+Web3+Solidity实现智能合约调用案例

原创 于 2025-12-18 18:58:09 发布 · 239 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#web3 #智能合约 #solidity #区块链

主要步骤

  1. 准备: 启动节点 → 连接Web3 → 获取账户
  2. 编译: 读取源码 → 编译 → 提取ABI和字节码
  3. 部署: 构造合约 → 估算gas → 发送交易 → 等待确认 → 获取地址
  4. 初始化: 构造函数执行 → 状态变量设置 → 白名单初始化
  5. 交互准备: 实例化合约对象 → 测试只读函数
  6. 用户操作: 注册用户 → 存款ETH → 验证权限
  7. 权限管理: owner更新白名单 → 用户获得权限
  8. 状态修改: 用户调用写入函数 → gas消耗 → 状态更新
  9. 事件处理: 实时监听 → 历史查询 → 日志解析
  10. 批量操作: 批量更新 → 节省gas
  11. 错误处理: 捕获异常 → 重试机制 → 用户反馈
  12. 监控: Gas跟踪 → 事件日志 → 状态变化

MyContract.sol 合约

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract MyContract {
    // 状态变量
    address public owner;
    uint256 public value;
    string public name;
    bool public isActive;
    
    // 结构体
    struct User {
        uint256 id;
        string name;
        uint256 balance;
        uint256 createdAt;
    }
    
    // 映射
    mapping(address => uint256) public balances;
    mapping(address => User) public users;
    mapping(address => bool) public whitelist;
    
    // 数组
    address[] public userAddresses;
    
    // 事件
    event ValueChanged(address indexed changer, uint256 oldValue, uint256 newValue);
    event UserRegistered(address indexed user, uint256 userId, string userName);
    event FundsDeposited(address indexed from, uint256 amount);
    event FundsWithdrawn(address indexed to, uint256 amount);
    event WhitelistUpdated(address indexed user, bool status);
    
    // 修饰器
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }
    
    modifier onlyWhitelisted() {
        require(whitelist[msg.sender] || msg.sender == owner, "Not whitelisted");
        _;
    }
    
    modifier whenActive() {
        require(isActive, "Contract is not active");
        _;
    }
    
    // 构造函数
    constructor(string memory _name, uint256 _initialValue) {
        owner = msg.sender;
        name = _name;
        value = _initialValue;
        isActive = true;
        
        // 将部署者加入白名单
        whitelist[msg.sender] = true;
    }
    
    // 1. 读取函数示例
    function getContractInfo() public view returns (
        address contractOwner,
        string memory contractName,
        uint256 contractValue,
        bool activeStatus,
        uint256 userCount
    ) {
        return (owner, name, value, isActive, userAddresses.length);
    }
    
    function getUserBalance(address _user) public view returns (uint256) {
        return balances[_user];
    }
    
    function getAllUsers() public view returns (address[] memory) {
        return userAddresses;
    }
    
    function calculateWithFee(uint256 _amount) public pure returns (uint256) {
        return _amount + (_amount * 5 / 100); // 5% 手续费
    }
    
    // 2. 写入函数示例
    function setValue(uint256 _newValue) public onlyWhitelisted whenActive {
        require(_newValue > 0, "Value must be greater than 0");
        
        uint256 oldValue = value;
        value = _newValue;
        
        emit ValueChanged(msg.sender, oldValue, _newValue);
    }
    
    function registerUser(string memory _userName) public whenActive returns (uint256) {
        require(bytes(_userName).length > 0, "Username cannot be empty");
        require(users[msg.sender].id == 0, "User already registered");
        
        uint256 userId = userAddresses.length + 1;
        
        users[msg.sender] = User({
            id: userId,
            name: _userName,
            balance: 0,
            createdAt: block.timestamp
        });
        
        userAddresses.push(msg.sender);
        
        emit UserRegistered(msg.sender, userId, _userName);
        return userId;
    }
    
    function deposit() public payable whenActive {
        require(msg.value > 0, "Deposit amount must be greater than 0");
        
        balances[msg.sender] += msg.value;
        
        emit FundsDeposited(msg.sender, msg.value);
    }
    
    function withdraw(uint256 _amount) public whenActive {
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        require(_amount > 0, "Amount must be greater than 0");
        
        balances[msg.sender] -= _amount;
        
        // 使用call进行转账（推荐方式）
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Transfer failed");
        
        emit FundsWithdrawn(msg.sender, _amount);
    }
    
    function transfer(address _to, uint256 _amount) public whenActive {
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        require(_to != address(0), "Invalid recipient address");
        require(_amount > 0, "Amount must be greater than 0");
        
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
    
    // 3. 仅owner可调用的函数
    function updateWhitelist(address _user, bool _status) public onlyOwner {
        whitelist[_user] = _status;
        emit WhitelistUpdated(_user, _status);
    }
    
    function toggleActive() public onlyOwner {
        isActive = !isActive;
    }
    
    function changeName(string memory _newName) public onlyOwner {
        name = _newName;
    }
    
    function withdrawContractBalance() public onlyOwner {
        uint256 contractBalance = address(this).balance;
        require(contractBalance > 0, "No balance to withdraw");
        
        (bool success, ) = owner.call{value: contractBalance}("");
        require(success, "Transfer failed");
    }
    
    // 4. 批量操作
    function batchUpdateWhitelist(address[] memory _users, bool[] memory _statuses) public onlyOwner {
        require(_users.length == _statuses.length, "Arrays length mismatch");
        
        for (uint256 i = 0; i < _users.length; i++) {
            whitelist[_users[i]] = _statuses[i];
            emit WhitelistUpdated(_users[i], _statuses[i]);
        }
    }
    
    // 5. 工具函数
    function getUserInfo(address _user) public view returns (
        uint256 userId,
        string memory userName,
        uint256 userBalance,
        uint256 registrationTime,
        bool isWhitelisted
    ) {
        User memory user = users[_user];
        return (
            user.id,
            user.name,
            balances[_user],
            user.createdAt,
            whitelist[_user]
        );
    }
    
    function getContractBalance() public view returns (uint256) {
        return address(this).balance;
    }
    
    // 6. 回退函数和接收函数
    receive() external payable {
        balances[msg.sender] += msg.value;
        emit FundsDeposited(msg.sender, msg.value);
    }
    
    fallback() external payable {
        // 自定义回退逻辑
        if (msg.value > 0) {
            balances[msg.sender] += msg.value;
            emit FundsDeposited(msg.sender, msg.value);
        }
    }
    
    // 7. 权限转移
    function transferOwnership(address _newOwner) public onlyOwner {
        require(_newOwner != address(0), "Invalid new owner address");
        owner = _newOwner;
    }
}

完整的使用示例代码

// myContractInteractions.js
const Web3 = require('web3');
const fs = require('fs');
const solc = require('solc');

// 1. 初始化Web3
const web3 = new Web3('http://localhost:8545');

class MyContractInteractor {
    constructor() {
        this.contract = null;
        this.accounts = [];
        this.contractAddress = '';
    }
    
    // 2. 编译合约
    async compileContract() {
        const source = fs.readFileSync('MyContract.sol', 'utf8');
        
        const input = {
            language: 'Solidity',
            sources: {
                'MyContract.sol': {
                    content: source
                }
            },
            settings: {
                outputSelection: {
                    '*': {
                        '*': ['abi', 'evm.bytecode']
                    }
                }
            }
        };
        
        const output = JSON.parse(solc.compile(JSON.stringify(input)));
        this.abi = output.contracts['MyContract.sol']['MyContract'].abi;
        this.bytecode = output.contracts['MyContract.sol']['MyContract'].evm.bytecode.object;
        
        console.log('✅ 合约编译成功');
        return { abi: this.abi, bytecode: this.bytecode };
    }
    
    // 3. 部署合约
    async deployContract() {
        try {
            this.accounts = await web3.eth.getAccounts();
            
            const contract = new web3.eth.Contract(this.abi);
            
            console.log('🚀 部署合约中...');
            const deployedContract = await contract.deploy({
                data: '0x' + this.bytecode,
                arguments: ['MyFirstContract', 100] // 构造函数参数
            })
            .send({
                from: this.accounts[0],
                gas: 3000000,
                gasPrice: web3.utils.toWei('20', 'gwei')
            });
            
            this.contractAddress = deployedContract.options.address;
            this.contract = deployedContract;
            
            console.log(`✅ 合约部署成功，地址: ${this.contractAddress}`);
            console.log(`📝 交易哈希: ${deployedContract.transactionHash}`);
            
            return deployedContract;
        } catch (error) {
            console.error('❌ 部署失败:', error);
            throw error;
        }
    }
    
    // 4. 连接到已部署的合约
    async connectToContract(address) {
        this.contractAddress = address;
        this.contract = new web3.eth.Contract(this.abi, address);
        console.log(`✅ 已连接到合约: ${address}`);
        return this.contract;
    }
    
    // 5. 读取函数示例
    async readContractInfo() {
        try {
            console.log('\n📖 读取合约信息...');
            
            // 读取公共变量
            const owner = await this.contract.methods.owner().call();
            const contractName = await this.contract.methods.name().call();
            const value = await this.contract.methods.value().call();
            const isActive = await this.contract.methods.isActive().call();
            
            console.log(`👑 合约所有者: ${owner}`);
            console.log(`🏷️  合约名称: ${contractName}`);
            console.log(`💰 当前值: ${value}`);
            console.log(`🔌 激活状态: ${isActive}`);
            
            // 调用返回多个值的函数
            const info = await this.contract.methods.getContractInfo().call();
            console.log(`👥 用户数量: ${info.userCount}`);
            
            // 计算函数
            const withFee = await this.contract.methods.calculateWithFee(100).call();
            console.log(`🧮 100 + 5%手续费 = ${withFee}`);
            
            return { owner, contractName, value, isActive };
        } catch (error) {
            console.error('❌ 读取失败:', error);
        }
    }
    
    // 6. 写入函数示例
    async interactWithContract() {
        try {
            console.log('\n✍️  与合约交互...');
            
            // 注册用户
            console.log('👤 注册用户...');
            const tx1 = await this.contract.methods.registerUser("Alice").send({
                from: this.accounts[1],
                gas: 200000
            });
            console.log(`✅ 用户注册成功，交易哈希: ${tx1.transactionHash}`);
            
            // 存款
            console.log('💰 存款1 ETH...');
            const tx2 = await this.contract.methods.deposit().send({
                from: this.accounts[1],
                value: web3.utils.toWei('1', 'ether'),
                gas: 150000
            });
            console.log(`✅ 存款成功，交易哈希: ${tx2.transactionHash}`);
            
            // 查询余额
            const balance = await this.contract.methods.getUserBalance(this.accounts[1]).call();
            console.log(`💳 用户余额: ${web3.utils.fromWei(balance, 'ether')} ETH`);
            
            // 转账给其他用户
            console.log('🔄 转账给其他用户...');
            const tx3 = await this.contract.methods.transfer(this.accounts[2], web3.utils.toWei('0.5', 'ether'))
                .send({
                    from: this.accounts[1],
                    gas: 150000
                });
            console.log(`✅ 转账成功，交易哈希: ${tx3.transactionHash}`);
            
            // Owner操作：更新白名单
            console.log('📝 更新白名单...');
            const tx4 = await this.contract.methods.updateWhitelist(this.accounts[1], true)
                .send({
                    from: this.accounts[0],
                    gas: 150000
                });
            console.log(`✅ 白名单更新成功`);
            
            // 设置新值（现在用户在白名单中）
            console.log('🔧 设置新值...');
            const tx5 = await this.contract.methods.setValue(200)
                .send({
                    from: this.accounts[1],
                    gas: 150000
                });
            console.log(`✅ 值更新成功，交易哈希: ${tx5.transactionHash}`);
            
        } catch (error) {
            console.error('❌ 交互失败:', error.message);
        }
    }
    
    // 7. 事件监听
    async setupEventListeners() {
        console.log('\n👂 设置事件监听器...');
        
        // 监听ValueChanged事件
        this.contract.events.ValueChanged({
            filter: {},
            fromBlock: 0
        })
        .on('data', (event) => {
            console.log(`📊 ValueChanged事件:`);
            console.log(`   改变者: ${event.returnValues.changer}`);
            console.log(`   旧值: ${event.returnValues.oldValue}`);
            console.log(`   新值: ${event.returnValues.newValue}`);
            console.log(`   区块: ${event.blockNumber}`);
        })
        .on('error', console.error);
        
        // 监听UserRegistered事件
        this.contract.events.UserRegistered({
            filter: {},
            fromBlock: 0
        })
        .on('data', (event) => {
            console.log(`👤 UserRegistered事件:`);
            console.log(`   用户: ${event.returnValues.user}`);
            console.log(`   ID: ${event.returnValues.userId}`);
            console.log(`   名称: ${event.returnValues.userName}`);
        });
        
        // 监听所有事件
        this.contract.events.allEvents({
            fromBlock: 'latest'
        })
        .on('data', (event) => {
            console.log(`📨 收到事件: ${event.event} from ${event.returnValues}`);
        });
    }
    
    // 8. 批量操作示例
    async batchOperations() {
        console.log('\n🔄 批量操作示例...');
        
        try {
            // 批量更新白名单
            const users = [this.accounts[2], this.accounts[3]];
            const statuses = [true, true];
            
            const tx = await this.contract.methods
                .batchUpdateWhitelist(users, statuses)
                .send({
                    from: this.accounts[0],
                    gas: 300000
                });
                
            console.log(`✅ 批量操作成功，交易哈希: ${tx.transactionHash}`);
        } catch (error) {
            console.error('❌ 批量操作失败:', error);
        }
    }
    
    // 9. 查询历史事件
    async queryPastEvents() {
        try {
            console.log('\n📜 查询历史事件...');
            
            const events = await this.contract.getPastEvents('ValueChanged', {
                fromBlock: 0,
                toBlock: 'latest'
            });
            
            console.log(`📊 找到 ${events.length} 个ValueChanged事件`);
            events.forEach((event, index) => {
                console.log(`   ${index + 1}. ${event.returnValues.changer} 从 ${event.returnValues.oldValue} 改为 ${event.returnValues.newValue}`);
            });
            
            return events;
        } catch (error) {
            console.error('❌ 查询事件失败:', error);
        }
    }
    
    // 10. 完整的交互流程
    async fullInteraction() {
        try {
            // 编译合约
            await this.compileContract();
            
            // 部署或连接
            const useExisting = false; // 设为true使用已部署合约
            const existingAddress = '0x...'; // 已部署合约地址
            
            if (!useExisting) {
                await this.deployContract();
            } else {
                await this.connectToContract(existingAddress);
            }
            
            // 获取账户
            this.accounts = await web3.eth.getAccounts();
            console.log(`👥 可用账户: ${this.accounts.slice(0, 3).join(', ')}...`);
            
            // 读取合约信息
            await this.readContractInfo();
            
            // 设置事件监听
            await this.setupEventListeners();
            
            // 与合约交互
            await this.interactWithContract();
            
            // 批量操作
            await this.batchOperations();
            
            // 查询历史事件
            await this.queryPastEvents();
            
            console.log('\n🎉 所有操作完成！');
            
        } catch (error) {
            console.error('❌ 流程执行失败:', error);
        }
    }
}

// 使用示例
async function main() {
    const interactor = new MyContractInteractor();
    
    // 运行完整流程
    await interactor.fullInteraction();
    
    // 或单独调用某个功能
    // await interactor.compileContract();
    // await interactor.deployContract();
    // await interactor.connectToContract('0x...');
    // await interactor.readContractInfo();
}

// 运行主函数
if (require.main === module) {
    main().catch(console.error);
}

module.exports = MyContractInteractor;

package.json 依赖

{
  "name": "my-contract-interaction",
  "version": "1.0.0",
  "scripts": {
    "start": "node myContractInteractions.js",
    "deploy": "node deploy.js",
    "test": "node testInteractions.js"
  },
  "dependencies": {
    "web3": "^4.0.3",
    "solc": "^0.8.19",
    "dotenv": "^16.0.0"
  }
}

测试脚本示例

// testInteractions.js
const MyContractInteractor = require('./myContractInteractions.js');

async function test() {
    const interactor = new MyContractInteractor();
    
    // 测试编译
    await interactor.compileContract();
    
    // 测试部署（需要本地以太坊节点）
    if (process.env.TEST_DEPLOY === 'true') {
        await interactor.deployContract();
        await interactor.readContractInfo();
    }
    
    console.log('✅ 测试完成');
}

test();

这个完整的示例包含了：

  1. 全面的 Solidity 合约：包含各种函数类型、修饰器、事件、数据结构
  2. 完整的 Web3.js 交互流程：编译、部署、读取、写入、事件监听
  3. 错误处理和最佳实践
  4. 模块化设计：便于扩展和维护
Web3前端开发：与以太坊智能合约交互实录
s13166803785的博客
05-29 188
Web3前端开发：与以太坊智能合约交互实录
以太坊智能合约开发：从Solidity到Truffle实战
shejizuopin的博客
04-16 996
Solidity是一种面向合约的高级编程语言，用于编写在以太坊虚拟机（EVM）上运行的智能合约。它具有类似JavaScript的语法，并提供了丰富的特性来支持智能合约的开发。Truffle是以太坊生态系统中最早且最成熟的开发框架之一，为智能合约的开发、测试、部署和与前端集成提供了全方位的工具支持。它支持Solidity和Vyper等合约语言，并与以太坊主网、测试网和本地开发网络无缝集成。以太坊智能合约的开发涉及多个环节，从Solidity编程到Truffle框架的实战应用。
Web3前沿技术的智能合约安全审计
AI天才研究院
05-08 1280
随着Web3技术的快速发展，智能合约作为区块链应用的核心组件，其安全性问题日益突出。本文旨在系统性地介绍智能合约安全审计的技术体系，帮助开发者理解智能合约安全风险，掌握安全审计的方法论和工具链。智能合约安全的基本概念常见漏洞类型及其原理安全审计的技术方法实际审计案例分析安全审计工具和资源首先介绍基本概念和背景然后分析常见漏洞和安全风险接着详细讲解安全审计技术提供实际案例和代码示例最后讨论工具资源和未来趋势智能合约：运行在区块链上的自执行程序，代码即法律安全审计。
AI+Web3：从Web2到Web3的范式革命与深度技术实践
程序边界
07-04 1万+
AI+Web3的融合正在开启数字文明的新纪元。从IO.NET的分布式算力革命到Bittensor的模型众包，从Power Ledger的能源自治到Streamr的数据民主化，这场技术革命不仅重构了技术栈，更在重塑人类社会的协作方式。跨链智能合约开发：Solidity/Rust双修隐私计算技术：零知识证明+同态加密分布式AI框架：联邦学习+模型蒸馏经济系统设计：代币经济学+DAO治理未来的数字世界将由代码与共识共同构建，而AI+Web3正是这场变革的核心引擎。
Java基于Web3j调用智能智能合约案例
友莘居士的博客
10-15 471
本文提供了一个完整的Java调用智能合约的示例方案，包含环境配置、合约部署和调用方法。主要内容包括：1）环境准备，添加必要的Maven依赖；2）Solidity合约示例代码，展示一个简单的存储合约；3）Java调用代码，包含合约部署、加载和读写方法调用；4）测试类演示完整调用流程；5）使用Web3j命令行工具生成Java包装类的步骤。该方案通过Web3j库实现Java与区块链智能合约的交互，覆盖了从合约部署到方法调用的全流程。
9、使用Web3与智能合约交互
open4的博客
07-13 56
本文详细介绍了如何使用Web3库与以太坊智能合约进行交互，涵盖了燃气（Gas）和燃气价格的概念、随机数（Nonce）的作用、在Rinkeby和Ganache网络中发送交易及部署智能合约的方法。文章还分析了不同网络的差异、常见问题的解决方法，并通过实际案例演示了如何实现智能合约的部署与调用，适合希望深入了解区块链开发的读者。
手把手教你一步步开发第一个Dapp(使用solidity语言实现投票合约)——Remix版本
热门推荐
自我总结，分享所有，快乐每一天
01-31 1万+
第一个Dapp开发(使用solidity语言实现投票合约)——Remix版本 Remix使用教程 MetaMask使用教程 Dapp开发技术 Web3.js
Lesson2:用Truffle测试智能合约
Bunny_51的博客
03-20 2207
欢迎!通过完成前面的课程，你已经证明了你真正了解你的东西。因此，继续将游戏部署到主网。享受你的成功!等一下……有一些事情你可能已经想到了。毕竟，一旦合约被部署到主网，它们将永远存在。如果其中有错误，它们也会继续存在。就像不死僵尸。无论多么熟练，每个程序员都会遇到错误或bug。你不太可能犯一个大错误，比如给攻击僵尸100%的胜利机会，但这是可能的。显然，给予进攻方100%的胜率将意味着你所写的内容不再是游戏，甚至没有任何乐趣。这样的漏洞可能会让你的游戏彻底失败，也不可能让你的僵尸死里逃生。
Web3.0智能合约安全开发：漏洞分析、防护技巧与实战指南
shejizuopin的博客
03-24 1057
智能合约安全开发是一个系统工程，需要开发者在架构设计、编码实现、审计测试等多个环节保持警惕。通过遵循安全编码规范、采用经过验证的安全模式、实施严格的安全审计，可以显著降低合约被攻击的风险。建议开发者持续关注最新安全动态，参与安全社区交流，不断提升自身的安全开发能力。
Java 在 Web3 时代的新定位
码刀攻城
12-13 772
在Web3时代，联盟链的企业级落地需求决定了技术选型的核心标准是“稳定、安全、可整合、可维护”，而这正是Java的核心竞争力
家家有平台：Web3.0绿色积分引领消费新纪元
seaofstar413的博客
12-17 438
摘要：家家有平台通过区块链与AI技术构建透明积分生态，助力实体商业数字化转型。其创新模式实现"0元加盟"和"无感锁客"，让商家共享生态流量红利，消费者获得可积累的绿色积分资产。平台紧扣国家数字经济发展战略，以"供应链+数字化工具+积分体系"三重赋能实体经济，推动商业价值与社会价值统一。典型案例显示，接入平台显著提升商家客户复购率与经营决策精准度，展现了数字经济与实体经济融合的创新实践。（149字）
Solidity入门（11）-智能合约设计模式2
weixin_43444221的博客
12-18 398
我们都知道，智能合约部署后代码是不可修改的。在紧急情况下，能够快速暂停合约的功能，防止损失扩大。从这些例子可以看出，真正的工程实践中，设计模式不是孤立使用的，而是根据业务需求组合使用，每个模式解决特定的问题。通过分离数据存储和业务逻辑，我们可以在不改变合约地址的情况下升级业务逻辑。这个模式在需要创建多个合约实例的场景中非常有用，还能大幅降低部署成本。在实际项目中，我们通常会组合使用多个设计模式来构建复杂的系统。现在我们已经学习了6种设计模式，让我们做一个对比，帮助大家在实际项目中选择合适的模式。
区块链智能合约之MetaMask插件安装
xuguiyi100的专栏
12-17 223
区块链智能合约之MetaMask插件安装
Spring Boot 集成区块链：智能合约调用接口开发全解析
码刀攻城
12-13 1342
Spring Boot集成区块链并开发智能合约调用接口的实现方案
Solidity入门（10）-智能合约设计模式1
weixin_43444221的博客
12-18 481
在软件工程中，设计模式是被反复使用的、经过实践验证的解决方案。它们不是具体的代码，而是一种解决特定问题的思路和方法。设计模式的价值：经过实践验证的解决方案减少常见错误提高代码可维护性不需要从零开始设计复用成熟的方案减少开发时间模式通常考虑了安全因素避免常见的安全漏洞提高合约的可靠性团队成员都理解这些模式代码更容易理解和维护降低沟通成本状态机（State Machine）是一种计算模型，它定义了一组有限的状态，以及状态之间的转换规则。
ZK暗战终局：STARK用哈希匕首撕碎「信任神殿」的数学圣战
Biteagle的博客
12-15 376
比特鹰直击密码学最血腥革命——当STARK以哈希函数为武器，终结SNARK的「魔法仪式」，区块链将迎来零信任原生的新时代。本文将揭秘抗量子核武库的运作原理，并预言ZK-Rollup终局之战的关键转折。
区块链 + AI：医疗诊断模型存证上链技术实践与探索
码刀攻城
12-16 784
区块链技术为AI医疗诊断模型的可信度提升、知识产权保护与数据隐私安全提供了有效解决方案
PinMe——极简、免费和无需服务器的开源前端部署工具
最新发布
2303_76885849的博客
12-18 332
PinMe是一款开源的前端部署工具（GitHub 1.7k stars），支持通过命令行或浏览器将静态网站快速部署到IPFS网络。核心特性包括免费、去中心化存储、内容不可篡改，提供.eth.limo短链接。支持HTML/CSS/JS等静态资源，适合个人简历、项目Demo等场景。首次访问可能稍慢，但后续会加速。免费版已满足基本需求，付费版提供更大存储和定制域名。相比传统托管平台，PinMe更侧重快速部署和内容自主权，但不支持动态功能。官网：https://pinme.eth.limo/
区块链软件开发专家：达普韦伯的技术哲学与实战体系
sun10861的博客
12-18 216
为一个传统资管背景的DeFi项目，我们不仅完成了复杂的多策略质押合约开发，更关键的是协助其设计并模拟了一套可持续的代币释放与回购机制。我是达普韦伯技术团队的负责人，今天，我想以一名深耕行业多年的开发者视角，与各位分享我们如何构建可靠、高效且面向未来的区块链软件解决方案。- 为一个急于上线的新兴链游项目，我们在十一天内交付了全套质押与资产市场系统，其合约代码的简洁与高效，使其Gas消耗比行业平均水平低约百分之四十，赢得了早期用户的积极反馈。区块链开发的世界里，速度与安全并非取舍，而是必须兼顾的工程艺术。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

友莘居士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值