Updates:

Had a call with Sultan and he will share a workflow proposal.

With some help from our bot friends:

To automatically distribute non-transferrable ERC20 token $sweat when making payments to contributors in $TDF tokens, you will need to create a smart contract that handles the distribution. Here's a high-level overview of the steps involved:

1. Create the $sweat token as an ERC20 token. Set the total supply to 0 so that no $sweat tokens are initially available.
2. Create the smart contract that handles the distribution of $sweat tokens. The contract should have functions for receiving $TDF tokens as payment and distributing an equal amount of $sweat tokens to the contributor's wallet.
3. In the smart contract, you will need to define the exchange rate between $TDF and $sweat tokens. For example, if 1 $TDF token is worth 1 $sweat token, then the exchange rate would be 1:1.
4. When a contributor sends $TDF tokens to the smart contract, the contract should calculate the amount of $sweat tokens that should be distributed based on the exchange rate. The contract should then transfer the calculated amount of $sweat tokens from the contract's wallet to the contributor's wallet.
5. To make $sweat tokens non-transferrable, you will need to include a "transfer restriction" in the smart contract. This can be done by defining a whitelist of wallet addresses that are allowed to receive $sweat tokens. When distributing $sweat tokens, the contract should check that the recipient's wallet address is on the whitelist before transferring the tokens.
6. Finally, you will need to ensure that the smart contract is properly funded with $sweat tokens so that it can distribute them to contributors. This can be done by transferring $sweat tokens to the contract's wallet from a designated wallet address.

Overall, creating a smart contract to automatically distribute non-transferrable ERC20 token $sweat when making payments to contributors in $TDF tokens is a feasible approach. However, you will need to have a good understanding of smart contract development and ERC20 tokens to implement this solution effectively.

Sample contract

pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract SweatToken {
	IERC20 public tdfToken;
	IERC20 public sweatToken;
	uint public sweatPerTDF;

	constructor(IERC20 _tdfToken, IERC20 _sweatToken, uint _sweatPerTDF) {
		tdfToken = _tdfToken;
		sweatToken = _sweatToken;
		sweatPerTDF = _sweatPerTDF;
	}
	function distributeSweat() public {
		uint tdfBalance = tdfToken.balanceOf(msg.sender);
		require(tdfBalance >= sweatPerTDF, "Not enough TDF tokens");
		uint sweatAmount = tdfBalance / sweatPerTDF;
		require(sweatToken.balanceOf(address(this)) >= sweatAmount, "Not enough sweat tokens");
		tdfToken.transferFrom(msg.sender, address(this), tdfBalance);
		sweatToken.transfer(msg.sender, sweatAmount);
	}
}