Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.4 <0.9.0;

import {BytesLib} from "./bytes.sol";
import "./ERC20.sol";

contract FToken is ERC20 {
    constructor(
        string memory name,
        string memory symbol,
        uint256 cap,
        address minter
    ) ERC20(name, symbol) {
        // send all supply to minter
        _mint(minter, cap);
    }
}

contract FTokenFactory {
    using BytesLib for bytes;

    struct Token {
        string name;
        string symbol;
        uint256 cap;
        uint128 trace;
        address minter;
    }

    address public owner;
    address public receiver;
    mapping(address => Token) tokens;

    constructor(address _owner, address _receiver) {
        owner = _owner;
        receiver = _receiver;
    }

    function transferOwnership(address _owner) public {
        require(msg.sender == owner, "Only owner can transfer ownership");
        owner = _owner;
    }

    function setReceiverAddress(address _receiver) public {
        require(msg.sender == owner, "Only owner can update receiver address");
        receiver = _receiver;
    }

    function readToken(address _address) public view returns (Token memory) {
        return tokens[_address];
    }

    function createContract(
        string memory name,
        string memory symbol,
        uint256 cap,
        uint128 trace
    ) public {
        require(msg.sender == owner, "Only owner can create contracts");

        uint256 balance = cap * 10**18;
        FToken ftoken = new FToken(name, symbol, balance, address(this));
        ftoken.transfer(receiver, balance);

        Token memory token = Token({
            name: name,
            symbol: symbol,
            cap: cap,
            trace: trace,
            minter: receiver
        });
        tokens[address(ftoken)] = token;
    }

    function createContractRaw(bytes memory raw, uint128 trace) public {
        require(msg.sender == owner, "Only owner can create contracts");

        uint256 offset;
        uint8 size;
        string memory name;
        string memory symbol;
        uint256 cap;

        while (offset < raw.length) {
            size = raw.toUint8(offset);
            offset = offset + 1;
            require(
                size > 0 && offset + size <= raw.length,
                "invalid data: name size"
            );
            name = string(raw.slice(offset, size));
            offset = offset + size;

            size = raw.toUint8(offset);
            offset = offset + 1;
            require(
                size > 0 && offset + size <= raw.length,
                "invalid data: symbol size"
            );
            symbol = string(raw.slice(offset, size));
            offset = offset + size;

            require(offset + 8 <= raw.length, "invalid data: cap size");
            cap = raw.toUint64(offset);
            require(cap > 0, "invalid cap size");
            offset = offset + 8;

            createContract(name, symbol, cap, trace);
        }
    }
}

// SPDX-License-Identifier: Unlicense
/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity >=0.8.0 <0.9.0;

library BytesLib {
    function concat(bytes memory _preBytes, bytes memory _postBytes)
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(
                0x40,
                and(
                    add(add(end, iszero(add(length, mload(_preBytes)))), 31),
                    not(31) // Round down to the nearest 32 bytes.
                )
            )
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes)
        internal
    {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(
                and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)),
                2
            )
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    ) internal pure returns (bytes memory) {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(
                    add(tempBytes, lengthmod),
                    mul(0x20, iszero(lengthmod))
                )
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(
                        add(
                            add(_bytes, lengthmod),
                            mul(0x20, iszero(lengthmod))
                        ),
                        _start
                    )
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (address)
    {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(
                mload(add(add(_bytes, 0x20), _start)),
                0x1000000000000000000000000
            )
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint8)
    {
        require(_bytes.length >= _start + 1, "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint16)
    {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint32)
    {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toInt32(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (int32)
    {
        require(_bytes.length >= _start + 4, "toInt32_outOfBounds");
        int32 tempInt;

        assembly {
            tempInt := mload(add(add(_bytes, 0x4), _start))
        }

        return tempInt;
    }

    function toUint64(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint64)
    {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint96)
    {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint128)
    {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint256)
    {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (bytes32)
    {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes)
        internal
        pure
        returns (bool)
    {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                    // the next line is the loop condition:
                    // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(bytes storage _preBytes, bytes memory _postBytes)
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(
                and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)),
                2
            )
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {

                        } eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Context.sol";

/**
 * @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 {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @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;
    }

    /**
     * @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;
        }
        _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 {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";

/**
 * @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);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_receiver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"uint128","name":"trace","type":"uint128"}],"name":"createContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"raw","type":"bytes"},{"internalType":"uint128","name":"trace","type":"uint128"}],"name":"createContractRaw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"readToken","outputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"uint128","name":"trace","type":"uint128"},{"internalType":"address","name":"minter","type":"address"}],"internalType":"struct FTokenFactory.Token","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"receiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"}],"name":"setReceiverAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x60806040523480156200001157600080fd5b5060043610620000875760003560e01c80638fddced811620000625780638fddced814620000ed578063990ac85d1462000113578063f2fde38b146200012a578063f7260d3e146200014157600080fd5b80636adb3a13146200008c5780638279c7db14620000a55780638da5cb5b14620000bc575b600080fd5b620000a36200009d36600462000c76565b62000155565b005b620000a3620000b636600462000cfd565b62000374565b600054620000d0906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b62000104620000fe36600462000cfd565b62000401565b604051620000e4919062000d78565b620000a36200012436600462000df1565b620005d3565b620000a36200013b36600462000cfd565b62000886565b600154620000d0906001600160a01b031681565b6000546001600160a01b03163314620001b55760405162461bcd60e51b815260206004820152601f60248201527f4f6e6c79206f776e65722063616e2063726561746520636f6e7472616374730060448201526064015b60405180910390fd5b6000620001cb83670de0b6b3a764000062000e70565b9050600085858330604051620001e19062000ae8565b620001f0949392919062000e92565b604051809103906000f0801580156200020d573d6000803e3d6000fd5b5060015460405163a9059cbb60e01b81526001600160a01b0391821660048201526024810185905291925082169063a9059cbb906044016020604051808303816000875af115801562000264573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200028a919062000edd565b506040805160a08101825287815260208082018890528183018790526001600160801b03861660608301526001546001600160a01b0390811660808401528416600090815260028252929092208151805192938493620002ee928492019062000af6565b50602082810151805162000309926001850192019062000af6565b506040820151600282015560608201516003820180546fffffffffffffffffffffffffffffffff19166001600160801b03909216919091179055608090910151600490910180546001600160a01b0319166001600160a01b0390921691909117905550505050505050565b6000546001600160a01b03163314620003df5760405162461bcd60e51b815260206004820152602660248201527f4f6e6c79206f776e65722063616e20757064617465207265636569766572206160448201526564647265737360d01b6064820152608401620001ac565b600180546001600160a01b0319166001600160a01b0392909216919091179055565b620004466040518060a0016040528060608152602001606081526020016000815260200160006001600160801b0316815260200160006001600160a01b031681525090565b6001600160a01b03821660009081526002602052604090819020815160a081019092528054829082906200047a9062000f01565b80601f0160208091040260200160405190810160405280929190818152602001828054620004a89062000f01565b8015620004f95780601f10620004cd57610100808354040283529160200191620004f9565b820191906000526020600020905b815481529060010190602001808311620004db57829003601f168201915b50505050508152602001600182018054620005149062000f01565b80601f0160208091040260200160405190810160405280929190818152602001828054620005429062000f01565b8015620005935780601f10620005675761010080835404028352916020019162000593565b820191906000526020600020905b8154815290600101906020018083116200057557829003601f168201915b50505091835250506002820154602082015260038201546001600160801b031660408201526004909101546001600160a01b031660609091015292915050565b6000546001600160a01b031633146200062f5760405162461bcd60e51b815260206004820152601f60248201527f4f6e6c79206f776e65722063616e2063726561746520636f6e747261637473006044820152606401620001ac565b60008060608060005b86518510156200087d576200064e87866200090e565b93506200065d85600162000f3e565b945060008460ff1611801562000682575086516200067f60ff86168762000f3e565b11155b620006d05760405162461bcd60e51b815260206004820152601760248201527f696e76616c696420646174613a206e616d652073697a650000000000000000006044820152606401620001ac565b620006e0878660ff87166200096e565b9250620006f160ff85168662000f3e565b9450620006ff87866200090e565b93506200070e85600162000f3e565b945060008460ff1611801562000733575086516200073060ff86168762000f3e565b11155b620007815760405162461bcd60e51b815260206004820152601960248201527f696e76616c696420646174613a2073796d626f6c2073697a65000000000000006044820152606401620001ac565b62000791878660ff87166200096e565b9150620007a260ff85168662000f3e565b8751909550620007b486600862000f3e565b1115620007fd5760405162461bcd60e51b8152602060048201526016602482015275696e76616c696420646174613a206361702073697a6560501b6044820152606401620001ac565b62000809878662000a87565b67ffffffffffffffff169050600081116200085a5760405162461bcd60e51b815260206004820152601060248201526f696e76616c6964206361702073697a6560801b6044820152606401620001ac565b6200086785600862000f3e565b9450620008778383838962000155565b62000638565b50505050505050565b6000546001600160a01b03163314620008ec5760405162461bcd60e51b815260206004820152602160248201527f4f6e6c79206f776e65722063616e207472616e73666572206f776e65727368696044820152600760fc1b6064820152608401620001ac565b600080546001600160a01b0319166001600160a01b0392909216919091179055565b60006200091d82600162000f3e565b83511015620009655760405162461bcd60e51b8152602060048201526013602482015272746f55696e74385f6f75744f66426f756e647360681b6044820152606401620001ac565b50016001015190565b6060816200097e81601f62000f3e565b1015620009bf5760405162461bcd60e51b815260206004820152600e60248201526d736c6963655f6f766572666c6f7760901b6044820152606401620001ac565b620009cb828462000f3e565b8451101562000a115760405162461bcd60e51b8152602060048201526011602482015270736c6963655f6f75744f66426f756e647360781b6044820152606401620001ac565b60608215801562000a32576040519150600082526020820160405262000a7e565b6040519150601f8416801560200281840101858101878315602002848b0101015b8183101562000a6d57805183526020928301920162000a53565b5050858452601f01601f1916604052505b50949350505050565b600062000a9682600862000f3e565b8351101562000adf5760405162461bcd60e51b8152602060048201526014602482015273746f55696e7436345f6f75744f66426f756e647360601b6044820152606401620001ac565b50016008015190565b610caa8062000f5a83390190565b82805462000b049062000f01565b90600052602060002090601f01602090048101928262000b28576000855562000b73565b82601f1062000b4357805160ff191683800117855562000b73565b8280016001018555821562000b73579182015b8281111562000b7357825182559160200191906001019062000b56565b5062000b8192915062000b85565b5090565b5b8082111562000b81576000815560010162000b86565b634e487b7160e01b600052604160045260246000fd5b600067ffffffffffffffff8084111562000bd05762000bd062000b9c565b604051601f8501601f19908116603f0116810190828211818310171562000bfb5762000bfb62000b9c565b8160405280935085815286868601111562000c1557600080fd5b858560208301376000602087830101525050509392505050565b600082601f83011262000c4157600080fd5b62000c528383356020850162000bb2565b9392505050565b80356001600160801b038116811462000c7157600080fd5b919050565b6000806000806080858703121562000c8d57600080fd5b843567ffffffffffffffff8082111562000ca657600080fd5b62000cb48883890162000c2f565b9550602087013591508082111562000ccb57600080fd5b5062000cda8782880162000c2f565b9350506040850135915062000cf26060860162000c59565b905092959194509250565b60006020828403121562000d1057600080fd5b81356001600160a01b038116811462000c5257600080fd5b6000815180845260005b8181101562000d505760208185018101518683018201520162000d32565b8181111562000d63576000602083870101525b50601f01601f19169290920160200192915050565b602081526000825160a0602084015262000d9660c084018262000d28565b90506020840151601f1984830301604085015262000db5828262000d28565b915050604084015160608401526001600160801b03606085015116608084015260018060a01b0360808501511660a08401528091505092915050565b6000806040838503121562000e0557600080fd5b823567ffffffffffffffff81111562000e1d57600080fd5b8301601f8101851362000e2f57600080fd5b62000e408582356020840162000bb2565b92505062000e516020840162000c59565b90509250929050565b634e487b7160e01b600052601160045260246000fd5b600081600019048311821515161562000e8d5762000e8d62000e5a565b500290565b60808152600062000ea7608083018762000d28565b828103602084015262000ebb818762000d28565b604084019590955250506001600160a01b039190911660609091015292915050565b60006020828403121562000ef057600080fd5b8151801515811462000c5257600080fd5b600181811c9082168062000f1657607f821691505b6020821081141562000f3857634e487b7160e01b600052602260045260246000fd5b50919050565b6000821982111562000f545762000f5462000e5a565b50019056fe60806040523480156200001157600080fd5b5060405162000caa38038062000caa8339810160408190526200003491620002dd565b8351849084906200004d9060039060208501906200016a565b508051620000639060049060208401906200016a565b5050506200007881836200008260201b60201c565b50505050620003d6565b6001600160a01b038216620000dd5760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015260640160405180910390fd5b8060026000828254620000f1919062000372565b90915550506001600160a01b038216600090815260208190526040812080548392906200012090849062000372565b90915550506040518181526001600160a01b038316906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35050565b828054620001789062000399565b90600052602060002090601f0160209004810192826200019c5760008555620001e7565b82601f10620001b757805160ff1916838001178555620001e7565b82800160010185558215620001e7579182015b82811115620001e7578251825591602001919060010190620001ca565b50620001f5929150620001f9565b5090565b5b80821115620001f55760008155600101620001fa565b634e487b7160e01b600052604160045260246000fd5b600082601f8301126200023857600080fd5b81516001600160401b038082111562000255576200025562000210565b604051601f8301601f19908116603f0116810190828211818310171562000280576200028062000210565b816040528381526020925086838588010111156200029d57600080fd5b600091505b83821015620002c15785820183015181830184015290820190620002a2565b83821115620002d35760008385830101525b9695505050505050565b60008060008060808587031215620002f457600080fd5b84516001600160401b03808211156200030c57600080fd5b6200031a8883890162000226565b955060208701519150808211156200033157600080fd5b50620003408782880162000226565b60408701516060880151919550935090506001600160a01b03811681146200036757600080fd5b939692955090935050565b600082198211156200039457634e487b7160e01b600052601160045260246000fd5b500190565b600181811c90821680620003ae57607f821691505b60208210811415620003d057634e487b7160e01b600052602260045260246000fd5b50919050565b6108c480620003e66000396000f3fe608060405234801561001057600080fd5b50600436106100a95760003560e01c80633950935111610071578063395093511461012357806370a082311461013657806395d89b411461015f578063a457c2d714610167578063a9059cbb1461017a578063dd62ed3e1461018d57600080fd5b806306fdde03146100ae578063095ea7b3146100cc57806318160ddd146100ef57806323b872dd14610101578063313ce56714610114575b600080fd5b6100b66101c6565b6040516100c39190610701565b60405180910390f35b6100df6100da366004610772565b610258565b60405190151581526020016100c3565b6002545b6040519081526020016100c3565b6100df61010f36600461079c565b61026e565b604051601281526020016100c3565b6100df610131366004610772565b61031d565b6100f36101443660046107d8565b6001600160a01b031660009081526020819052604090205490565b6100b6610359565b6100df610175366004610772565b610368565b6100df610188366004610772565b610401565b6100f361019b3660046107fa565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b6060600380546101d59061082d565b80601f01602080910402602001604051908101604052809291908181526020018280546102019061082d565b801561024e5780601f106102235761010080835404028352916020019161024e565b820191906000526020600020905b81548152906001019060200180831161023157829003601f168201915b5050505050905090565b600061026533848461040e565b50600192915050565b600061027b848484610532565b6001600160a01b0384166000908152600160209081526040808320338452909152902054828110156103055760405162461bcd60e51b815260206004820152602860248201527f45524332303a207472616e7366657220616d6f756e74206578636565647320616044820152676c6c6f77616e636560c01b60648201526084015b60405180910390fd5b610312853385840361040e565b506001949350505050565b3360008181526001602090815260408083206001600160a01b03871684529091528120549091610265918590610354908690610868565b61040e565b6060600480546101d59061082d565b3360009081526001602090815260408083206001600160a01b0386168452909152812054828110156103ea5760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b60648201526084016102fc565b6103f7338585840361040e565b5060019392505050565b6000610265338484610532565b6001600160a01b0383166104705760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b60648201526084016102fc565b6001600160a01b0382166104d15760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b60648201526084016102fc565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b0383166105965760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b60648201526084016102fc565b6001600160a01b0382166105f85760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b60648201526084016102fc565b6001600160a01b038316600090815260208190526040902054818110156106705760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b60648201526084016102fc565b6001600160a01b038085166000908152602081905260408082208585039055918516815290812080548492906106a7908490610868565b92505081905550826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516106f391815260200190565b60405180910390a350505050565b600060208083528351808285015260005b8181101561072e57858101830151858201604001528201610712565b81811115610740576000604083870101525b50601f01601f1916929092016040019392505050565b80356001600160a01b038116811461076d57600080fd5b919050565b6000806040838503121561078557600080fd5b61078e83610756565b946020939093013593505050565b6000806000606084860312156107b157600080fd5b6107ba84610756565b92506107c860208501610756565b9150604084013590509250925092565b6000602082840312156107ea57600080fd5b6107f382610756565b9392505050565b6000806040838503121561080d57600080fd5b61081683610756565b915061082460208401610756565b90509250929050565b600181811c9082168061084157607f821691505b6020821081141561086257634e487b7160e01b600052602260045260246000fd5b50919050565b6000821982111561088957634e487b7160e01b600052601160045260246000fd5b50019056fea2646970667358221220f80fc16f9595cf92202b2388b4e79e50bb7c6b55975697edd7462cfd5106c94264736f6c634300080c0033a26469706673582212204e47d05b18ceca6fe9971613ef928c989205ba2125efa629d9bb43c95f1e19a164736f6c634300080c0033

00000000000000000000000026aa9980242bd09a7353149acda8c845c08e2cd0000000000000000000000000d6ce6c804ec06711670118999b300fedf5aa082a

-----Decoded View---------------
Arg [0] : _owner (address): 0x26AA9980242bD09a7353149acdA8c845C08E2cd0
Arg [1] : _receiver (address): 0xD6ce6C804Ec06711670118999b300FeDF5aA082a

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000026aa9980242bd09a7353149acda8c845c08e2cd0
Arg [1] : 000000000000000000000000d6ce6c804ec06711670118999b300fedf5aa082a

374:2638:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1237:598;;;;;;:::i;:::-;;:::i;:::-;;942:171;;;;;;:::i;:::-;;:::i;572:20::-;;;;;-1:-1:-1;;;;;572:20:5;;;;;;-1:-1:-1;;;;;2349:32:6;;;2331:51;;2319:2;2304:18;572:20:5;;;;;;;;1119:112;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1841:1169::-;;;;;;:::i;:::-;;:::i;780:156::-;;;;;;:::i;:::-;;:::i;598:23::-;;;;;-1:-1:-1;;;;;598:23:5;;;1237:598;1408:5;;-1:-1:-1;;;;;1408:5:5;1394:10;:19;1386:63;;;;-1:-1:-1;;;1386:63:5;;4413:2:6;1386:63:5;;;4395:21:6;4452:2;4432:18;;;4425:30;4491:33;4471:18;;;4464:61;4542:18;;1386:63:5;;;;;;;;;1460:15;1478:12;:3;1484:6;1478:12;:::i;:::-;1460:30;;1500:13;1527:4;1533:6;1541:7;1558:4;1516:48;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1590:8:5;;1574:34;;-1:-1:-1;;;1574:34:5;;-1:-1:-1;;;;;1590:8:5;;;1574:34;;;5608:51:6;5675:18;;;5668:34;;;1500:64:5;;-1:-1:-1;1574:15:5;;;;;5581:18:6;;1574:34:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;1640:147:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1640:147:5;;;;;;1768:8;;-1:-1:-1;;;;;1768:8:5;;;1640:147;;;;1797:23;;1619:18;1797:23;;;:6;:23;;;;;;:31;;;;1640:147;;;;1797:31;;:23;;:31;;;:::i;:::-;-1:-1:-1;1797:31:5;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;1797:31:5;;;;;;;;;;;;;;;;;-1:-1:-1;;1797:31:5;-1:-1:-1;;;;;1797:31:5;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;1797:31:5;-1:-1:-1;;;;;1797:31:5;;;;;;;;;-1:-1:-1;;;;;;;1237:598:5:o;942:171::-;1028:5;;-1:-1:-1;;;;;1028:5:5;1014:10;:19;1006:70;;;;-1:-1:-1;;;1006:70:5;;6197:2:6;1006:70:5;;;6179:21:6;6236:2;6216:18;;;6209:30;6275:34;6255:18;;;6248:62;-1:-1:-1;;;6326:18:6;;;6319:36;6372:19;;1006:70:5;5995:402:6;1006:70:5;1086:8;:20;;-1:-1:-1;;;;;;1086:20:5;-1:-1:-1;;;;;1086:20:5;;;;;;;;;;942:171::o;1119:112::-;1177:12;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1177:12:5;-1:-1:-1;;;;;1208:16:5;;;;;;:6;:16;;;;;;;1201:23;;;;;;;;;;;;1208:16;;1201:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1201:23:5;;;-1:-1:-1;;1201:23:5;;;;;;;;;;;;-1:-1:-1;;;;;1201:23:5;;;;;;;;;;-1:-1:-1;;;;;1201:23:5;;;;;;;1119:112;-1:-1:-1;;1119:112:5:o;1841:1169::-;1940:5;;-1:-1:-1;;;;;1940:5:5;1926:10;:19;1918:63;;;;-1:-1:-1;;;1918:63:5;;4413:2:6;1918:63:5;;;4395:21:6;4452:2;4432:18;;;4425:30;4491:33;4471:18;;;4464:61;4542:18;;1918:63:5;4211:355:6;1918:63:5;1992:14;2016:10;2036:18;2064:20;2094:11;2116:888;2132:3;:10;2123:6;:19;2116:888;;;2165:19;:3;2177:6;2165:11;:19::i;:::-;2158:26;-1:-1:-1;2207:10:5;:6;2216:1;2207:10;:::i;:::-;2198:19;;2263:1;2256:4;:8;;;:39;;;;-1:-1:-1;2285:10:5;;2268:13;;;;:6;:13;:::i;:::-;:27;;2256:39;2231:121;;;;-1:-1:-1;;;2231:121:5;;7122:2:6;2231:121:5;;;7104:21:6;7161:2;7141:18;;;7134:30;7200:25;7180:18;;;7173:53;7243:18;;2231:121:5;6920:347:6;2231:121:5;2380:23;:3;2390:6;2380:23;;;:9;:23::i;:::-;2366:38;-1:-1:-1;2427:13:5;;;;:6;:13;:::i;:::-;2418:22;-1:-1:-1;2462:19:5;:3;2418:22;2462:11;:19::i;:::-;2455:26;-1:-1:-1;2504:10:5;:6;2513:1;2504:10;:::i;:::-;2495:19;;2560:1;2553:4;:8;;;:39;;;;-1:-1:-1;2582:10:5;;2565:13;;;;:6;:13;:::i;:::-;:27;;2553:39;2528:123;;;;-1:-1:-1;;;2528:123:5;;7474:2:6;2528:123:5;;;7456:21:6;7513:2;7493:18;;;7486:30;7552:27;7532:18;;;7525:55;7597:18;;2528:123:5;7272:349:6;2528:123:5;2681:23;:3;2691:6;2681:23;;;:9;:23::i;:::-;2665:40;-1:-1:-1;2728:13:5;;;;:6;:13;:::i;:::-;2778:10;;2719:22;;-1:-1:-1;2764:10:5;2719:22;2773:1;2764:10;:::i;:::-;:24;;2756:59;;;;-1:-1:-1;;;2756:59:5;;7828:2:6;2756:59:5;;;7810:21:6;7867:2;7847:18;;;7840:30;-1:-1:-1;;;7886:18:6;;;7879:52;7948:18;;2756:59:5;7626:346:6;2756:59:5;2835:20;:3;2848:6;2835:12;:20::i;:::-;2829:26;;;;2883:1;2877:3;:7;2869:36;;;;-1:-1:-1;;;2869:36:5;;8179:2:6;2869:36:5;;;8161:21:6;8218:2;8198:18;;;8191:30;-1:-1:-1;;;8237:18:6;;;8230:46;8293:18;;2869:36:5;7977:340:6;2869:36:5;2928:10;:6;2937:1;2928:10;:::i;:::-;2919:19;;2953:40;2968:4;2974:6;2982:3;2987:5;2953:14;:40::i;:::-;2116:888;;;1908:1102;;;;;1841:1169;;:::o;780:156::-;862:5;;-1:-1:-1;;;;;862:5:5;848:10;:19;840:65;;;;-1:-1:-1;;;840:65:5;;8524:2:6;840:65:5;;;8506:21:6;8563:2;8543:18;;;8536:30;8602:34;8582:18;;;8575:62;-1:-1:-1;;;8653:18:6;;;8646:31;8694:19;;840:65:5;8322:397:6;840:65:5;915:5;:14;;-1:-1:-1;;;;;;915:14:5;-1:-1:-1;;;;;915:14:5;;;;;;;;;;780:156::o;12980:329:4:-;13081:5;13127:10;:6;13136:1;13127:10;:::i;:::-;13110:6;:13;:27;;13102:59;;;;-1:-1:-1;;;13102:59:4;;8926:2:6;13102:59:4;;;8908:21:6;8965:2;8945:18;;;8938:30;-1:-1:-1;;;8984:18:6;;;8977:49;9043:18;;13102:59:4;8724:343:6;13102:59:4;-1:-1:-1;13237:29:4;13253:3;13237:29;13231:36;;12980:329::o;9554:2986::-;9676:12;9724:7;9708:12;9724:7;9718:2;9708:12;:::i;:::-;:23;;9700:50;;;;-1:-1:-1;;;9700:50:4;;9274:2:6;9700:50:4;;;9256:21:6;9313:2;9293:18;;;9286:30;-1:-1:-1;;;9332:18:6;;;9325:44;9386:18;;9700:50:4;9072:338:6;9700:50:4;9785:16;9794:7;9785:6;:16;:::i;:::-;9768:6;:13;:33;;9760:63;;;;-1:-1:-1;;;9760:63:4;;9617:2:6;9760:63:4;;;9599:21:6;9656:2;9636:18;;;9629:30;-1:-1:-1;;;9675:18:6;;;9668:47;9732:18;;9760:63:4;9415:341:6;9760:63:4;9834:22;9897:15;;9925:2177;;;;12243:4;12237:11;12224:24;;12429:1;12418:9;12411:20;12477:4;12466:9;12462:20;12456:4;12449:34;9890:2607;;9925:2177;10107:4;10101:11;10088:24;;10766:2;10757:7;10753:16;11189:9;11182:17;11176:4;11172:28;11140:9;11129;11125:25;11100:118;11254:7;11250:2;11246:16;11637:6;11574:9;11567:17;11561:4;11557:28;11517:9;11509:6;11505:22;11472:139;11443:222;11280:577;11691:3;11687:2;11684:11;11280:577;;;11829:9;;11818:21;;11732:4;11724:13;;;;11764;11280:577;;;-1:-1:-1;;11875:26:4;;;12083:2;12066:11;-1:-1:-1;;12062:25:4;12056:4;12049:39;-1:-1:-1;9890:2607:4;-1:-1:-1;12524:9:4;9554:2986;-1:-1:-1;;;;9554:2986:4:o;14325:333::-;14427:6;14474:10;:6;14483:1;14474:10;:::i;:::-;14457:6;:13;:27;;14449:60;;;;-1:-1:-1;;;14449:60:4;;9963:2:6;14449:60:4;;;9945:21:6;10002:2;9982:18;;;9975:30;-1:-1:-1;;;10021:18:6;;;10014:50;10081:18;;14449:60:4;9761:344:6;14449:60:4;-1:-1:-1;14586:29:4;14602:3;14586:29;14580:36;;14325:333::o;-1:-1:-1:-;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:127:6;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:632;211:5;241:18;282:2;274:6;271:14;268:40;;;288:18;;:::i;:::-;363:2;357:9;331:2;417:15;;-1:-1:-1;;413:24:6;;;439:2;409:33;405:42;393:55;;;463:18;;;483:22;;;460:46;457:72;;;509:18;;:::i;:::-;549:10;545:2;538:22;578:6;569:15;;608:6;600;593:22;648:3;639:6;634:3;630:16;627:25;624:45;;;665:1;662;655:12;624:45;715:6;710:3;703:4;695:6;691:17;678:44;770:1;763:4;754:6;746;742:19;738:30;731:41;;;;146:632;;;;;:::o;783:222::-;826:5;879:3;872:4;864:6;860:17;856:27;846:55;;897:1;894;887:12;846:55;919:80;995:3;986:6;973:20;966:4;958:6;954:17;919:80;:::i;:::-;910:89;783:222;-1:-1:-1;;;783:222:6:o;1010:188::-;1078:20;;-1:-1:-1;;;;;1127:46:6;;1117:57;;1107:85;;1188:1;1185;1178:12;1107:85;1010:188;;;:::o;1203:686::-;1309:6;1317;1325;1333;1386:3;1374:9;1365:7;1361:23;1357:33;1354:53;;;1403:1;1400;1393:12;1354:53;1443:9;1430:23;1472:18;1513:2;1505:6;1502:14;1499:34;;;1529:1;1526;1519:12;1499:34;1552:50;1594:7;1585:6;1574:9;1570:22;1552:50;:::i;:::-;1542:60;;1655:2;1644:9;1640:18;1627:32;1611:48;;1684:2;1674:8;1671:16;1668:36;;;1700:1;1697;1690:12;1668:36;;1723:52;1767:7;1756:8;1745:9;1741:24;1723:52;:::i;:::-;1713:62;;;1822:2;1811:9;1807:18;1794:32;1784:42;;1845:38;1879:2;1868:9;1864:18;1845:38;:::i;:::-;1835:48;;1203:686;;;;;;;:::o;1894:286::-;1953:6;2006:2;1994:9;1985:7;1981:23;1977:32;1974:52;;;2022:1;2019;2012:12;1974:52;2048:23;;-1:-1:-1;;;;;2100:31:6;;2090:42;;2080:70;;2146:1;2143;2136:12;2393:472;2435:3;2473:5;2467:12;2500:6;2495:3;2488:19;2525:1;2535:162;2549:6;2546:1;2543:13;2535:162;;;2611:4;2667:13;;;2663:22;;2657:29;2639:11;;;2635:20;;2628:59;2564:12;2535:162;;;2715:6;2712:1;2709:13;2706:87;;;2781:1;2774:4;2765:6;2760:3;2756:16;2752:27;2745:38;2706:87;-1:-1:-1;2847:2:6;2826:15;-1:-1:-1;;2822:29:6;2813:39;;;;2854:4;2809:50;;2393:472;-1:-1:-1;;2393:472:6:o;2870:803::-;3045:2;3034:9;3027:21;3008:4;3083:6;3077:13;3126:4;3121:2;3110:9;3106:18;3099:32;3154:52;3201:3;3190:9;3186:19;3172:12;3154:52;:::i;:::-;3140:66;;3255:2;3247:6;3243:15;3237:22;3327:2;3323:7;3311:9;3303:6;3299:22;3295:36;3290:2;3279:9;3275:18;3268:64;3355:41;3389:6;3373:14;3355:41;:::i;:::-;3341:55;;;3450:2;3442:6;3438:15;3432:22;3427:2;3416:9;3412:18;3405:50;-1:-1:-1;;;;;3514:2:6;3506:6;3502:15;3496:22;3492:63;3486:3;3475:9;3471:19;3464:92;3640:1;3636;3631:3;3627:11;3623:19;3616:3;3608:6;3604:16;3598:23;3594:49;3587:4;3576:9;3572:20;3565:79;3661:6;3653:14;;;2870:803;;;;:::o;3678:528::-;3755:6;3763;3816:2;3804:9;3795:7;3791:23;3787:32;3784:52;;;3832:1;3829;3822:12;3784:52;3872:9;3859:23;3905:18;3897:6;3894:30;3891:50;;;3937:1;3934;3927:12;3891:50;3960:22;;4013:4;4005:13;;4001:27;-1:-1:-1;3991:55:6;;4042:1;4039;4032:12;3991:55;4065:76;4133:7;4128:2;4115:16;4108:4;4104:2;4100:13;4065:76;:::i;:::-;4055:86;;;4160:40;4194:4;4183:9;4179:20;4160:40;:::i;:::-;4150:50;;3678:528;;;;;:::o;4571:127::-;4632:10;4627:3;4623:20;4620:1;4613:31;4663:4;4660:1;4653:15;4687:4;4684:1;4677:15;4703:168;4743:7;4809:1;4805;4801:6;4797:14;4794:1;4791:21;4786:1;4779:9;4772:17;4768:45;4765:71;;;4816:18;;:::i;:::-;-1:-1:-1;4856:9:6;;4703:168::o;4876:553::-;5129:3;5118:9;5111:22;5092:4;5156:46;5197:3;5186:9;5182:19;5174:6;5156:46;:::i;:::-;5250:9;5242:6;5238:22;5233:2;5222:9;5218:18;5211:50;5278:33;5304:6;5296;5278:33;:::i;:::-;5342:2;5327:18;;5320:34;;;;-1:-1:-1;;;;;;;5390:32:6;;;;5385:2;5370:18;;;5363:60;5270:41;4876:553;-1:-1:-1;;4876:553:6:o;5713:277::-;5780:6;5833:2;5821:9;5812:7;5808:23;5804:32;5801:52;;;5849:1;5846;5839:12;5801:52;5881:9;5875:16;5934:5;5927:13;5920:21;5913:5;5910:32;5900:60;;5956:1;5953;5946:12;6402:380;6481:1;6477:12;;;;6524;;;6545:61;;6599:4;6591:6;6587:17;6577:27;;6545:61;6652:2;6644:6;6641:14;6621:18;6618:38;6615:161;;;6698:10;6693:3;6689:20;6686:1;6679:31;6733:4;6730:1;6723:15;6761:4;6758:1;6751:15;6615:161;;6402:380;;;:::o;6787:128::-;6827:3;6858:1;6854:6;6851:1;6848:13;6845:39;;;6864:18;;:::i;:::-;-1:-1:-1;6900:9:6;;6787:128::o

ipfs://4e47d05b18ceca6fe9971613ef928c989205ba2125efa629d9bb43c95f1e19a1