Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
• library SafeMath
•    - function tryAdd(
•    - function trySub(
•    - function tryMul(
•    - function tryDiv(
•    - function tryMod(
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(
• functionCallWithValue(
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(
• functionStaticCall(
•    - function functionStaticCall(
•    - function functionDelegateCall(
• functionDelegateCall(
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(
• library Strings
•    - function toUpperCase(
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface PAXGOLD
•    - function feeRate()
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(
•    - function transfer(
•    - function allowance(
•    - function approve(
•    - function transferFrom(
•    - function increaseAllowance(
•    - function decreaseAllowance(
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _spendAllowance(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•  contract AuriumToken is ERC20, Ree ...
•    - function calculateReceivedPaxg(
•    - function getAuriumTokenAmountsOut(
•    - function getPaxgAmountsOut(
•    - function _updateValue()
•    - function mint(uint256 _value)
•    - function burn(uint256 _value)
•    - function transfer(
•    - function transferFrom(
•    - function getDetails()
•  contract AuriumTokenFactory is Ree ... *
•    - function createAuriumToken(
•    - function getMinPaxgDeposit()
•    - function getAuriumTokenCount()
•    - function getAuriumTokenAddressFromInd ...
•    - function getAuriumTokenDataFromAddres ...
•    - function convertToUpperCase(

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-06-12
*/

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

abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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 subtraction 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;
        }
    }
}

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                0,
                "Address: low-level call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data
    ) internal view returns (bytes memory) {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(
        bytes memory returndata,
        string memory errorMessage
    ) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

library Strings {
    function toUpperCase(
        string memory _str
    ) public pure returns (string memory) {
        bytes memory bStr = bytes(_str);
        bytes memory bUpper = new bytes(bStr.length);
        for (uint i = 0; i < bStr.length; i++) {
            // Uppercase the letter if it's a lowercase letter
            if ((bStr[i] >= 0x61) && (bStr[i] <= 0x7A)) {
                bUpper[i] = bytes1(uint8(bStr[i]) - 32);
            } else {
                bUpper[i] = bStr[i];
            }
        }
        return string(bUpper);
    }
}

interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

interface IERC20 {
    /**
     * @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
    );

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

interface PAXGOLD {
    function feeRate() external view returns (uint256);
}

library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    newAllowance
                )
            );
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(
            nonceAfter == nonceBefore + 1,
            "SafeERC20: permit did not succeed"
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

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);
}

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:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, 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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(
            fromBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, 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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: insufficient allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - 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 {}
}

/**
 * @title AuriumToken
 * @dev AuriumToken is an ERC20 token that is backed by Pax Gold (PAXG).
 *The value of the token is derived from the amount of PAXG in the reserve.
 *AuriumToken can be minted and burned by depositing and withdrawing PAXG from the reserve.
 *A small percentage of each transfer is burned, decreasing the total supply and increasing the value of each token.
 */
contract AuriumToken is ERC20, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    uint256 public totalReserve_; // Total amount of PAXG in the reserve
    uint256 private immutable initialSupply_;
    uint256 public value_; // The value of each token, expressed in PAXG
    uint256 public constant burnFee_ = 5; // 0.5% burn rate (in basis points)
    uint256 private _maxBurnFee = 1e18; // Max burn fee (1 Paxg)
    uint256 public constant MULTIPLIER = 1000; //basis points
    IERC20 public paxGold_; // The PAXG contract
    address public immutable auriumTokenFactoryAddr_; //auriumToken Factory Address
    uint256 public constant PRECISION_FACTOR = 1e18; //Precison factor for value calculations
    uint256 public lastValue_; //The last value recorded
    // uint256 public paxGoldFee; //Get transfer fee from PaxGold
    uint256 public constant PAXGOLD_FEE_PARTS = 1000000; //Get paxGoldFeeParts

    event AuriumTokenMinted(
        address indexed tokenAddress,
        string name,
        string symbol,
        address indexed account,
        uint256 value
    );
    event AuriumTokenBurned(
        address indexed tokenAddress,
        string name,
        string symbol,
        address indexed account,
        uint256 value
    );
    event maxBurnFeeAlert(address sender, uint256 amount, uint256 maxBurnFee);

    /**

    @dev Constructor for AuriumToken contract

    @param _paxGold The address of the PAXG contract

    @param _initialDeposit The initial amount of PAXG to deposit into the reserve

    @param _initialSupply The initial supply of AuriumToken to mint

    @param _name The name of the AuriumToken

    @param _symbol The symbol of the AuriumToken

    @param _userAddress The address of the user that will receive the initial supply of AuriumToken
    */
    constructor(
        address _paxGold,
        uint256 _initialDeposit,
        uint256 _initialSupply,
        string memory _name,
        string memory _symbol,
        address _userAddress
    ) ERC20(_name, _symbol) {
        paxGold_ = IERC20(_paxGold);
        auriumTokenFactoryAddr_ = msg.sender;
        require(
            _initialDeposit > 0,
            "Initial deposit must be greater than zero"
        );
        require(_initialSupply > 0, "Initial supply must be greater than zero");

        totalReserve_ = calculateReceivedPaxg(_initialDeposit);
        initialSupply_ = _initialSupply;
        value_ = (totalReserve_.mul(PRECISION_FACTOR)).div(_initialSupply);
        _mint(_userAddress, _initialSupply);
    }

    /**
    @dev Calculates the receivable PAXG.
    @param _amount the amount of AuriumToken to burn.
    @return receivedPaxg - Receivable PAXG after fee deduction.
     */
    function calculateReceivedPaxg(
        uint256 _amount
    ) public view returns (uint256 receivedPaxg) {
        return
            _amount.sub(
                (_amount.mul(PAXGOLD(address(paxGold_)).feeRate())).div(
                    PAXGOLD_FEE_PARTS
                )
            );
    }

    /*
    @dev Calculates the AuriumToken to be minted.
    @param _amountPaxg the amount of PAXG to deposit
    @return ATKAmountsOut - AuriumToken to be minted.
     */
    function getAuriumTokenAmountsOut(
        uint _amountPaxg
    ) public view returns (uint256 ATKAmountsOut) {
        uint tempPaxgReceived = calculateReceivedPaxg(_amountPaxg); //Dummy var to calculate PAXG to be received after fee deduction.
        if (totalSupply() == 0) {
            return (tempPaxgReceived.mul(PRECISION_FACTOR)).div(lastValue_);
        } else {
            return (tempPaxgReceived.mul(PRECISION_FACTOR)).div(value_);
        }
    }

    function getPaxgAmountsOut(
        uint _amountAuriumToken
    ) public view returns (uint256 PAXGAmountsOut) {
        uint256 temp;
        if (value_ == 0) {
            temp = (_amountAuriumToken.mul(lastValue_)).div(PRECISION_FACTOR);
        } else {
            temp = (_amountAuriumToken.mul(value_)).div(PRECISION_FACTOR);
        }
        return calculateReceivedPaxg(temp);
    }

    /**

    @dev Calculates the current value of each AuriumToken
    */
    function _updateValue() public {
        value_ = totalSupply() == 0
            ? 0
            : (totalReserve_.mul(PRECISION_FACTOR)).div(totalSupply());
    }

    /**

    @dev Mint new AuriumToken by depositing PAXG into the reserve

    @param _value The amount of PAXG to deposit
    */
    function mint(uint256 _value) public nonReentrant {
        uint256 auriumTokenToMint;
        uint256 paxgReceived;

        require(
            paxGold_.balanceOf(msg.sender) >= _value,
            "Insufficient PaxGold balance"
        );

        paxGold_.safeTransferFrom(msg.sender, address(this), _value);
        paxgReceived = calculateReceivedPaxg(_value);

        if (totalSupply() == 0) {
            auriumTokenToMint = (paxgReceived.mul(PRECISION_FACTOR)).div(
                lastValue_
            );
        } else {
            auriumTokenToMint = (paxgReceived.mul(PRECISION_FACTOR)).div(
                value_
            );
        }
        _mint(msg.sender, auriumTokenToMint);

        totalReserve_ = totalReserve_.add(paxgReceived);
        lastValue_ = value_;
        _updateValue();
        emit AuriumTokenMinted(
            address(this),
            name(),
            symbol(),
            msg.sender,
            auriumTokenToMint
        );
    }

    /**

    @dev Burn AuriumToken and receive PAXG in return

    @param _value The amount of AuriumToken to burn
    */
    function burn(uint256 _value) public nonReentrant {
        require(
            balanceOf(msg.sender) >= _value,
            "Insufficient AuriumToken balance"
        );
        //Expected Paxg
        uint256 paxGoldValue = (_value.mul(value_)).div(PRECISION_FACTOR);
        paxGold_.safeTransfer(msg.sender, paxGoldValue);
        totalReserve_ = totalReserve_.sub(paxGoldValue);
        _burn(msg.sender, _value);
        lastValue_ = value_;
        _updateValue();
        emit AuriumTokenBurned(
            address(this),
            name(),
            symbol(),
            msg.sender,
            _value
        );
    }

    /**

    @dev Transfer AuriumToken while applying a burn fee

    @param recipient The address to transfer AuriumToken to

    @param amount The amount of AuriumToken to transfer

    @return A boolean indicating if the transfer was successful or not
    */
    function transfer(
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(amount > 1000, "Amount should be greater than 1000 wei");
        uint256 calculatedBurnFee = amount.mul(burnFee_).div(MULTIPLIER);
        uint256 FeeValueForComparison = value_ == 0
            ? lastValue_.mul(calculatedBurnFee)
            : value_.mul(calculatedBurnFee);
        if (FeeValueForComparison > (_maxBurnFee.mul(PRECISION_FACTOR))) {
            calculatedBurnFee = value_ == 0
                ? (_maxBurnFee.mul(PRECISION_FACTOR)).div(lastValue_)
                : (_maxBurnFee.mul(PRECISION_FACTOR)).div(value_);
            emit maxBurnFeeAlert(msg.sender, amount, calculatedBurnFee); //event if max burn fee is applied
        }
        _burn(msg.sender, calculatedBurnFee);
        lastValue_ = value_;
        _updateValue();
        return super.transfer(recipient, amount.sub(calculatedBurnFee));
    }

    /**

    @dev Transfer AuriumToken from a specified address to another while applying a burn fee

    @param sender The address to transfer AuriumToken from

    @param recipient The address to transfer AuriumToken to

    @param amount The amount of AuriumToken to transfer

    @return A boolean indicating if the transfer was successful or not
    */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(amount > 1000, "Amount should be greater than 1000 wei");
        uint256 calculatedBurnFee = amount.mul(burnFee_).div(MULTIPLIER);
        uint256 FeeValueForComparison = value_ == 0
            ? lastValue_.mul(calculatedBurnFee)
            : value_.mul(calculatedBurnFee);
        if (FeeValueForComparison > (_maxBurnFee.mul(PRECISION_FACTOR))) {
            calculatedBurnFee = value_ == 0
                ? (_maxBurnFee.mul(PRECISION_FACTOR)).div(lastValue_)
                : (_maxBurnFee.mul(PRECISION_FACTOR)).div(value_);
            emit maxBurnFeeAlert(msg.sender, amount, calculatedBurnFee); //event if max burn fee is applied
        }
        _burn(sender, calculatedBurnFee);
        lastValue_ = value_;
        _updateValue();
        return
            super.transferFrom(
                sender,
                recipient,
                amount.sub(calculatedBurnFee)
            );
    }

    /**

    @dev Get AuriumToken contract details
    @return A tuple containing the AuriumToken name, symbol, total supply, and current value of the AuriumToken
    */
    function getDetails()
        public
        view
        returns (string memory, string memory, uint256, uint256)
    {
        return (name(), symbol(), totalSupply(), value_);
    }
}

/**
 * @title AuriumTokenFactory
 * @dev A factory contract for creating AuriumToken instances.
 */
contract AuriumTokenFactory is ReentrancyGuard {
    IERC20 public immutable paxGold_;
    using Strings for string;

    struct AuriumTokenData {
        address auriumTokenAddress;
        string name;
        string symbol;
        uint256 index;
    }

    uint256 internal auriumTokenCount_;
    uint256 internal immutable minPaxgDeposit_;
    mapping(uint256 => address) internal auriumTokenIndexToAddress_;
    mapping(address => AuriumTokenData) internal auriumTokenAddressToData_;
    mapping(string => uint) internal auriumTokenNameToIndex_;

    event AuriumTokenCreated(
        address indexed auriumTokenAddress,
        string name,
        string symbol
    );

    constructor(IERC20 _paxGold, uint _minPaxgAmount) {
        paxGold_ = _paxGold;
        minPaxgDeposit_ = _minPaxgAmount;
    }

    function createAuriumToken(
        string memory _name,
        string memory _symbol,
        uint256 _initialDeposit,
        uint256 _initialSupply
    ) public nonReentrant {
        require(
            _initialDeposit >= minPaxgDeposit_,
            "Initial deposit is too low"
        );
        require(_initialSupply > 0, "Initial supply must be greater than ZERO");
        require(
            paxGold_.balanceOf(msg.sender) >= _initialDeposit,
            "Insufficient PaxGold balance"
        );
        require(
            paxGold_.allowance(msg.sender, address(this)) >= _initialDeposit,
            "Factory is not approved to spend PAXG on behalf of user"
        );

        string memory tempName = convertToUpperCase(_name);
        string memory tempSymbol = convertToUpperCase(_symbol);
        require(
            auriumTokenNameToIndex_[tempName] == 0,
            "AuriumToken name already exists"
        );
        require(
            auriumTokenNameToIndex_[tempSymbol] == 0,
            "AuriumToken symbol already exists"
        );

        auriumTokenCount_++;

        AuriumToken auriumToken = new AuriumToken(
            address(paxGold_),
            _initialDeposit,
            _initialSupply,
            _name,
            _symbol,
            msg.sender
        );

        auriumTokenAddressToData_[address(auriumToken)] = AuriumTokenData({
            auriumTokenAddress: address(auriumToken),
            name: _name,
            symbol: _symbol,
            index: auriumTokenCount_
        });

        require(
            paxGold_.transferFrom(
                msg.sender,
                address(auriumToken),
                _initialDeposit
            ),
            "Paxg transfer failed"
        );

        auriumTokenIndexToAddress_[auriumTokenCount_] = address(auriumToken);
        auriumTokenNameToIndex_[tempName] = auriumTokenCount_;
        auriumTokenNameToIndex_[tempSymbol] = auriumTokenCount_;

        emit AuriumTokenCreated(address(auriumToken), _name, _symbol);
    }

    /*
    @dev Gets the minimum amount out of PAXG to be deposited.
    @return minimumPaxgDeposit.
     */
    function getMinPaxgDeposit()
        public
        view
        returns (uint256 minimumPaxgDeposit)
    {
        return minPaxgDeposit_;
    }

    /*
    @dev Gets the current AuriumToken count.
    @return auriumTokenCounts.
     */
    function getAuriumTokenCount()
        public
        view
        returns (uint256 auriumTokenCounts)
    {
        return auriumTokenCount_;
    }

    /*
    @dev Gets the AuriumToken address from index value.
    @param _num Index number
    @return AuriumTokenIndexToAddress - AuriumToken address.
     */
    function getAuriumTokenAddressFromIndex(
        uint256 _num
    ) public view returns (address AuriumTokenIndexToAddress) {
        return auriumTokenIndexToAddress_[_num];
    }

    /*
    @dev Gets the AuriumToken details from address.
    @param _addr Address of AuriumToken
    @return auriumTokenAddress - AuriumToken address.
    @return name - AuriumToken name.
    @return symbol - AuriumToken symbol.
     */
    function getAuriumTokenDataFromAddress(
        address _addr
    )
        public
        view
        returns (
            address auriumTokenAddress,
            string memory name,
            string memory symbol,
            uint256 index
        )
    {
        AuriumTokenData storage auriumTokenData = auriumTokenAddressToData_[
            _addr
        ];
        return (
            auriumTokenData.auriumTokenAddress,
            auriumTokenData.name,
            auriumTokenData.symbol,
            auriumTokenData.index
        );
    }

    function convertToUpperCase(
        string memory _str
    ) internal pure returns (string memory) {
        return _str.toUpperCase();
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_paxGold","type":"address"},{"internalType":"uint256","name":"_minPaxgAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"auriumTokenAddress","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"string","name":"symbol","type":"string"}],"name":"AuriumTokenCreated","type":"event"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"_initialDeposit","type":"uint256"},{"internalType":"uint256","name":"_initialSupply","type":"uint256"}],"name":"createAuriumToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"getAuriumTokenAddressFromIndex","outputs":[{"internalType":"address","name":"AuriumTokenIndexToAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAuriumTokenCount","outputs":[{"internalType":"uint256","name":"auriumTokenCounts","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getAuriumTokenDataFromAddress","outputs":[{"internalType":"address","name":"auriumTokenAddress","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"index","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinPaxgDeposit","outputs":[{"internalType":"uint256","name":"minimumPaxgDeposit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paxGold_","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000045804880de22913dafe09f4980848ece6ecbaf780000000000000000000000000000000000000000000000000c7d713b49da0000

-----Decoded View---------------
Arg [0] : _paxGold (address): 0x45804880De22913dAFE09f4980848ECE6EcbAf78
Arg [1] : _minPaxgAmount (uint256): 900000000000000000

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000045804880de22913dafe09f4980848ece6ecbaf78
Arg [1] : 0000000000000000000000000000000000000000000000000c7d713b49da0000

Strings : 0x97d096bc5421d30447f974324ff92f8b9c66233e

51054:4822:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51108:32;;;;;;;;-1:-1:-1;;;;;192:32:1;;;174:51;;162:2;147:18;51108:32:0;;;;;;;;54707:184;;;;;;:::i;:::-;54798:33;54851:32;;;:26;:32;;;;;;-1:-1:-1;;;;;54851:32:0;;54707:184;55145:574;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;54125:151::-;54253:15;54125:151;;;2155:25:1;;;2143:2;2128:18;54125:151:0;2009:177:1;51898:2106:0;;;;;;:::i;:::-;;:::i;:::-;;54379:154;54508:17;;54379:154;;55145:574;-1:-1:-1;;;;;55469:56:0;;;55277:26;55469:56;;;:25;:56;;;;;;;55558:34;;55679:21;;;;55558:34;55607:20;;55536:175;;55277:26;;55318:18;;;;55277:26;;55469:56;55558:34;;;55607:20;55642:22;;;;55607:20;;55536:175;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55145:574;;;;;:::o;51898:2106::-;1462:21;:19;:21::i;:::-;52133:15:::1;52114;:34;;52092:110;;;::::0;-1:-1:-1;;;52092:110:0;;4536:2:1;52092:110:0::1;::::0;::::1;4518:21:1::0;4575:2;4555:18;;;4548:30;4614:28;4594:18;;;4587:56;4660:18;;52092:110:0::1;;;;;;;;;52238:1;52221:14;:18;52213:71;;;::::0;-1:-1:-1;;;52213:71:0;;4891:2:1;52213:71:0::1;::::0;::::1;4873:21:1::0;4930:2;4910:18;;;4903:30;4969:34;4949:18;;;4942:62;-1:-1:-1;;;5020:18:1;;;5013:38;5068:19;;52213:71:0::1;4689:404:1::0;52213:71:0::1;52317:30;::::0;-1:-1:-1;;;52317:30:0;;52336:10:::1;52317:30;::::0;::::1;174:51:1::0;52351:15:0;;52317:8:::1;-1:-1:-1::0;;;;;52317:18:0::1;::::0;::::1;::::0;147::1;;52317:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;52295:127;;;::::0;-1:-1:-1;;;52295:127:0;;5489:2:1;52295:127:0::1;::::0;::::1;5471:21:1::0;5528:2;5508:18;;;5501:30;5567;5547:18;;;5540:58;5615:18;;52295:127:0::1;5287:352:1::0;52295:127:0::1;52455:45;::::0;-1:-1:-1;;;52455:45:0;;52474:10:::1;52455:45;::::0;::::1;5856:34:1::0;52494:4:0::1;5906:18:1::0;;;5899:43;52504:15:0;;52455:8:::1;-1:-1:-1::0;;;;;52455:18:0::1;::::0;::::1;::::0;5791::1;;52455:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:64;;52433:169;;;::::0;-1:-1:-1;;;52433:169:0;;6155:2:1;52433:169:0::1;::::0;::::1;6137:21:1::0;6194:2;6174:18;;;6167:30;6233:34;6213:18;;;6206:62;6304:25;6284:18;;;6277:53;6347:19;;52433:169:0::1;5953:419:1::0;52433:169:0::1;52615:22;52640:25;52659:5;52640:18;:25::i;:::-;52615:50;;52676:24;52703:27;52722:7;52703:18;:27::i;:::-;52676:54;;52763:23;52787:8;52763:33;;;;;;:::i;:::-;;;;;;;;;;;;;;52800:1;52763:38;52741:119;;;::::0;-1:-1:-1;;;52741:119:0;;6873:2:1;52741:119:0::1;::::0;::::1;6855:21:1::0;6912:2;6892:18;;;6885:30;6951:33;6931:18;;;6924:61;7002:18;;52741:119:0::1;6671:355:1::0;52741:119:0::1;52893:23;52917:10;52893:35;;;;;;:::i;:::-;;;;;;;;;;;;;;52932:1;52893:40;52871:123;;;::::0;-1:-1:-1;;;52871:123:0;;7233:2:1;52871:123:0::1;::::0;::::1;7215:21:1::0;7272:2;7252:18;;;7245:30;7311:34;7291:18;;;7284:62;-1:-1:-1;;;7362:18:1;;;7355:31;7403:19;;52871:123:0::1;7031:397:1::0;52871:123:0::1;53007:17;:19:::0;;;:17:::1;:19;::::0;::::1;:::i;:::-;;;;;;53039:23;53103:8;53127:15;53157:14;53186:5;53206:7;53228:10;53065:184;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;53312:178:0::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;53312:178:0;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;;;;;;;53461:17:::1;::::0;;53312:178;;;;-1:-1:-1;53262:47:0;;;:25:::1;:47:::0;;;;;;;:228;;;;-1:-1:-1;;;;;;53262:228:0::1;::::0;::::1;::::0;;;::::1;::::0;;;;53312:178;;-1:-1:-1;53312:178:0;;53262:47;;:228;::::1;::::0;::::1;::::0;;::::1;:::i;:::-;-1:-1:-1::0;53262:228:0::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;:::i;:::-;-1:-1:-1::0;53262:228:0::1;::::0;;;::::1;::::0;::::1;::::0;;::::1;::::0;53525:138:::1;::::0;-1:-1:-1;;;53525:138:0;;53565:10:::1;53525:138;::::0;::::1;10846:34:1::0;-1:-1:-1;;;;;10916:15:1;;;10896:18;;;10889:43;10948:18;;;10941:34;;;53525:8:0::1;:21;::::0;::::1;::::0;10781:18:1;;53525:138:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53503:208;;;::::0;-1:-1:-1;;;53503:208:0;;11470:2:1;53503:208:0::1;::::0;::::1;11452:21:1::0;11509:2;11489:18;;;11482:30;-1:-1:-1;;;11528:18:1;;;11521:50;11588:18;;53503:208:0::1;11268:344:1::0;53503:208:0::1;53751:17;::::0;;53724:45:::1;::::0;;;:26:::1;:45;::::0;;;;;;:68;;-1:-1:-1;;;;;;53724:68:0::1;-1:-1:-1::0;;;;;53724:68:0;::::1;;::::0;;53839:17;;53803:33;;:23:::1;::::0;:33:::1;::::0;53827:8;;53803:33:::1;:::i;:::-;;;;;;;;;;;;;:53;;;;53905:17;;53867:23;53891:10;53867:35;;;;;;:::i;:::-;;;;;;;;;;;;;:55;;;;53967:11;-1:-1:-1::0;;;;;53940:56:0::1;;53981:5;53988:7;53940:56;;;;;;;:::i;:::-;;;;;;;;52081:1923;;;1506:20:::0;900:1;2026:7;:22;1843:213;1506:20;51898:2106;;;;:::o;1542:293::-;944:1;1676:7;;:19;1668:63;;;;-1:-1:-1;;;1668:63:0;;12207:2:1;1668:63:0;;;12189:21:1;12246:2;12226:18;;;12219:30;12285:33;12265:18;;;12258:61;12336:18;;1668:63:0;12005:355:1;1668:63:0;944:1;1809:7;:18;1542:293::o;55727:146::-;55847:18;;-1:-1:-1;;;55847:18:0;;55814:13;;55847:16;;;;:18;;:4;;:18;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55847:18:0;;;;;;;;;;;;:::i;:::-;55840:25;55727:146;-1:-1:-1;;55727:146:0:o;-1:-1:-1:-;;;;;;;;:::o;236:180:1:-;295:6;348:2;336:9;327:7;323:23;319:32;316:52;;;364:1;361;354:12;316:52;-1:-1:-1;387:23:1;;236:180;-1:-1:-1;236:180:1:o;629:286::-;688:6;741:2;729:9;720:7;716:23;712:32;709:52;;;757:1;754;747:12;709:52;783:23;;-1:-1:-1;;;;;835:31:1;;825:42;;815:70;;881:1;878;871:12;815:70;904:5;629:286;-1:-1:-1;;;629:286:1:o;920:250::-;1005:1;1015:113;1029:6;1026:1;1023:13;1015:113;;;1105:11;;;1099:18;1086:11;;;1079:39;1051:2;1044:10;1015:113;;;-1:-1:-1;;1162:1:1;1144:16;;1137:27;920:250::o;1175:271::-;1217:3;1255:5;1249:12;1282:6;1277:3;1270:19;1298:76;1367:6;1360:4;1355:3;1351:14;1344:4;1337:5;1333:16;1298:76;:::i;:::-;1428:2;1407:15;-1:-1:-1;;1403:29:1;1394:39;;;;1435:4;1390:50;;1175:271;-1:-1:-1;;1175:271:1:o;1451:553::-;-1:-1:-1;;;;;1704:32:1;;1686:51;;1773:3;1768:2;1753:18;;1746:31;;;-1:-1:-1;;1800:46:1;;1826:19;;1818:6;1800:46;:::i;:::-;1894:9;1886:6;1882:22;1877:2;1866:9;1862:18;1855:50;1922:33;1948:6;1940;1922:33;:::i;:::-;1914:41;;;1991:6;1986:2;1975:9;1971:18;1964:34;1451:553;;;;;;;:::o;2191:127::-;2252:10;2247:3;2243:20;2240:1;2233:31;2283:4;2280:1;2273:15;2307:4;2304:1;2297:15;2323:275;2394:2;2388:9;2459:2;2440:13;;-1:-1:-1;;2436:27:1;2424:40;;2494:18;2479:34;;2515:22;;;2476:62;2473:88;;;2541:18;;:::i;:::-;2577:2;2570:22;2323:275;;-1:-1:-1;2323:275:1:o;2603:187::-;2652:4;2685:18;2677:6;2674:30;2671:56;;;2707:18;;:::i;:::-;-1:-1:-1;2773:2:1;2752:15;-1:-1:-1;;2748:29:1;2779:4;2744:40;;2603:187::o;2795:464::-;2838:5;2891:3;2884:4;2876:6;2872:17;2868:27;2858:55;;2909:1;2906;2899:12;2858:55;2945:6;2932:20;2976:49;2992:32;3021:2;2992:32;:::i;:::-;2976:49;:::i;:::-;3050:2;3041:7;3034:19;3096:3;3089:4;3084:2;3076:6;3072:15;3068:26;3065:35;3062:55;;;3113:1;3110;3103:12;3062:55;3178:2;3171:4;3163:6;3159:17;3152:4;3143:7;3139:18;3126:55;3226:1;3201:16;;;3219:4;3197:27;3190:38;;;;3205:7;2795:464;-1:-1:-1;;;2795:464:1:o;3264:680::-;3370:6;3378;3386;3394;3447:3;3435:9;3426:7;3422:23;3418:33;3415:53;;;3464:1;3461;3454:12;3415:53;3504:9;3491:23;3533:18;3574:2;3566:6;3563:14;3560:34;;;3590:1;3587;3580:12;3560:34;3613:50;3655:7;3646:6;3635:9;3631:22;3613:50;:::i;:::-;3603:60;;3716:2;3705:9;3701:18;3688:32;3672:48;;3745:2;3735:8;3732:16;3729:36;;;3761:1;3758;3751:12;3729:36;;3784:52;3828:7;3817:8;3806:9;3802:24;3784:52;:::i;:::-;3264:680;;3774:62;;-1:-1:-1;;;;3883:2:1;3868:18;;3855:32;;3934:2;3919:18;3906:32;;3264:680;-1:-1:-1;3264:680:1:o;3949:380::-;4028:1;4024:12;;;;4071;;;4092:61;;4146:4;4138:6;4134:17;4124:27;;4092:61;4199:2;4191:6;4188:14;4168:18;4165:38;4162:161;;4245:10;4240:3;4236:20;4233:1;4226:31;4280:4;4277:1;4270:15;4308:4;4305:1;4298:15;4162:161;;3949:380;;;:::o;5098:184::-;5168:6;5221:2;5209:9;5200:7;5196:23;5192:32;5189:52;;;5237:1;5234;5227:12;5189:52;-1:-1:-1;5260:16:1;;5098:184;-1:-1:-1;5098:184:1:o;6377:289::-;6508:3;6546:6;6540:13;6562:66;6621:6;6616:3;6609:4;6601:6;6597:17;6562:66;:::i;:::-;6644:16;;;;;6377:289;-1:-1:-1;;6377:289:1:o;7433:232::-;7472:3;7493:17;;;7490:140;;7552:10;7547:3;7543:20;7540:1;7533:31;7587:4;7584:1;7577:15;7615:4;7612:1;7605:15;7490:140;-1:-1:-1;7657:1:1;7646:13;;7433:232::o;7670:727::-;7942:4;7988:1;7984;7979:3;7975:11;7971:19;8029:2;8021:6;8017:15;8006:9;7999:34;8069:6;8064:2;8053:9;8049:18;8042:34;8112:6;8107:2;8096:9;8092:18;8085:34;8155:3;8150:2;8139:9;8135:18;8128:31;8182:46;8223:3;8212:9;8208:19;8200:6;8182:46;:::i;:::-;8277:9;8269:6;8265:22;8259:3;8248:9;8244:19;8237:51;8305:33;8331:6;8323;8305:33;:::i;:::-;8297:41;;;8387:2;8379:6;8375:15;8369:3;8358:9;8354:19;8347:44;;7670:727;;;;;;;;;:::o;8528:545::-;8630:2;8625:3;8622:11;8619:448;;;8666:1;8691:5;8687:2;8680:17;8736:4;8732:2;8722:19;8806:2;8794:10;8790:19;8787:1;8783:27;8777:4;8773:38;8842:4;8830:10;8827:20;8824:47;;;-1:-1:-1;8865:4:1;8824:47;8920:2;8915:3;8911:12;8908:1;8904:20;8898:4;8894:31;8884:41;;8975:82;8993:2;8986:5;8983:13;8975:82;;;9038:17;;;9019:1;9008:13;8975:82;;;8979:3;;;8619:448;8528:545;;;:::o;9249:1352::-;9375:3;9369:10;9402:18;9394:6;9391:30;9388:56;;;9424:18;;:::i;:::-;9453:97;9543:6;9503:38;9535:4;9529:11;9503:38;:::i;:::-;9497:4;9453:97;:::i;:::-;9605:4;;9669:2;9658:14;;9686:1;9681:663;;;;10388:1;10405:6;10402:89;;;-1:-1:-1;10457:19:1;;;10451:26;10402:89;-1:-1:-1;;9206:1:1;9202:11;;;9198:24;9194:29;9184:40;9230:1;9226:11;;;9181:57;10504:81;;9651:944;;9681:663;8475:1;8468:14;;;8512:4;8499:18;;-1:-1:-1;;9717:20:1;;;9835:236;9849:7;9846:1;9843:14;9835:236;;;9938:19;;;9932:26;9917:42;;10030:27;;;;9998:1;9986:14;;;;9865:19;;9835:236;;;9839:3;10099:6;10090:7;10087:19;10084:201;;;10160:19;;;10154:26;-1:-1:-1;;10243:1:1;10239:14;;;10255:3;10235:24;10231:37;10227:42;10212:58;10197:74;;10084:201;-1:-1:-1;;;;;10331:1:1;10315:14;;;10311:22;10298:36;;-1:-1:-1;9249:1352:1:o;10986:277::-;11053:6;11106:2;11094:9;11085:7;11081:23;11077:32;11074:52;;;11122:1;11119;11112:12;11074:52;11154:9;11148:16;11207:5;11200:13;11193:21;11186:5;11183:32;11173:60;;11229:1;11226;11219:12;11617:383;11814:2;11803:9;11796:21;11777:4;11840:45;11881:2;11870:9;11866:18;11858:6;11840:45;:::i;:::-;11933:9;11925:6;11921:22;11916:2;11905:9;11901:18;11894:50;11961:33;11987:6;11979;11961:33;:::i;:::-;11953:41;11617:383;-1:-1:-1;;;;;11617:383:1:o;12365:228::-;12522:2;12511:9;12504:21;12485:4;12542:45;12583:2;12572:9;12568:18;12560:6;12542:45;:::i;12598:649::-;12678:6;12731:2;12719:9;12710:7;12706:23;12702:32;12699:52;;;12747:1;12744;12737:12;12699:52;12780:9;12774:16;12813:18;12805:6;12802:30;12799:50;;;12845:1;12842;12835:12;12799:50;12868:22;;12921:4;12913:13;;12909:27;-1:-1:-1;12899:55:1;;12950:1;12947;12940:12;12899:55;12979:2;12973:9;13004:49;13020:32;13049:2;13020:32;:::i;13004:49::-;13076:2;13069:5;13062:17;13116:7;13111:2;13106;13102;13098:11;13094:20;13091:33;13088:53;;;13137:1;13134;13127:12;13088:53;13150:67;13214:2;13209;13202:5;13198:14;13193:2;13189;13185:11;13150:67;:::i

ipfs://b76f8593023f58340f363defb4ab3f9b4a09b9047a09cb4d16bb43851d90826a