Web3协议拆解｜ LGNS模式实战：用Solidity构建弹性供应+自动回购高级代币

木西
发布于 5小时前
阅读 32

前言2026年DeFi浪潮中，以LGNS（ORIGIN）为代表的“持币增产”模式再度兴起。不同于传统质押挖矿，其核心是通过智能合约的Rebase（弹性供应）机制，实现“无需操作、余额自动增长”；但单一Rebase机制难以对抗抛压、稳定生态，因此结合自动化回购（Buyback/Liquify）的进

# 前言

>2026年DeFi浪潮中，以LGNS（ORIGIN）为代表的“持币增产”模式再度兴起。不同于传统质押挖矿，其核心是通过智能合约的Rebase（弹性供应）机制，实现“无需操作、余额自动增长”；但单一Rebase机制难以对抗抛压、稳定生态，因此结合自动化回购（Buyback/Liquify）的进阶模型更具实用性。本文将拆解Rebase核心逻辑，完整呈现LGNS进阶合约的架构、代码、测试流程，并分析其经济学博弈与潜在风险。

# 一、核心理论模型：Rebase（弹性供应）

Rebase（弹性供应）是持币增产的底层核心，本质是通过智能合约自动调整代币总供应量，间接实现用户余额“静默增长”，核心逻辑围绕“份额守恒”，区别于传统固定供应量代币模型。

### 1.1 核心定义与特点

协议会根据市场价格或预设周期，自动调整所有持有者的代币余额，无需用户手动领取，余额“静默增长”的特性的是其吸引用户的核心优势。

### 1.2 数学逻辑

-   **份额 (Shares/Gons) 守恒**：用户的核心资产是合约总量的“占比”（非固定代币数量），合约通过Gons（份额）计量实际资产，这是Rebase实现的关键。
-   **供应量函数**：$$Balance=\frac{TotalShares}{Factor}$$，其中Balance为用户钱包显示余额，TotalShares为用户持有的Gons总量，Factor为缩放因子。
-   **增产实质**：Factor（缩放因子）减小，所有人余额同步增加；Factor增大，余额同步减少，本质是调整“份额兑换比例”，而非直接增发或销毁份额。

### 1.3 收益来源分类 (Yield Origin)

持币增产收益分为两类，这是判断项目价值的核心：

-   **内生性（虚幻增长）** ：仅依赖代币自身机制，无外部现金流注入，长期易面临价格下跌。

-   **通胀增发**：传统LGNS模式的增产源于合约无限增发，若无新增资金（TVL），代币价格会随增发等比例下跌，用户余额增加但实际资产未提升（即$$1\times1=2\times0.5$$）。
    -   **铸币税再分配**：通过交易手续费回购代币并分发给持有人，本质是转移交易成本，未创造新增价值。

-   **外生性（真实收益 Real Yield）** ：源于协议业务收入或外部生态奖励，具备可持续性，是优质DeFi项目的核心竞争力。

-   **借贷利差**：如Aave的aToken，收益来自借款人支付的利息，依托真实借贷需求。
    -   **PoS 质押奖励**：如Lido的stETH，收益来自以太坊节点共识奖励，依托公链生态价值。
    -   **协议收入分红**：协议将服务费（如交易费）分配给质押者，收益与业务规模挂钩。

# 二、经济学悖论：死亡螺旋与应对策略

持币增产项目的核心难题是对抗抛压——Rebase带来的余额增长易刺激用户抛售，缺乏约束则极易陷入死亡螺旋。

### 2.1 (3, 3) 博弈论

源自Olympus DAO的核心共识逻辑：若所有人持有不卖出，代币价值将正向循环增长；一旦共识破裂，抛售会引发“抛售→价跌→更疯狂抛售”的死亡螺旋，这是多数Rebase项目失败的关键。

### 2.2 退出成本（Exit Tax）

为对抗抛压，多数项目设置10%-20%的卖出税，用户卖出时扣除部分资金，补贴在场持有人，本质是用后来者离场成本维持短期生态稳定，无法从根本上解决共识破裂问题。

# 三、LGNS进阶合约：Rebase+自动化回购的实现

针对单一Rebase的缺陷，我们设计了LGNSAdvancedToken进阶合约，依托OpenZeppelin库，兼顾Rebase“静默增产”优势与自动化回购的真实收益支撑，缓解抛压、提升生态可持续性。

### 3.1 核心架构设计

合约包含三个联动模块，构成完整的持币增产与生态稳定体系：

1.  **Gons 份额制余额系统**：通过$$_gonBalances$$映射实现，用户持有总量“份额”（Gons），Rebase仅调整份额与代币兑换比例，保障份额守恒。
1.  **动态交易税**：重写ERC20合约$$_update$$函数，识别流动性池（pair）地址，用户卖出代币时自动扣除10%交易税，存入合约作为回购资金。
1.  **自动化回购 (SwapAndLiquify)** ：通过Uniswap V2接口，将累积税费代币自动兑换为ETH并存入国库，用于生态建设或分红，形成“交易税→回购→真实资产注入”的正向循环。

### 3.2 合约代码实现

以下为完整合约代码（基于Solidity 0.8.24，依赖OpenZeppelin库），含主合约及测试用模拟合约。

### 3.2.1 LGNSAdvancedToken智能合约

```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface IUniswapV2Router02 {
    function WETH() external pure returns (address);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline
    ) external;
}

contract LGNSAdvancedToken is ERC20, Ownable {
    uint256 private constant MAX_UINT256 = type(uint256).max;
    uint256 private constant INITIAL_SUPPLY = 1000000 * 10**18;
    uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_SUPPLY);
    
    uint256 private _totalSupply;
    uint256 private _gonsPerFragment;
    mapping(address => uint256) private _gonBalances;

uint256 public sellTax = 10; // 10% 卖出税
    address public treasury;     // 国库地址
    IUniswapV2Router02 public router;
    address public pair;
    bool private inSwap;

constructor(address _router, address _treasury) ERC20("LGNS Pro", "LGNSP") Ownable(msg.sender) {
        _totalSupply = INITIAL_SUPPLY;
        _gonsPerFragment = TOTAL_GONS / _totalSupply;
        _gonBalances[msg.sender] = TOTAL_GONS; 
        router = IUniswapV2Router02(_router);
        treasury = _treasury;
        emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
    }

function balanceOf(address account) public view override returns (uint256) {
        return _gonBalances[account] / _gonsPerFragment;
    }

function _update(address from, address to, uint256 value) internal override {
        if (from == address(0)) { super._update(from, to, value); return; }

uint256 gonAmount = value * _gonsPerFragment;
        require(_gonBalances[from] >= gonAmount, "Insufficient Balance");

uint256 taxAmount = 0;
        // 卖出逻辑：接收者为流动性池且不在swap过程中
        if (!inSwap && to == pair && pair != address(0)) {
            taxAmount = (value * sellTax) / 100;
        }

uint256 amountReceived = value - taxAmount;
        _gonBalances[from] -= gonAmount;
        _gonBalances[to] += (amountReceived * _gonsPerFragment);

if (taxAmount > 0) {
            _gonBalances[address(this)] += (taxAmount * _gonsPerFragment);
            emit Transfer(from, address(this), taxAmount);
        }
        emit Transfer(from, to, amountReceived);
    }

function swapAndLiquify() external {
        uint256 contractTokenBalance = balanceOf(address(this));
        if (contractTokenBalance == 0) return;

inSwap = true;
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

_approve(address(this), address(router), contractTokenBalance);
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            contractTokenBalance, 0, path, treasury, block.timestamp
        );
        inSwap = false;
    }

function rebase(uint256 rate) external onlyOwner {
        _totalSupply = (_totalSupply * (10000 + rate)) / 10000;
        _gonsPerFragment = TOTAL_GONS / _totalSupply;
    }
}
```

### 3.2.2 模拟合约（MockUniswapV2Pair/Router）

用于测试环境部署，模拟Uniswap V2流动性池和路由的兑换逻辑：

```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// 模拟 Uniswap V2 Pair
contract MockUniswapV2Pair {
    address public token0;
    address public token1;

function initialize(address _token0, address _token1) external {
        token0 = _token0;
        token1 = _token1;
    }
    
    function sync() external {}
}

// 模拟 Uniswap V2 Router
contract MockUniswapV2Router {
    address public WETH;

constructor(address _weth) {
        WETH = _weth;
    }

// 模拟交换逻辑
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline
    ) external {
        IERC20(path[0]).transferFrom(msg.sender, address(this), amountIn);
        // 模拟1:1兑换，实际可调整比例
        payable(to).transfer(address(this).balance > 0 ? 0.01 ether : 0); 
    }

receive() external payable {}
}
```

# 四、测试与验证：基于Hardhat Viem

为确保合约逻辑正确，使用Hardhat Viem框架编写测试脚本，覆盖税费收集、自动化回购、Rebase联动三大核心功能。

## 4.1 测试重点

1.  税费收集：验证用户卖出代币时，合约是否准确收取10%交易税。
1.  Swap流程：调用swapAndLiquify函数，验证合约税费代币清零、国库ETH余额增加。
1.  Rebase联动：执行10%通胀Rebase，验证用户余额自动按比例增长。

## 4.2 测试输出结果

```
  LGNS 自动化回购全流程测试
    ✅ 合约已积累税费: 100.0 LGNS
    🚀 Swap后合约余额: 0.0 LGNS
    💰 国库收到 ETH 后的变动: 0.01 ETH
    ✔ 应该能够扣除卖出税并完成 SwapAndLiquify (1245ms)
    📈 Rebase 后 User 余额: 110.0 LGNS
    ✔ Rebase 逻辑验证：通胀后余额应自动按比例增加 (110ms)
```

## 4.3 测试脚本

```
import assert from "node:assert/strict";
import { describe, it, beforeEach } from "node:test";
import { parseEther, formatEther } from 'viem';
import { network } from "hardhat";

describe("LGNS 自动化回购全流程测试", function () {
    let LGNS, MockRouter, MockWETH;
    let publicClient, walletClient;
    let owner, user, treasury;

beforeEach(async function () {
        // 环境初始化
        const { viem } = await (network as any).connect();
        publicClient = await viem.getPublicClient();
        [owner, user, treasury] = await viem.getWalletClients();

// 部署模拟设施
        MockWETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"; 
        MockRouter = await viem.deployContract("MockUniswapV2Router", [MockWETH]);

// 部署LGNS合约
        LGNS = await viem.deployContract("LGNSAdvancedToken", [
            MockRouter.address, 
            treasury.account.address
        ]);

// 模拟创建流动性池并绑定
        const MockPair = await viem.deployContract("MockUniswapV2Pair");
        await LGNS.write.setPair([MockPair.address]);

// 给Router注入测试ETH
        await owner.sendTransaction({
            to: MockRouter.address,
            value: parseEther("1"),
        });
    });

it("扣除卖出税并完成SwapAndLiquify", async function () {
        const initialAmount = parseEther("1000");
        const sellAmount = parseEther("1000");
        const expectedTax = parseEther("100");

// 初始化用户余额
        await LGNS.write.transfer([user.account.address, initialAmount]);
        const userBal = await LGNS.read.balanceOf([user.account.address]);
        assert.equal(userBal, initialAmount, "User初始余额应为1000");

// 模拟卖出
        const pairAddress = await LGNS.read.pair();
        await LGNS.write.transfer([pairAddress, sellAmount], { account: user.account });

// 验证税费
        const taxInContract = await LGNS.read.balanceOf([LGNS.address]);
        console.log(`✅ 合约已积累税费: ${formatEther(taxInContract)} LGNS`);
        assert.equal(taxInContract, expectedTax, "合约应存10%税费");

// 执行回购
        const treasuryEthBefore = await publicClient.getBalance({ address: treasury.account.address });
        await LGNS.write.swapAndLiquify();

// 验证结果
        const taxAfter = await LGNS.read.balanceOf([LGNS.address]);
        const treasuryEthAfter = await publicClient.getBalance({ address: treasury.account.address });

console.log(`🚀 Swap后合约余额: ${formatEther(taxAfter)} LGNS`);
        console.log(`💰 国库ETH变动: ${formatEther(treasuryEthAfter - treasuryEthBefore)} ETH`);

assert.equal(taxAfter, 0n, "合约余额应清空");
        assert.ok(treasuryEthAfter > treasuryEthBefore, "国库ETH应增加");
    });

it("Rebase逻辑验证：通胀后余额自动增长", async function () {
        const amount = parseEther("100");
        await LGNS.write.transfer([user.account.address, amount]);
        
        // 执行10%通胀Rebase
        await LGNS.write.rebase([1000n]);
        
        const userBalAfter = await LGNS.read.balanceOf([user.account.address]);
        console.log(`📈 Rebase后User余额: ${formatEther(userBalAfter)} LGNS`);
        
        // 验证余额增长（允许微小精度误差）
        assert.ok(userBalAfter >= parseEther("109.9"));
    });
});
```

# 五、潜在风险与安全提醒

LGNSAdvancedToken合约优化了传统持币增产模型，但实际部署仍面临以下风险，需重点防范：

### 5.1 流动性枯竭风险

若Rebase通胀率过高、代币产出过快，而DEX中稳定币未同步注入，代币价格会因供给过剩暴跌，即便有自动化回购也难以对抗抛压，最终导致用户无法变现。

### 5.2 中心化权限风险

合约基于Ownable框架，rebase及核心参数修改权集中在拥有者手中。若拥有者恶意操作（如修改负通胀率）或私钥泄露，会导致用户资产损失、合约被攻击。

### 5.3 Jito 捆绑攻击风险

在Solana或高性能L2公链上，攻击者可利用Jito Bundles在Rebase瞬间抢跑交易，提前买入、生效后卖出，收割普通用户资产。

### 5.4 部署安全提醒

-   滑点保护：当前swap函数中amountOutMin设为0，缺乏保护，实际部署需结合预言机动态设置，防范三明治攻击。
-   权限安全：rebase权限不应集中，建议采用多签钱包或DAO治理，分散风险。
-   Gas优化：合约中转账、映射操作会增加Gas消耗，需优化代码降低用户交易成本。

# 六、结论

Rebase机制的“无需操作、余额自动增长”特性，使其成为DeFi持币增产的核心，但单一机制难以摆脱虚幻增长和死亡螺旋风险。LGNSAdvancedToken合约通过Gons份额制、动态交易税与自动化回购的结合，实现了“Rebase增产+真实资产注入”的双重逻辑，兼顾吸引力与可持续性。

需明确的是，任何DeFi模型都无法完全规避风险，Rebase本质仍是“份额兑换比例调整”，长期价值依赖外部现金流和社区共识。开发者需注重合约安全与机制合理性，用户则应理性看待增产诱惑，谨慎参与相关项目。

前言

2026年DeFi浪潮中，以LGNS（ORIGIN）为代表的“持币增产”模式再度兴起。不同于传统质押挖矿，其核心是通过智能合约的Rebase（弹性供应）机制，实现“无需操作、余额自动增长”；但单一Rebase机制难以对抗抛压、稳定生态，因此结合自动化回购（Buyback/Liquify）的进阶模型更具实用性。本文将拆解Rebase核心逻辑，完整呈现LGNS进阶合约的架构、代码、测试流程，并分析其经济学博弈与潜在风险。

一、核心理论模型：Rebase（弹性供应）

1.1 核心定义与特点

协议会根据市场价格或预设周期，自动调整所有持有者的代币余额，无需用户手动领取，余额“静默增长”的特性的是其吸引用户的核心优势。

1.2 数学逻辑

份额 (Shares/Gons) 守恒：用户的核心资产是合约总量的“占比”（非固定代币数量），合约通过Gons（份额）计量实际资产，这是Rebase实现的关键。
供应量函数：$$Balance=\frac{TotalShares}{Factor}$$，其中Balance为用户钱包显示余额，TotalShares为用户持有的Gons总量，Factor为缩放因子。
增产实质：Factor（缩放因子）减小，所有人余额同步增加；Factor增大，余额同步减少，本质是调整“份额兑换比例”，而非直接增发或销毁份额。

1.3 收益来源分类 (Yield Origin)

持币增产收益分为两类，这是判断项目价值的核心：

内生性（虚幻增长） ：仅依赖代币自身机制，无外部现金流注入，长期易面临价格下跌。
- 通胀增发：传统LGNS模式的增产源于合约无限增发，若无新增资金（TVL），代币价格会随增发等比例下跌，用户余额增加但实际资产未提升（即$$1\times1=2\times0.5$$）。
- 铸币税再分配：通过交易手续费回购代币并分发给持有人，本质是转移交易成本，未创造新增价值。
外生性（真实收益 Real Yield） ：源于协议业务收入或外部生态奖励，具备可持续性，是优质DeFi项目的核心竞争力。
- 借贷利差：如Aave的aToken，收益来自借款人支付的利息，依托真实借贷需求。
- PoS 质押奖励：如Lido的stETH，收益来自以太坊节点共识奖励，依托公链生态价值。
- 协议收入分红：协议将服务费（如交易费）分配给质押者，收益与业务规模挂钩。

二、经济学悖论：死亡螺旋与应对策略

持币增产项目的核心难题是对抗抛压——Rebase带来的余额增长易刺激用户抛售，缺乏约束则极易陷入死亡螺旋。

2.1 (3, 3) 博弈论

2.2 退出成本（Exit Tax）

三、LGNS进阶合约：Rebase+自动化回购的实现

3.1 核心架构设计

合约包含三个联动模块，构成完整的持币增产与生态稳定体系：

Gons 份额制余额系统：通过$$_gonBalances$$映射实现，用户持有总量“份额”（Gons），Rebase仅调整份额与代币兑换比例，保障份额守恒。
动态交易税：重写ERC20合约$$_update$$函数，识别流动性池（pair）地址，用户卖出代币时自动扣除10%交易税，存入合约作为回购资金。
自动化回购 (SwapAndLiquify) ：通过Uniswap V2接口，将累积税费代币自动兑换为ETH并存入国库，用于生态建设或分红，形成“交易税→回购→真实资产注入”的正向循环。

3.2 合约代码实现

以下为完整合约代码（基于Solidity 0.8.24，依赖OpenZeppelin库），含主合约及测试用模拟合约。

3.2.1 LGNSAdvancedToken智能合约

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface IUniswapV2Router02 {
    function WETH() external pure returns (address);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline
    ) external;
}

contract LGNSAdvancedToken is ERC20, Ownable {
    uint256 private constant MAX_UINT256 = type(uint256).max;
    uint256 private constant INITIAL_SUPPLY = 1000000 * 10**18;
    uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_SUPPLY);

    uint256 private _totalSupply;
    uint256 private _gonsPerFragment;
    mapping(address => uint256) private _gonBalances;

    uint256 public sellTax = 10; // 10% 卖出税
    address public treasury;     // 国库地址
    IUniswapV2Router02 public router;
    address public pair;
    bool private inSwap;

    constructor(address _router, address _treasury) ERC20("LGNS Pro", "LGNSP") Ownable(msg.sender) {
        _totalSupply = INITIAL_SUPPLY;
        _gonsPerFragment = TOTAL_GONS / _totalSupply;
        _gonBalances[msg.sender] = TOTAL_GONS; 
        router = IUniswapV2Router02(_router);
        treasury = _treasury;
        emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _gonBalances[account] / _gonsPerFragment;
    }

    function _update(address from, address to, uint256 value) internal override {
        if (from == address(0)) { super._update(from, to, value); return; }

        uint256 gonAmount = value * _gonsPerFragment;
        require(_gonBalances[from] >= gonAmount, "Insufficient Balance");

        uint256 taxAmount = 0;
        // 卖出逻辑：接收者为流动性池且不在swap过程中
        if (!inSwap && to == pair && pair != address(0)) {
            taxAmount = (value * sellTax) / 100;
        }

        uint256 amountReceived = value - taxAmount;
        _gonBalances[from] -= gonAmount;
        _gonBalances[to] += (amountReceived * _gonsPerFragment);

        if (taxAmount > 0) {
            _gonBalances[address(this)] += (taxAmount * _gonsPerFragment);
            emit Transfer(from, address(this), taxAmount);
        }
        emit Transfer(from, to, amountReceived);
    }

    function swapAndLiquify() external {
        uint256 contractTokenBalance = balanceOf(address(this));
        if (contractTokenBalance == 0) return;

        inSwap = true;
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

        _approve(address(this), address(router), contractTokenBalance);
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            contractTokenBalance, 0, path, treasury, block.timestamp
        );
        inSwap = false;
    }

    function rebase(uint256 rate) external onlyOwner {
        _totalSupply = (_totalSupply * (10000 + rate)) / 10000;
        _gonsPerFragment = TOTAL_GONS / _totalSupply;
    }
}

3.2.2 模拟合约（MockUniswapV2Pair/Router）

用于测试环境部署，模拟Uniswap V2流动性池和路由的兑换逻辑：

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// 模拟 Uniswap V2 Pair
contract MockUniswapV2Pair {
    address public token0;
    address public token1;

    function initialize(address _token0, address _token1) external {
        token0 = _token0;
        token1 = _token1;
    }

    function sync() external {}
}

// 模拟 Uniswap V2 Router
contract MockUniswapV2Router {
    address public WETH;

    constructor(address _weth) {
        WETH = _weth;
    }

    // 模拟交换逻辑
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline
    ) external {
        IERC20(path[0]).transferFrom(msg.sender, address(this), amountIn);
        // 模拟1:1兑换，实际可调整比例
        payable(to).transfer(address(this).balance > 0 ? 0.01 ether : 0); 
    }

    receive() external payable {}
}

四、测试与验证：基于Hardhat Viem

为确保合约逻辑正确，使用Hardhat Viem框架编写测试脚本，覆盖税费收集、自动化回购、Rebase联动三大核心功能。

4.1 测试重点

税费收集：验证用户卖出代币时，合约是否准确收取10%交易税。
Swap流程：调用swapAndLiquify函数，验证合约税费代币清零、国库ETH余额增加。
Rebase联动：执行10%通胀Rebase，验证用户余额自动按比例增长。

4.2 测试输出结果

  LGNS 自动化回购全流程测试
    ✅ 合约已积累税费: 100.0 LGNS
    🚀 Swap后合约余额: 0.0 LGNS
    💰 国库收到 ETH 后的变动: 0.01 ETH
    ✔ 应该能够扣除卖出税并完成 SwapAndLiquify (1245ms)
    📈 Rebase 后 User 余额: 110.0 LGNS
    ✔ Rebase 逻辑验证：通胀后余额应自动按比例增加 (110ms)

4.3 测试脚本

import assert from "node:assert/strict";
import { describe, it, beforeEach } from "node:test";
import { parseEther, formatEther } from 'viem';
import { network } from "hardhat";

describe("LGNS 自动化回购全流程测试", function () {
    let LGNS, MockRouter, MockWETH;
    let publicClient, walletClient;
    let owner, user, treasury;

    beforeEach(async function () {
        // 环境初始化
        const { viem } = await (network as any).connect();
        publicClient = await viem.getPublicClient();
        [owner, user, treasury] = await viem.getWalletClients();

        // 部署模拟设施
        MockWETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"; 
        MockRouter = await viem.deployContract("MockUniswapV2Router", [MockWETH]);

        // 部署LGNS合约
        LGNS = await viem.deployContract("LGNSAdvancedToken", [
            MockRouter.address, 
            treasury.account.address
        ]);

        // 模拟创建流动性池并绑定
        const MockPair = await viem.deployContract("MockUniswapV2Pair");
        await LGNS.write.setPair([MockPair.address]);

        // 给Router注入测试ETH
        await owner.sendTransaction({
            to: MockRouter.address,
            value: parseEther("1"),
        });
    });

    it("扣除卖出税并完成SwapAndLiquify", async function () {
        const initialAmount = parseEther("1000");
        const sellAmount = parseEther("1000");
        const expectedTax = parseEther("100");

        // 初始化用户余额
        await LGNS.write.transfer([user.account.address, initialAmount]);
        const userBal = await LGNS.read.balanceOf([user.account.address]);
        assert.equal(userBal, initialAmount, "User初始余额应为1000");

        // 模拟卖出
        const pairAddress = await LGNS.read.pair();
        await LGNS.write.transfer([pairAddress, sellAmount], { account: user.account });

        // 验证税费
        const taxInContract = await LGNS.read.balanceOf([LGNS.address]);
        console.log(`✅ 合约已积累税费: ${formatEther(taxInContract)} LGNS`);
        assert.equal(taxInContract, expectedTax, "合约应存10%税费");

        // 执行回购
        const treasuryEthBefore = await publicClient.getBalance({ address: treasury.account.address });
        await LGNS.write.swapAndLiquify();

        // 验证结果
        const taxAfter = await LGNS.read.balanceOf([LGNS.address]);
        const treasuryEthAfter = await publicClient.getBalance({ address: treasury.account.address });

        console.log(`🚀 Swap后合约余额: ${formatEther(taxAfter)} LGNS`);
        console.log(`💰 国库ETH变动: ${formatEther(treasuryEthAfter - treasuryEthBefore)} ETH`);

        assert.equal(taxAfter, 0n, "合约余额应清空");
        assert.ok(treasuryEthAfter > treasuryEthBefore, "国库ETH应增加");
    });

    it("Rebase逻辑验证：通胀后余额自动增长", async function () {
        const amount = parseEther("100");
        await LGNS.write.transfer([user.account.address, amount]);

        // 执行10%通胀Rebase
        await LGNS.write.rebase([1000n]);

        const userBalAfter = await LGNS.read.balanceOf([user.account.address]);
        console.log(`📈 Rebase后User余额: ${formatEther(userBalAfter)} LGNS`);

        // 验证余额增长（允许微小精度误差）
        assert.ok(userBalAfter >= parseEther("109.9"));
    });
});

五、潜在风险与安全提醒

LGNSAdvancedToken合约优化了传统持币增产模型，但实际部署仍面临以下风险，需重点防范：

5.1 流动性枯竭风险

5.2 中心化权限风险

5.3 Jito 捆绑攻击风险

在Solana或高性能L2公链上，攻击者可利用Jito Bundles在Rebase瞬间抢跑交易，提前买入、生效后卖出，收割普通用户资产。

5.4 部署安全提醒

滑点保护：当前swap函数中amountOutMin设为0，缺乏保护，实际部署需结合预言机动态设置，防范三明治攻击。
权限安全：rebase权限不应集中，建议采用多签钱包或DAO治理，分散风险。
Gas优化：合约中转账、映射操作会增加Gas消耗，需优化代码降低用户交易成本。

六、结论

原创
学分: 0
分类: 以太坊
标签: 智能合约 Solidity LGNS

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

Web3协议拆解｜ LGNS模式实战：用Solidity构建弹性供应+自动回购高级代币

前言

一、核心理论模型：Rebase（弹性供应）

1.1 核心定义与特点

1.2 数学逻辑

1.3 收益来源分类 (Yield Origin)

二、经济学悖论：死亡螺旋与应对策略

2.1 (3, 3) 博弈论

2.2 退出成本（Exit Tax）

三、LGNS进阶合约：Rebase+自动化回购的实现

3.1 核心架构设计

3.2 合约代码实现

3.2.1 LGNSAdvancedToken智能合约

3.2.2 模拟合约（MockUniswapV2Pair/Router）

四、测试与验证：基于Hardhat Viem

4.1 测试重点

4.2 测试输出结果

4.3 测试脚本

五、潜在风险与安全提醒

5.1 流动性枯竭风险

5.2 中心化权限风险

5.3 Jito 捆绑攻击风险

5.4 部署安全提醒

六、结论

0 条评论

文章目录

Web3协议拆解 ｜ LGNS模式实战：用Solidity构建弹性供应+自动回购高级代币

前言

一、核心理论模型：Rebase（弹性供应）

1.1 核心定义与特点

1.2 数学逻辑

1.3 收益来源分类 (Yield Origin)

二、经济学悖论：死亡螺旋与应对策略

2.1 (3, 3) 博弈论

2.2 退出成本（Exit Tax）

三、LGNS进阶合约：Rebase+自动化回购的实现

3.1 核心架构设计

3.2 合约代码实现

3.2.1 LGNSAdvancedToken智能合约

3.2.2 模拟合约（MockUniswapV2Pair/Router）

四、测试与验证：基于Hardhat Viem

4.1 测试重点

4.2 测试输出结果

4.3 测试脚本

五、潜在风险与安全提醒

5.1 流动性枯竭风险

5.2 中心化权限风险

5.3 Jito 捆绑攻击风险

5.4 部署安全提醒

六、结论

0 条评论

文章目录

Web3协议拆解｜ LGNS模式实战：用Solidity构建弹性供应+自动回购高级代币