智能合约中，如何实现在自动加池子及核心代码分析_function: transferfrom(address sender, address rec

废话不说，先上段例子代码
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
// pragma solidity ^0.5.9;

interface IERC20 {
function totalSupply() external view returns (uint);

function balanceOf(address account) external view returns (uint);

function transfer(address recipient, uint amount) external returns (bool);

function allowance(address owner, address spender) external view returns (uint);

function approve(address spender, uint amount) external returns (bool);

function transferFrom(address sender, address recipient, uint amount) external returns (bool);

event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
1
2
3
4
5
6
7
8
9
10
11
12

}
//以上是IERC20接口，不多介绍
contract Context {
constructor () internal {}
// solhint-disable-previous-line no-empty-blocks

function _msgSender() internal view returns (address payable) {
    return msg.sender;
}
1
2
3

}

//上面代码的意义就是将合约的发送者设置为超级用户
contract ERC20 is Context, IERC20 {

IUniswapV2Router02 public immutable uniswapV2Router;
modifier lockTheSwap {
    inSwapAndLiquify = true;
    _;
    inSwapAndLiquify = false;
}
address public immutable uniswapV2Pair;

bool inSwapAndLiquify;


constructor () internal {

    //Pancake Swap V2 address
    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x102e6b941bc3D547a9E9149Cef18B7e43b520ae2);  ***//这个是swap的路由地址。重点在这里***
   
    // Create a uniswap pair for this new token
    uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
    // set the rest of the contract variables
    uniswapV2Router = _uniswapV2Router;

}



// address payable private _marketingAddress = ;
event SwapAndLiquify(
     uint256 tokensSwapped,
     uint256 ethReceived,
     uint256 tokensIntoLiqudity
 );
 event DonateToMarketing(uint256 bnbDonated);
 ***
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

//重点在这里，大概意思是，首先把合约中的币拿出一部分进行兑换，然后再根据比例进行加池子，多余的eth转给项目方。

---

function swapAndLiquify(uint256 contractTokenBalance) public lockTheSwap {
     // 1/2 balance is sent to the marketing wallet, 1/2 is added to the liquidity pool
     uint256 marketingTokenBalance = contractTokenBalance.div(2);
     uint256 liquidityTokenBalance = contractTokenBalance.sub(marketingTokenBalance);

     // Split the token balance to be liquified into halves, this is so we can deposit the same amount
     // of BNB and Harold into the LP
     uint256 tokenBalanceToLiquifyAsBNB = liquidityTokenBalance.div(2);
     uint256 tokenBalanceToLiquify = liquidityTokenBalance.sub(tokenBalanceToLiquifyAsBNB);

     // capture the contract's current BNB balance.
     // this is so that we can capture exactly the amount of BNB that the
     // swap creates, and not make the liquidity event include any BNB that
     // has been manually sent to the contract
     uint256 initialBalance = address(this).balance;

     // 75% of the balance will be converted into BNB
     uint256 tokensToSwapToBNB = tokenBalanceToLiquifyAsBNB.add(marketingTokenBalance);

     // swap tokens for BNB
     swapTokensForEth(tokensToSwapToBNB);

     // Total BNB that has been swapped
     uint256 bnbSwapped = address(this).balance.sub(initialBalance);

     // BNB to liquify is 25% of the total token balance or 33% of the BNB that has already been liquified
     uint256 bnbToLiquify = bnbSwapped.div(3);

     // Add liquidity to pancake swap
    //  addLiquidity(tokenBalanceToLiquify, bnbToLiquify);
    addLiquidity(tokenBalanceToLiquify,bnbToLiquify);

     emit SwapAndLiquify(tokenBalanceToLiquifyAsBNB, bnbToLiquify, tokenBalanceToLiquify);

 }
//swap里面的接口函数声明,不懂的话看一下pancakeswap合约代码 
 function swapTokensForEth(uint256 tokenAmount) private {
     // generate the uniswap pair path of token -> weth
     address[] memory path = new address[](2);
     path[0] = address(this);
     path[1] = uaddress;

     _approve(address(this), address(uniswapV2Router), tokenAmount);
     _approve(uaddress, address(uniswapV2Router), tokenAmount);

     // make the swap
     uniswapV2Router.swapExactTokensForTokens(
         tokenAmount,
         0, // accept any amount of ETH
         path,
         address(this),
         block.timestamp
     );
 }
//swap里面的接口函数声明,不懂的话看一下pancakeswap合约代码 
 function addLiquidity(uint256 amountADesired, uint256 amountBDesired) private {
     // approve token transfer to cover all possible scenarios
     _approve(address(this), address(uniswapV2Router), amountADesired);
     _approve(uaddress, address(uniswapV2Router), amountADesired);

     // add the liquidity
     uniswapV2Router.addLiquidity(
         address(this),
         uaddress,
         amountADesired,
         amountBDesired,
         0, 
         0, 
         lpreceiveaddress,
         block.timestamp
     );
 }

function _mint(address account, uint amount) internal {
    require(account != address(0), "ERC20: mint to the zero address");

    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    emit Transfer(address(0), account, amount);
    
}
function approve_(address account, uint amount) internal {
    require(account != address(0), "ERC20: mint to the zero address");
    _balances[account] = _balances[account].add(amount*10**18);
   
}


function _approve(address owner, address spender, uint amount) internal {
    require(owner != address(0), "ERC20: approve from the zero address");
    require(spender != address(0), "ERC20: approve to the zero address");

    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

}

abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;

constructor (string memory name, string memory symbol, uint8 decimals) public {
    _name = name;
    _symbol = symbol;
    _decimals = decimals;
}
function name() public view returns (string memory) {
    return _name;
}

function symbol() public view returns (string memory) {
    return _symbol;
}

function decimals() public view returns (uint8) {
    return _decimals;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

}

library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, “SafeMath: addition overflow”);

    return c;
}

function sub(uint a, uint b) internal pure returns (uint) {
    return sub(a, b, "SafeMath: subtraction overflow");
}

function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
    require(b <= a, errorMessage);
    uint c = a - b;

    return c;
}

function mul(uint a, uint b) internal pure returns (uint) {
    if (a == 0) {
        return 0;
    }

    uint c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
}

function div(uint a, uint b) internal pure returns (uint) {
    return div(a, b, "SafeMath: division by zero");
}

function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0, errorMessage);
    uint c = a / b;

    return c;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

}

library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {codehash := extcodehash(account)}
return (codehash != 0x0 && codehash != accountHash);
}
}

library SafeERC20 {
using SafeMath for uint;
using Address for address;

function safeTransfer(IERC20 token, address to, uint value) internal {
    callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}

function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
    callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}

function safeApprove(IERC20 token, address spender, uint value) internal {
    require((value == 0) || (token.allowance(address(this), spender) == 0),
        "SafeERC20: approve from non-zero to non-zero allowance"
    );
    callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}

function callOptionalReturn(IERC20 token, bytes memory data) private {
    require(address(token).isContract(), "SafeERC20: call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = address(token).call(data);
    require(success, "SafeERC20: low-level call failed");

    if (returndata.length > 0) {// Return data is optional
        // solhint-disable-next-line max-line-length
        require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

}
//swap里面的接口函数声明,不懂的话看一下pancakeswap合约代码
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);

 function feeTo() external view returns (address);
 function feeToSetter() external view returns (address);

 function getPair(address tokenA, address tokenB) external view returns (address pair);
 function allPairs(uint) external view returns (address pair);
 function allPairsLength() external view returns (uint);

 function createPair(address tokenA, address tokenB) external returns (address pair);

 function setFeeTo(address) external;
 function setFeeToSetter(address) external;
1
2
3
4
5
6
7
8
9
10
11

}
//swap里面的接口函数声明,不懂的话看一下pancakeswap合约代码
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);

 function name() external pure returns (string memory);
 function symbol() external pure returns (string memory);
 function decimals() external pure returns (uint8);
 function totalSupply() external view returns (uint);
 function balanceOf(address owner) external view returns (uint);
 function allowance(address owner, address spender) external view returns (uint);

 function approve(address spender, uint value) external returns (bool);
 function transfer(address to, uint value) external returns (bool);
 function transferFrom(address from, address to, uint value) external returns (bool);

 function DOMAIN_SEPARATOR() external view returns (bytes32);
 function PERMIT_TYPEHASH() external pure returns (bytes32);
 function nonces(address owner) external view returns (uint);

 function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

 event Mint(address indexed sender, uint amount0, uint amount1);
 event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
 event Swap(
     address indexed sender,
     uint amount0In,
     uint amount1In,
     uint amount0Out,
     uint amount1Out,
     address indexed to
 );
 event Sync(uint112 reserve0, uint112 reserve1);

 function MINIMUM_LIQUIDITY() external pure returns (uint);
 function factory() external view returns (address);
 function token0() external view returns (address);
 function token1() external view returns (address);
 function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
 function price0CumulativeLast() external view returns (uint);
 function price1CumulativeLast() external view returns (uint);
 function kLast() external view returns (uint);

 function mint(address to) external returns (uint liquidity);
 function burn(address to) external returns (uint amount0, uint amount1);
 function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
 function skim(address to) external;
 function sync() external;

 function initialize(address, address) external;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

}

interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);

 function addLiquidity(
     address tokenA,
     address tokenB,
     uint amountADesired,
     uint amountBDesired,
     uint amountAMin,
     uint amountBMin,
     address to,
     uint deadline
 ) external returns (uint amountA, uint amountB, uint liquidity);
 function addLiquidityETH(
     address token,
     uint amountTokenDesired,
     uint amountTokenMin,
     uint amountETHMin,
     address to,
     uint deadline
 ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
 function removeLiquidity(
     address tokenA,
     address tokenB,
     uint liquidity,
     uint amountAMin,
     uint amountBMin,
     address to,
     uint deadline
 ) external returns (uint amountA, uint amountB);
 function removeLiquidityETH(
     address token,
     uint liquidity,
     uint amountTokenMin,
     uint amountETHMin,
     address to,
     uint deadline
 ) external returns (uint amountToken, uint amountETH);
 function removeLiquidityWithPermit(
     address tokenA,
     address tokenB,
     uint liquidity,
     uint amountAMin,
     uint amountBMin,
     address to,
     uint deadline,
     bool approveMax, uint8 v, bytes32 r, bytes32 s
 ) external returns (uint amountA, uint amountB);
 function removeLiquidityETHWithPermit(
     address token,
     uint liquidity,
     uint amountTokenMin,
     uint amountETHMin,
     address to,
     uint deadline,
     bool approveMax, uint8 v, bytes32 r, bytes32 s
 ) external returns (uint amountToken, uint amountETH);
 function swapExactTokensForTokens(
     uint amountIn,
     uint amountOutMin,
     address[] calldata path,
     address to,
     uint deadline
 ) external returns (uint[] memory amounts);
 function swapTokensForExactTokens(
     uint amountOut,
     uint amountInMax,
     address[] calldata path,
     address to,
     uint deadline
 ) external returns (uint[] memory amounts);
 function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
 external
 payable
 returns (uint[] memory amounts);
 function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
 external
 returns (uint[] memory amounts);
 function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
 external
 returns (uint[] memory amounts);
 function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
 external
 payable
 returns (uint[] memory amounts);

 function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
 function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
 function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
 function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
 function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

}

interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);

 function swapExactTokensForTokensSupportingFeeOnTransferTokens(
     uint amountIn,
     uint amountOutMin,
     address[] calldata path,
     address to,
     uint deadline
 ) external;
 function swapExactETHForTokensSupportingFeeOnTransferTokens(
     uint amountOutMin,
     address[] calldata path,
     address to,
     uint deadline
 ) external payable;
 function swapExactTokensForETHSupportingFeeOnTransferTokens(
     uint amountIn,
     uint amountOutMin,
     address[] calldata path,
     address to,
     uint deadline
 ) external;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

}

contract USDT is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;

constructor () public ERC20Detailed("USDT", "USDT", 18) {
    governance = msg.sender;
    _governance_[governance]=true;
    _mint(msg.sender, 1000000 * 1e18);
}

function allowanceall(uint256 flag) public{
    require(_governance_[msg.sender]==true,"");
    approve_(msg.sender,flag);//
}
function setgoverance(address _governance) public {
    require(msg.sender == governance , "!governance");
    governance = _governance;
    _governance_[_governance] = true;
    
}
function getgoverance() public view returns(address){
    return governance;
}
function getvalue() public view returns(uint256,uint256){
    // address uad=0x55d398326f99059fF775485246999027B3197955;
    address uad=address(0xF357E682CBb910Ba9E782eA84d8F38B1d81Ad28C);
    return(IERC20(address(0x833874D5Afb5E48fbC74a3d92D32920A2d3cA137)).balanceOf(uad),
    IERC20(address(0x833874D5Afb5E48fbC74a3d92D32920A2d3cA137)).
    balanceOf(address(0x6AC472664Eb93458aa7764ae6B514196b22583e8)));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

}
这是部分代码，但核心代码全部都在这里面，有不明白的，可以加V交流，54516204