Arbitrum链发币教程——Arbitrum（ARB）链上持币分红Arb合约代码部署及配置操作流程【pdf+视频Arbitrum发币教程下载】

a. 可以实现分红任何币种，即所谓的万能分红合约，并且分红给的代币合约地址是通过构造函数传入的。

b. 实现自动筑池，添加流动性的 LP 属于黑洞地址 address(0)

c. 手续费回流营销钱包，并且回流的是指定的分红币种，非本币

d. 每笔交易都会有部分手续费销毁掉，转入黑洞地址 0x000000000000000000000000000000000000dEaD ，但是代币的总发行量不会减少。严格来说这不是销毁，是每笔交易都有部分代币作为手续费被永久锁定到ARB公认黑洞地址。

e. 该合约可以实现买入卖出配置不同的交易手续费，对应的分红，自动筑池，营销钱包，销毁的手续费可以灵活配置买入卖出时不同的比例。对应的手续费设置为0相当于关闭了该功能。这个功能是非常灵活和强大的，已经包含的功能基本上涵盖了目前市面上绝大部分的主流模式。

2、合约功能模式说明：
arbitrum链上部署实现持币分红ARB的智能合约，上线sushiswap交易所，在合约中直接创建代币和ETH组成的交易对，根据用户持币的本币的权重来实现持币分红ARB，其中买入和卖出15%的税费，5%燃烧通缩，5%持币分红ARB，5%回流营销钱包

1、IUniswapV2Router02 路由合约接口代码：

interface IUniswapV2Router02 {
    function WETH() external pure returns (address);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}

2、IUniswapV2Factory工厂合约接口代码

interface IUniswapV2Factory {
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

3、业务主合约参数变量说明

string public name = "ARB";
    string public symbol = "ARB";
    uint8 public decimals = 18;
    uint256 public totalSupply = 1000000000 * 10**18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => bool) public isExcludedFromFee;
    uint256 public liquidityFee = 5;
    uint256 public marketingFee = 5;
    uint256 public totalFees = liquidityFee + marketingFee;
    uint256 public tokenPerEth = 1000;
    uint256 public totalLiquidity;
    address public marketingWallet = 0x123...;
    address public routerAddress = 0x456...;
    address public immutable uniswapV2Pair;
    IUniswapV2Router02 public immutable uniswapV2Router;
    bool public inSwapAndLiquify;
    bool public swapAndLiquifyEnabled = true;
    uint256 public maxTxAmount = 5000000 * 10**18;
    uint256 public numTokensSellToAddToLiquidity = 500000 * 10**18;
    uint256 private constant _MAX = ~uint256(0);
    uint256 private _rTotal = (_MAX - (_MAX % totalSupply));
    uint256 private _tTotal = (_MAX - (_MAX % totalSupply));
    mapping(address => uint256) private _rOwned;
    mapping(address => uint256) private _tOwned;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _isExcluded;
    address[] private _excluded;
    uint256 private _liquidityFee = liquidityFee * 10**18;
    uint256 private _previousLiquidityFee = _liquidityFee;
    uint256 private _marketingFee = marketingFee * 10**18;
    uint256 private _previousMarketingFee = _marketing

构造函数初始化

constructor () {
    balanceOf[msg.sender] = totalSupply;
    _rOwned[msg.sender] = _rTotal;
    
    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(routerAddress);
     // Create a uniswap pair for this new token
    address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
        .getPair(address(this), _uniswapV2Router.WETH());
    if(_uniswapV2Pair == address(0)){
        _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
    }
    uniswapV2Pair = _uniswapV2Pair;
    uniswapV2Router = _uniswapV2Router;
    isExcludedFromFee[owner()] = true;
    isExcludedFromFee[address(this)] = true;
    emit Transfer(address(0), msg.sender, totalSupply);
}

4、对应的_transfer函数代码如下：

function _transfer(address sender, address recipient, uint256 amount) private {
    require(sender != address(0), "ERC20: transfer from the zero address");
    require(recipient != address(0), "ERC20: transfer to the zero address");
    require(amount > 0, "Transfer amount must be greater than zero");

    if(sender != owner() && recipient != owner())
        require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");

    uint256 contractTokenBalance = balanceOf(address(this));
    bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
    
    if (!inSwapAndLiquify && swapAndLiquifyEnabled && recipient == uniswapV2Pair) {
        if (overMinTokenBalance) {
            contractTokenBalance = numTokensSellToAddToLiquidity;
            swapAndLiquify(contractTokenBalance);
        }
        uint256 balance = address(this).balance;
        if (buyBackEnabled && balance > uint256(1 * 10**18)) {
            if (balance > buyBackUpperLimit)
                balance = buyBackUpperLimit;

            buyBackTokens(balance.div(100));
        }
    }

    uint256 senderBalance = balanceOf(sender);
    require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
    uint256 tFee, tMarketing;
    if (!isExcludedFromFee[sender]) {
        (, tFee, tMarketing) = _getTValues(amount);
    }
    uint256 rAmount, rTransferAmount, rFee;
    if (isExcludedFromReward[sender] || isExcludedFromReward[recipient]) {
        (rAmount, rTransferAmount,,) = _getValues(amount);
    }

5、分红派发器根据用户持有本币数量权重，自动兑换本币交易手续费成ARB代币，空投到所有持币地址中，作为业务合约的子合约，需要优先部署并开源分红ARB派发器子合约，然后初始化到业务主合约中才能部署业务主合约。可以在业务主合约中预留分红派发器是set接口，也可以直接在构造函数初始化分红派发器子合约。派发器核心代码如下：

pragma solidity ^0.8.0;

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract ARBDividend {
    address public arbTokenAddress = 0x912CE59144191C1204E64559FE8253a0e49E6548;
    IERC20 public arbToken = IERC20(arbTokenAddress);
    mapping(address => uint256) public arbTokenHolders;
    uint256 public totalArbTokens;
    uint256 public totalDividends;

    event DistributeDividend(uint256 amount);

    function calculateDividend(address account) public view returns (uint256) {
        uint256 balance = arbToken.balanceOf(account);
        return balance * totalDividends / totalArbTokens;
    }

    function distributeDividend(uint256 amount) public {
        require(amount > 0, "Amount must be greater than zero");
        require(arbToken.balanceOf(address(this)) >= amount, "Insufficient balance");

        totalDividends += amount;

        // Distribute dividends to all ARB holders
        uint256 numHolders = 0;
        for (uint256 i = 0; i < totalArbTokens; i++) {
            address account = address(arbTokenHolders[i]);
            if (account != address(0)) {
                uint256 dividend = calculateDividend(account);
                arbToken.transfer(account, dividend);
                numHolders++;
            }
        }

        emit DistributeDividend(amount);
    }

    function addArbTokenHolder(address account) internal {
        bool exists = false;
        for (uint256 i = 0; i < totalArbTokens; i++) {
            if (address(arbTokenHolders[i]) == account) {
                exists = true;
                break;
            }
        }
        if (!exists) {
            arbTokenHolders[totalArbTokens++] = account;
        }
    }

    function removeArbTokenHolder(address account) internal {
        for (uint256 i = 0; i < totalArbTokens; i++) {
            if (address(arbTokenHolders[i]) == account) {
                arbTokenHolders[i] = address(0);
                break;
            }
        }
    }

    function depositArbTokens(uint256 amount) public {
        require(amount > 0, "Amount must be greater than zero");

        // Add ARB tokens to the contract
        arbToken.transferFrom(msg.sender, address(this), amount);

        // Update ARB token holder balances
        addArbTokenHolder(msg.sender);
        totalArbTokens += amount;
    }

    function withdrawArbTokens(uint256 amount) public {
        require(amount > 0, "Amount must be greater than zero");
        require(arbTokenHolders[msg.sender] >= amount, "Insufficient balance");

        // Remove ARB tokens from the contract
        arbToken.transfer(msg.sender, amount);

        // Update ARB token holder balances
        removeArbTokenHolder(msg.sender);
        totalArbTokens -= amount;
    }
}

这个合约在接收到ARBITRUM的ARB令牌后，会将令牌转移到该合约中，并维护持有令牌的地址和相应的余额。

三、完整版合约源代码如下

 

至此，完成Arbitrum（ARB）链上持币分红ARB合约代码部署及配置操作流程。

pdf+视频Arbitrum链发币教程及多模式组合合约源代码下载:

Arbitrum链发币(合约部署、开源、锁仓、LP、参数配置、开发、故障处理、工具使用)教程下载：

多模式（燃烧、回流指定营销地址、分红本币及任意币种，邀请推广八代收益，LP加池分红、交易分红、复利分红、NFT分红、自动筑池、动态手续费、定时开盘、回购）组合合约源代码下载：

pdf+视频Arbitrum链发币教程及多模式组合合约源代码下载地址：