Token Bee Trade Finance

Overview ERC20

Price
$0.00 @ 0.000000 AVAX
Fully Diluted Market Cap
Total Supply:
1,079,999,999.999999 BTF

Holders:
74 addresses
Filtered by Token Holder (Bee Trade Finance: Deployer)

Balance
1,079.999999999999998921 BTF

Value
$0.00
0xa9a02aa338ddbd7ffd952799ba006c45cc651bf3
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

Bee Trade Finance Network is a fully decentralized peer-to-peer hybrid cryptocurrency exchange for the Avalanche DeFi ecosystem built on EVM.


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
BTFToken

Compiler Version
v0.8.0+commit.c7dfd78e

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-02-25
*/

/**
 *Submitted for verification at snowtrace.io on 2021-12-21
*/

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.3.2 (utils/math/SafeMath.sol)

pragma solidity 0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.3.2 (utils/Context.sol)

pragma solidity 0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/IERC20.sol)

pragma solidity 0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity 0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/ERC20.sol)

pragma solidity 0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    using SafeMath for uint256;
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    // custom variables added
    uint256 BURN_FEE = 1;
    uint256 TOTAL_BURNED = 0;
    uint256 TOTAL_BURN_LIMIT = 324000000000000000000000000;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * returns total burnt
     */
    function totalBurnt() public view virtual returns (uint256) {
        return TOTAL_BURNED;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }

        // check if the TOTAL_BURNT LIMIT HAS REACHED
        if(TOTAL_BURNED >= TOTAL_BURN_LIMIT){
            _balances[recipient] += amount;
            emit Transfer(sender, recipient, amount);
        } else {
            // calculate the amount to be burnt
            uint256 burnAmount = amount.mul(BURN_FEE) / 1000000000000000000000000;
            // burn the tokens
            _burn(_msgSender(), burnAmount);
            // add the burnt amount to the total amount burnt
            TOTAL_BURNED = TOTAL_BURNED.add(burnAmount);
            
            _balances[recipient] += amount;

            emit Transfer(sender, recipient, amount);
        }

        

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        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);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity 0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/presets/ERC20PresetFixedSupply.sol)
pragma solidity 0.8.0;


/**
 * @dev {ERC20} token, including:
 *
 *  - Preminted initial supply
 *  - Ability for holders to burn (destroy) their tokens
 *  - No access control mechanism (for minting/pausing) and hence no governance
 *
 * This contract uses {ERC20Burnable} to include burn capabilities - head to
 * its documentation for details.
 *
 * _Available since v3.4._
 *
 * _Deprecated in favor of https://wizard.openzeppelin.com/[Contracts Wizard]._
 */
contract ERC20PresetFixedSupply is ERC20Burnable {
    /**
     * @dev Mints `initialSupply` amount of token and transfers them to `owner`.
     *
     * See {ERC20-constructor}.
     */
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply,
        address owner
    ) ERC20(name, symbol) {
        _mint(owner, initialSupply);
    }
}

// File: contracts/BTF.sol

pragma solidity 0.8.0;



contract BTFToken is ERC20 {
    constructor() ERC20("Bee Trade Finance", "BTF") {
        _mint(msg.sender, 1080000000000000000000000000);
    }  
}

Contract Security Audit

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBurnt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

27483:153:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14198:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16517:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15318:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17168:492;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15160:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18069:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15641:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14417:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15480:98;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18787:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15981:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16219:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14198:100;14252:13;14285:5;14278:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14198:100;:::o;16517:169::-;16600:4;16617:39;16626:12;:10;:12::i;:::-;16640:7;16649:6;16617:8;:39::i;:::-;16674:4;16667:11;;16517:169;;;;:::o;15318:108::-;15379:7;15406:12;;15399:19;;15318:108;:::o;17168:492::-;17308:4;17325:36;17335:6;17343:9;17354:6;17325:9;:36::i;:::-;17374:24;17401:11;:19;17413:6;17401:19;;;;;;;;;;;;;;;:33;17421:12;:10;:12::i;:::-;17401:33;;;;;;;;;;;;;;;;17374:60;;17473:6;17453:16;:26;;17445:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;17560:57;17569:6;17577:12;:10;:12::i;:::-;17610:6;17591:16;:25;17560:8;:57::i;:::-;17648:4;17641:11;;;17168:492;;;;;:::o;15160:93::-;15218:5;15243:2;15236:9;;15160:93;:::o;18069:215::-;18157:4;18174:80;18183:12;:10;:12::i;:::-;18197:7;18243:10;18206:11;:25;18218:12;:10;:12::i;:::-;18206:25;;;;;;;;;;;;;;;:34;18232:7;18206:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;18174:8;:80::i;:::-;18272:4;18265:11;;18069:215;;;;:::o;15641:127::-;15715:7;15742:9;:18;15752:7;15742:18;;;;;;;;;;;;;;;;15735:25;;15641:127;;;:::o;14417:104::-;14473:13;14506:7;14499:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14417:104;:::o;15480:98::-;15531:7;15558:12;;15551:19;;15480:98;:::o;18787:413::-;18880:4;18897:24;18924:11;:25;18936:12;:10;:12::i;:::-;18924:25;;;;;;;;;;;;;;;:34;18950:7;18924:34;;;;;;;;;;;;;;;;18897:61;;18997:15;18977:16;:35;;18969:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;19090:67;19099:12;:10;:12::i;:::-;19113:7;19141:15;19122:16;:34;19090:8;:67::i;:::-;19188:4;19181:11;;;18787:413;;;;:::o;15981:175::-;16067:4;16084:42;16094:12;:10;:12::i;:::-;16108:9;16119:6;16084:9;:42::i;:::-;16144:4;16137:11;;15981:175;;;;:::o;16219:151::-;16308:7;16335:11;:18;16347:5;16335:18;;;;;;;;;;;;;;;:27;16354:7;16335:27;;;;;;;;;;;;;;;;16328:34;;16219:151;;;;:::o;7881:98::-;7934:7;7961:10;7954:17;;7881:98;:::o;23070:380::-;23223:1;23206:19;;:5;:19;;;;23198:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;23304:1;23285:21;;:7;:21;;;;23277:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;23388:6;23358:11;:18;23370:5;23358:18;;;;;;;;;;;;;;;:27;23377:7;23358:27;;;;;;;;;;;;;;;:36;;;;23426:7;23410:32;;23419:5;23410:32;;;23435:6;23410:32;;;;;;:::i;:::-;;;;;;;;23070:380;;;:::o;19690:1332::-;19848:1;19830:20;;:6;:20;;;;19822:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;19932:1;19911:23;;:9;:23;;;;19903:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;19987:47;20008:6;20016:9;20027:6;19987:20;:47::i;:::-;20047:21;20071:9;:17;20081:6;20071:17;;;;;;;;;;;;;;;;20047:41;;20124:6;20107:13;:23;;20099:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;20245:6;20229:13;:22;20209:9;:17;20219:6;20209:17;;;;;;;;;;;;;;;:42;;;;20349:16;;20333:12;;:32;20330:614;;20405:6;20381:9;:20;20391:9;20381:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;20448:9;20431:35;;20440:6;20431:35;;;20459:6;20431:35;;;;;;:::i;:::-;;;;;;;;20330:614;;;20548:18;20592:25;20569:20;20580:8;;20569:6;:10;;:20;;;;:::i;:::-;:48;;;;:::i;:::-;20548:69;;20664:31;20670:12;:10;:12::i;:::-;20684:10;20664:5;:31::i;:::-;20788:28;20805:10;20788:12;;:16;;:28;;;;:::i;:::-;20773:12;:43;;;;20869:6;20845:9;:20;20855:9;20845:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;20914:9;20897:35;;20906:6;20897:35;;;20925:6;20897:35;;;;;;:::i;:::-;;;;;;;;20330:614;;20968:46;20988:6;20996:9;21007:6;20968:19;:46::i;:::-;19690:1332;;;;:::o;24050:125::-;;;;:::o;3723:98::-;3781:7;3812:1;3808;:5;;;;:::i;:::-;3801:12;;3723:98;;;;:::o;22041:591::-;22144:1;22125:21;;:7;:21;;;;22117:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;22197:49;22218:7;22235:1;22239:6;22197:20;:49::i;:::-;22259:22;22284:9;:18;22294:7;22284:18;;;;;;;;;;;;;;;;22259:43;;22339:6;22321:14;:24;;22313:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;22458:6;22441:14;:23;22420:9;:18;22430:7;22420:18;;;;;;;;;;;;;;;:44;;;;22502:6;22486:12;;:22;;;;;;;:::i;:::-;;;;;;;;22552:1;22526:37;;22535:7;22526:37;;;22556:6;22526:37;;;;;;:::i;:::-;;;;;;;;22576:48;22596:7;22613:1;22617:6;22576:19;:48::i;:::-;22041:591;;;:::o;2985:98::-;3043:7;3074:1;3070;:5;;;;:::i;:::-;3063:12;;2985:98;;;;:::o;24779:124::-;;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:139::-;;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;204:87;;;;:::o;297:262::-;;405:2;393:9;384:7;380:23;376:32;373:2;;;421:1;418;411:12;373:2;464:1;489:53;534:7;525:6;514:9;510:22;489:53;:::i;:::-;479:63;;435:117;363:196;;;;:::o;565:407::-;;;690:2;678:9;669:7;665:23;661:32;658:2;;;706:1;703;696:12;658:2;749:1;774:53;819:7;810:6;799:9;795:22;774:53;:::i;:::-;764:63;;720:117;876:2;902:53;947:7;938:6;927:9;923:22;902:53;:::i;:::-;892:63;;847:118;648:324;;;;;:::o;978:552::-;;;;1120:2;1108:9;1099:7;1095:23;1091:32;1088:2;;;1136:1;1133;1126:12;1088:2;1179:1;1204:53;1249:7;1240:6;1229:9;1225:22;1204:53;:::i;:::-;1194:63;;1150:117;1306:2;1332:53;1377:7;1368:6;1357:9;1353:22;1332:53;:::i;:::-;1322:63;;1277:118;1434:2;1460:53;1505:7;1496:6;1485:9;1481:22;1460:53;:::i;:::-;1450:63;;1405:118;1078:452;;;;;:::o;1536:407::-;;;1661:2;1649:9;1640:7;1636:23;1632:32;1629:2;;;1677:1;1674;1667:12;1629:2;1720:1;1745:53;1790:7;1781:6;1770:9;1766:22;1745:53;:::i;:::-;1735:63;;1691:117;1847:2;1873:53;1918:7;1909:6;1898:9;1894:22;1873:53;:::i;:::-;1863:63;;1818:118;1619:324;;;;;:::o;1949:109::-;2030:21;2045:5;2030:21;:::i;:::-;2025:3;2018:34;2008:50;;:::o;2064:364::-;;2180:39;2213:5;2180:39;:::i;:::-;2235:71;2299:6;2294:3;2235:71;:::i;:::-;2228:78;;2315:52;2360:6;2355:3;2348:4;2341:5;2337:16;2315:52;:::i;:::-;2392:29;2414:6;2392:29;:::i;:::-;2387:3;2383:39;2376:46;;2156:272;;;;;:::o;2434:367::-;;2597:67;2661:2;2656:3;2597:67;:::i;:::-;2590:74;;2694:34;2690:1;2685:3;2681:11;2674:55;2760:5;2755:2;2750:3;2746:12;2739:27;2792:2;2787:3;2783:12;2776:19;;2580:221;;;:::o;2807:366::-;;2970:67;3034:2;3029:3;2970:67;:::i;:::-;2963:74;;3067:34;3063:1;3058:3;3054:11;3047:55;3133:4;3128:2;3123:3;3119:12;3112:26;3164:2;3159:3;3155:12;3148:19;;2953:220;;;:::o;3179:366::-;;3342:67;3406:2;3401:3;3342:67;:::i;:::-;3335:74;;3439:34;3435:1;3430:3;3426:11;3419:55;3505:4;3500:2;3495:3;3491:12;3484:26;3536:2;3531:3;3527:12;3520:19;;3325:220;;;:::o;3551:370::-;;3714:67;3778:2;3773:3;3714:67;:::i;:::-;3707:74;;3811:34;3807:1;3802:3;3798:11;3791:55;3877:8;3872:2;3867:3;3863:12;3856:30;3912:2;3907:3;3903:12;3896:19;;3697:224;;;:::o;3927:372::-;;4090:67;4154:2;4149:3;4090:67;:::i;:::-;4083:74;;4187:34;4183:1;4178:3;4174:11;4167:55;4253:10;4248:2;4243:3;4239:12;4232:32;4290:2;4285:3;4281:12;4274:19;;4073:226;;;:::o;4305:365::-;;4468:67;4532:2;4527:3;4468:67;:::i;:::-;4461:74;;4565:34;4561:1;4556:3;4552:11;4545:55;4631:3;4626:2;4621:3;4617:12;4610:25;4661:2;4656:3;4652:12;4645:19;;4451:219;;;:::o;4676:369::-;;4839:67;4903:2;4898:3;4839:67;:::i;:::-;4832:74;;4936:34;4932:1;4927:3;4923:11;4916:55;5002:7;4997:2;4992:3;4988:12;4981:29;5036:2;5031:3;5027:12;5020:19;;4822:223;;;:::o;5051:368::-;;5214:67;5278:2;5273:3;5214:67;:::i;:::-;5207:74;;5311:34;5307:1;5302:3;5298:11;5291:55;5377:6;5372:2;5367:3;5363:12;5356:28;5410:2;5405:3;5401:12;5394:19;;5197:222;;;:::o;5425:369::-;;5588:67;5652:2;5647:3;5588:67;:::i;:::-;5581:74;;5685:34;5681:1;5676:3;5672:11;5665:55;5751:7;5746:2;5741:3;5737:12;5730:29;5785:2;5780:3;5776:12;5769:19;;5571:223;;;:::o;5800:118::-;5887:24;5905:5;5887:24;:::i;:::-;5882:3;5875:37;5865:53;;:::o;5924:112::-;6007:22;6023:5;6007:22;:::i;:::-;6002:3;5995:35;5985:51;;:::o;6042:210::-;;6167:2;6156:9;6152:18;6144:26;;6180:65;6242:1;6231:9;6227:17;6218:6;6180:65;:::i;:::-;6134:118;;;;:::o;6258:313::-;;6409:2;6398:9;6394:18;6386:26;;6458:9;6452:4;6448:20;6444:1;6433:9;6429:17;6422:47;6486:78;6559:4;6550:6;6486:78;:::i;:::-;6478:86;;6376:195;;;;:::o;6577:419::-;;6781:2;6770:9;6766:18;6758:26;;6830:9;6824:4;6820:20;6816:1;6805:9;6801:17;6794:47;6858:131;6984:4;6858:131;:::i;:::-;6850:139;;6748:248;;;:::o;7002:419::-;;7206:2;7195:9;7191:18;7183:26;;7255:9;7249:4;7245:20;7241:1;7230:9;7226:17;7219:47;7283:131;7409:4;7283:131;:::i;:::-;7275:139;;7173:248;;;:::o;7427:419::-;;7631:2;7620:9;7616:18;7608:26;;7680:9;7674:4;7670:20;7666:1;7655:9;7651:17;7644:47;7708:131;7834:4;7708:131;:::i;:::-;7700:139;;7598:248;;;:::o;7852:419::-;;8056:2;8045:9;8041:18;8033:26;;8105:9;8099:4;8095:20;8091:1;8080:9;8076:17;8069:47;8133:131;8259:4;8133:131;:::i;:::-;8125:139;;8023:248;;;:::o;8277:419::-;;8481:2;8470:9;8466:18;8458:26;;8530:9;8524:4;8520:20;8516:1;8505:9;8501:17;8494:47;8558:131;8684:4;8558:131;:::i;:::-;8550:139;;8448:248;;;:::o;8702:419::-;;8906:2;8895:9;8891:18;8883:26;;8955:9;8949:4;8945:20;8941:1;8930:9;8926:17;8919:47;8983:131;9109:4;8983:131;:::i;:::-;8975:139;;8873:248;;;:::o;9127:419::-;;9331:2;9320:9;9316:18;9308:26;;9380:9;9374:4;9370:20;9366:1;9355:9;9351:17;9344:47;9408:131;9534:4;9408:131;:::i;:::-;9400:139;;9298:248;;;:::o;9552:419::-;;9756:2;9745:9;9741:18;9733:26;;9805:9;9799:4;9795:20;9791:1;9780:9;9776:17;9769:47;9833:131;9959:4;9833:131;:::i;:::-;9825:139;;9723:248;;;:::o;9977:419::-;;10181:2;10170:9;10166:18;10158:26;;10230:9;10224:4;10220:20;10216:1;10205:9;10201:17;10194:47;10258:131;10384:4;10258:131;:::i;:::-;10250:139;;10148:248;;;:::o;10402:222::-;;10533:2;10522:9;10518:18;10510:26;;10546:71;10614:1;10603:9;10599:17;10590:6;10546:71;:::i;:::-;10500:124;;;;:::o;10630:214::-;;10757:2;10746:9;10742:18;10734:26;;10770:67;10834:1;10823:9;10819:17;10810:6;10770:67;:::i;:::-;10724:120;;;;:::o;10850:99::-;;10936:5;10930:12;10920:22;;10909:40;;;:::o;10955:169::-;;11073:6;11068:3;11061:19;11113:4;11108:3;11104:14;11089:29;;11051:73;;;;:::o;11130:305::-;;11189:20;11207:1;11189:20;:::i;:::-;11184:25;;11223:20;11241:1;11223:20;:::i;:::-;11218:25;;11377:1;11309:66;11305:74;11302:1;11299:81;11296:2;;;11383:18;;:::i;:::-;11296:2;11427:1;11424;11420:9;11413:16;;11174:261;;;;:::o;11441:185::-;;11498:20;11516:1;11498:20;:::i;:::-;11493:25;;11532:20;11550:1;11532:20;:::i;:::-;11527:25;;11571:1;11561:2;;11576:18;;:::i;:::-;11561:2;11618:1;11615;11611:9;11606:14;;11483:143;;;;:::o;11632:348::-;;11695:20;11713:1;11695:20;:::i;:::-;11690:25;;11729:20;11747:1;11729:20;:::i;:::-;11724:25;;11917:1;11849:66;11845:74;11842:1;11839:81;11834:1;11827:9;11820:17;11816:105;11813:2;;;11924:18;;:::i;:::-;11813:2;11972:1;11969;11965:9;11954:20;;11680:300;;;;:::o;11986:191::-;;12046:20;12064:1;12046:20;:::i;:::-;12041:25;;12080:20;12098:1;12080:20;:::i;:::-;12075:25;;12119:1;12116;12113:8;12110:2;;;12124:18;;:::i;:::-;12110:2;12169:1;12166;12162:9;12154:17;;12031:146;;;;:::o;12183:96::-;;12249:24;12267:5;12249:24;:::i;:::-;12238:35;;12228:51;;;:::o;12285:90::-;;12362:5;12355:13;12348:21;12337:32;;12327:48;;;:::o;12381:126::-;;12458:42;12451:5;12447:54;12436:65;;12426:81;;;:::o;12513:77::-;;12579:5;12568:16;;12558:32;;;:::o;12596:86::-;;12671:4;12664:5;12660:16;12649:27;;12639:43;;;:::o;12688:307::-;12756:1;12766:113;12780:6;12777:1;12774:13;12766:113;;;12865:1;12860:3;12856:11;12850:18;12846:1;12841:3;12837:11;12830:39;12802:2;12799:1;12795:10;12790:15;;12766:113;;;12897:6;12894:1;12891:13;12888:2;;;12977:1;12968:6;12963:3;12959:16;12952:27;12888:2;12737:258;;;;:::o;13001:320::-;;13082:1;13076:4;13072:12;13062:22;;13129:1;13123:4;13119:12;13150:18;13140:2;;13206:4;13198:6;13194:17;13184:27;;13140:2;13268;13260:6;13257:14;13237:18;13234:38;13231:2;;;13287:18;;:::i;:::-;13231:2;13052:269;;;;:::o;13327:180::-;13375:77;13372:1;13365:88;13472:4;13469:1;13462:15;13496:4;13493:1;13486:15;13513:180;13561:77;13558:1;13551:88;13658:4;13655:1;13648:15;13682:4;13679:1;13672:15;13699:180;13747:77;13744:1;13737:88;13844:4;13841:1;13834:15;13868:4;13865:1;13858:15;13885:102;;13977:2;13973:7;13968:2;13961:5;13957:14;13953:28;13943:38;;13933:54;;;:::o;13993:122::-;14066:24;14084:5;14066:24;:::i;:::-;14059:5;14056:35;14046:2;;14105:1;14102;14095:12;14046:2;14036:79;:::o;14121:122::-;14194:24;14212:5;14194:24;:::i;:::-;14187:5;14184:35;14174:2;;14233:1;14230;14223:12;14174:2;14164:79;:::o

Swarm Source

ipfs://68cc3c5fa31f1b1332577df9d7da3529bf1e4eb59200b2983002add5dcc0d474
Loading