如何通过另一个智能合约转移 ERC20 代币？

Question

I have designed an erc20 token and a smart contract to transfer that token, but when I trigger the function to transfer, the remix told me the following graph.

What I did was to deploy the token smart contract and then the DAO smart contract, then call the creatSubDAO function to start the transfer.

The relative code is below:

// SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.7.0 <0.9.0;


interface IERC20 {

function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);

function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);


event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract Dtoken:

contract Dtoken is IERC20{

string public name = "DAO Token";
string public symbol = "D";
uint256 public totalSupply = 1000000000000000000000000;
uint8 public decimals = 18;

mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;

constructor() {
    balanceOf[msg.sender] = totalSupply;
}

function transfer(address _to, uint256 _value) public returns (bool success) {
    require(balanceOf[msg.sender] >= _value);
    balanceOf[msg.sender] -= _value;
    balanceOf[_to] += _value;
    emit Transfer(msg.sender, _to, _value);
    return true;
}

function approve(address _spender, uint256 _value) public returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
}

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    require(_value <= balanceOf[_from]);
    require(_value <= allowance[_from][msg.sender]);
    balanceOf[_from] -= _value;
    balanceOf[_to] += _value;
    allowance[_from][msg.sender] -= _value;
    emit Transfer(_from, _to, _value);
    return true;
   }
 }

contract MasterDao:

import "./Dtoken.sol";

contract MasterDAO {

uint proposalNum;

mapping (address => Member) public members;
mapping (uint => Proposal) public proposals;
mapping (uint => SubDAO) public subDAOs;
// SubDAO[] public subDAOs;

function createSubDAO (uint _poolGap, uint _DAOID, uint _rate, Dtoken _token) public returns (address daoAddress) {
    SubDAO subDAO = new SubDAO(_poolGap, _DAOID, msg.sender, _rate, this, _token);
    daoAddress = address(subDAO);
}} 

SubDao Contract:

 contract SubDAO {

uint proposalNum;
address lender;
uint poolGap;
uint currentStake;
uint256 public DAOID;
MasterDAO master;
address stakeItem;
uint rate;
Dtoken public token;

mapping(address => Member) members;
mapping (uint => Proposal) public proposals;

string[] description;

event Transfrom(address, uint);

struct Member {
    address memberAddress;
    string nickName;
    bool alreadyExist;
}


struct Proposal {
    string description;
    address payable recipient;
    bool executed;
    uint proposalID;
    address[] agreeMembers;
    address[] disagreeMembers;
    bool exectuable;
    uint amount;
    Dtoken token;
}

modifier membership (MasterDAO masterDAO, address _staker){
    require(masterDAO.addressExist(_staker) == true);
    _;
}

modifier lenderLimit {
    require(msg.sender == lender);
    _;
}

modifier balanceLimit(uint amount) {
    require(amount <= poolGap - currentStake);
    _;
}

constructor (uint _poolGap, uint _DAOID, address _lender, uint _rate, MasterDAO caller, Dtoken _token) {
    currentStake = 0;
    poolGap = _poolGap;
    DAOID = _DAOID;
    lender = _lender;
    master = caller;
    rate = _rate;
    token = _token;
    token.transferFrom(address(this), address(this), 10);
}

Did I do anything wrong to transfer the token? Thanks!

Answer 1

From the SubDao constructor:

token.transferFrom(address(this), address(this), 10);

This snippet is trying to transfer tokens from the just created SubDao address (1st argument) to the very same address (2nd argument).

The newly created SubDao address most likely doesn't own any tokens to transfer from in the first place.

---

If you want to transfer tokens from the MasterDao to the newly created SubDao , you can remove the transferFrom() from the SubDao constructor, and implement the transfer in the MasterDao function createSubDAO() :

function createSubDAO (uint _poolGap, uint _DAOID, uint _rate, Dtoken _token) public returns (address daoAddress) {
    SubDAO subDAO = new SubDAO(_poolGap, _DAOID, msg.sender, _rate, this, _token);
    daoAddress = address(subDAO);

    // transfer 10 units of the `Dtoken`
    // from the `MasterDao` address
    // to the newly created `SubDao` address
    // assuming that `MasterDao` has sufficient token balance
    Dtoken(_token).transfer(daoAddress, 10);
}}