How to send ERC20 token to smart contract balance?

Question

I'm trying to build a smart contract and inherit some functions to swap ERC20 tokens,

Here are my questions?

Question A: Is it possible to transfer ERC20 token to smart contract balance?, Please provide an example, i.e. We can create a function to send ETH to smart contract

function contribute() external payable {}

//It will allow us to send ETH to smart contract balance,but how to send,for example, "BAND" token
//to smart contract balance?

Question B: If A is possible, how to get contract's token balance? i.e. We can get the contract ETH balance from this function:

// Get ETH balance
function getBalance() external view returns(uint) {
    return address(this).balance;    
}

// How to return contract's BAND balance, if A is possible ...

Question C:

If "A" is possible, How to make a swap to BAND/ETH liquidity pool, using Uniswap or Sushiswap API, Is it better to handle that process on server side proccesses using NodeJS, or implement it in solidity?

---

Full smart contract code:

pragma solidity ^0.5.11; 

contract SwapTest {
    address public manager;
    
    constructor() public {
        manager = msg.sender;
    }
    
    modifier OnlyManager() {
        require(msg.sender == manager);
        _;
    }
    
    // Add funds to contract
    function contribute() external payable {}
    
    
    // Get ETH balance
    function getBalance() external view returns(uint) {
        return address(this).balance;    
    } 
    
    // Send provided amount of WEI to recipient
    function sendEther (address payable recipient, uint weiAmount) external OnlyManager{
        recipient.transfer(weiAmount);    
    }
    
    // Send contract balance to recipient
    function withdrawBalance (address payable recipient) external OnlyManager{
        recipient.transfer(address(this).balance);
    }
}

Looking forward to hearing back from you guys, Thanks in advance.

Answer 1

When dealing with external contracts first include an interface definition, so you can call the contract's functions.

interface ERC20 {
  function balanceOf(address owner) external view returns (unit);
  function allowance(address owner, address spender) external view returns (unit);
  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); 
}

A: Tokens can be transferred directly to the contract's address, no additional functions need to be specified. Although, depending on your use case you can also write a function that will transfer tokens to itself.

function transferToMe(address _owner, address _token, unit _amount) public {
  ERC20(_token).transferFrom(_owner, address(this), _amount);
}

B: You can use this:

function getBalanceOfToken(address _address) public view returns (unit) {
  return ERC20(_address).balanceOf(address(this));
}

C: If you need your contract to be able to swap tokens you need to include the corresponding functions. Please refer to the Uniswap or Sushiswap documentation as they describe this in-depth.