How to operate USDT on the main chain in an external contract

When I first come into contact with the USDT main chain contract, I will always think about how to use the contract to operate the assets of my wallet.

Please read below

Specifically, it's a simple question

Because this is actually the use of the solidity interface

In Solidity, interfaces are abstract contracts that define the external behavior of the contract without providing any implementation details. Interfaces allow interoperability between contracts, similar to interfaces or abstract classes in other programming languages.

Define an interface as follows:

// 定义一个简单的接口
interface MyInterface {
    
    
    function myFunction() external;
}

Implement interfaces: A contract can implement one or more interfaces by using the contract keyword and the is keyword after the contract name.

// 实现上述接口的合约
contract MyContract is MyInterface {
    
    
    function myFunction() external {
    
    
        // 实现接口中定义的函数
    }
}

Inheritance between interfaces: Interfaces can also inherit other interfaces, using the interface keyword and is keyword.

// 定义另一个接口，继承MyInterface
interface AnotherInterface is MyInterface {
    
    
    function anotherFunction() external;
}

Using interfaces in contracts: Contracts can be declared using interface types and implement the functions defined in the interface.

contract MyContract is AnotherInterface {
    
    
    function myFunction() external {
    
    
        // 实现MyInterface中的函数
    }

    function anotherFunction() external {
    
    
        // 实现AnotherInterface中的函数
    }
}

Interaction between external contracts and interfaces: Interfaces can be used to declare the type of external contracts and call functions in external contracts through the interface

contract CallerContract {
    
    
    MyInterface public myContractInstance;

    constructor(address _myContractAddress) {
    
    
        myContractInstance = MyInterface(_myContractAddress);
    }

    function callMyFunction() external {
    
    
        myContractInstance.myFunction();
    }
}

By using interfaces, standardization and interoperability between contracts can be achieved, making the system more modular and easier to maintain.

The following explains how to use the interactive function of its external contract and interface to realize the call of TRC20-USDT.

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

// TRC-20 USDT 合约接口
interface ITRC20 {
    
    
    function transfer(address to, uint256 value) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

// 主合约
contract MainContract {
    
    
    // TRC-20 USDT 合约地址
    address public usdtContractAddress = 0x1234567890123456789012345678901234567890;

    // TRC-20 USDT 合约接口变量
    ITRC20 public usdtContract;

    // 构造函数
    constructor() {
    
    
        // 创建 TRC-20 USDT 合约接口实例
        usdtContract = ITRC20(usdtContractAddress);
    }

    // 转账 USDT
    function transferUSDT(address to, uint256 amount) external {
    
    
        // 调用 TRC-20 USDT 合约的 transfer 方法
        bool success = usdtContract.transfer(to, amount);
        // 处理转账结果
        // ...
    }

    // 获取账户 USDT 余额
    function getUSDTBalance(address account) external view returns (uint256) {
    
    
        // 调用 TRC-20 USDT 合约的 balanceOf 方法
        return usdtContract.balanceOf(account);
    }
}