// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "./Counters.sol";
import "./JsmnSolLib.sol";
import "./inputData.sol";
contract Inscription is inputData {
    // Declare a public variable to store the owner's address
    address public owner;

    /**
    * @dev Constructor that sets the contract deployer as the owner.
    * 
    * The constructor is called only once when the contract is deployed.
    * It assigns the address of the account that deploys the contract to the `owner` variable.
    */
    constructor() {
        owner = msg.sender; // Set the owner to the address that deployed the contract
    }

    /**
    * @dev Modifier that restricts function access to the contract owner.
    * 
    * This modifier checks if the caller of a function is the owner of the contract.
    * If the caller is not the owner, it reverts the transaction with an error message.
    */
    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not the contract owner"); // Ensure the caller is the owner
        _; // Placeholder for the function body to be executed
    }

    // Importing and using the Counters library for managing counters
    using Counters for Counters.Counter;

    // Define a constant for the number of decimal places for the token
    uint256 constant DECIMALS = 18; // The standard decimal precision for ERC20 tokens is usually 18
    bytes32 constant ERC20_P_HASH = keccak256(abi.encodePacked("p"));
    bytes32 constant ERC20_OP_HASH = keccak256(abi.encodePacked("op"));
    bytes32 constant ERC20_TICK_HASH = keccak256(abi.encodePacked("tick"));
    bytes32 constant ERC20_MAX_HASH = keccak256(abi.encodePacked("max"));
    bytes32 constant ERC20_LIM_HASH = keccak256(abi.encodePacked("lim"));
    bytes32 constant ERC20_AMT_HASH = keccak256(abi.encodePacked("amt"));
    bytes32 constant ERC20_P_HASH_ERC20 = keccak256(abi.encodePacked("erc-20"));
    bytes32 constant ERC20_OP_HASH_DEPLOY =keccak256(abi.encodePacked("deploy"));
    bytes32 constant ERC20_OP_HASH_MINT = keccak256(abi.encodePacked("mint"));
    bytes32 constant ERC20_OP_HASH_TRANSFER = keccak256(abi.encodePacked("transfer"));
    bytes32 constant ERC20_OP_HASH_TRANSFER_TO = keccak256(abi.encodePacked("to"));
    bytes32 constant ERC20_OP_HASH_TRANSFER_FROM = keccak256(abi.encodePacked("from"));
    bytes32 constant ERC20_MAX_MINT = keccak256(abi.encodePacked("maxMint"));
    bytes32 constant ERC20_MINT_PRICE = keccak256(abi.encodePacked("mintPrice"));
    bytes32 constant ERC20_RESERVE = keccak256(abi.encodePacked("reserve"));
    bytes32 constant ERC20_OP_HASH_APPROVE = keccak256(abi.encodePacked("approve"));
    bytes32 constant ERC20_OP_HASH_TRANSFERFROM = keccak256(abi.encodePacked("transferFrom"));

    // The ERC20Token struct represents basic information about an ERC20 token
    struct ERC20Token {
        string name;              // The name of the token
        uint256 maxSupply;        // The maximum supply of the token, indicating the upper limit of tokens that can be minted
        uint256 mintLimit;        // The limit per mint operation, i.e., the maximum number of tokens that can be minted in one transaction
        uint256 minted;           // The total number of tokens that have already been minted
        address deployer;         // The address of the deployer, representing the creator or owner of the contract
        uint256 deployTime;       // The timestamp when the contract was deployed, indicating the deployment time of the token
        uint256 holders;          // The number of addresses holding this token, representing the current number of token holders
        uint256 maxMintPerAddress;// The maximum number of tokens that can be minted by a single address
        uint256 mintPrice;        // The price per token mint in wei, representing the cost to mint one token
        uint256 reserve;          // The reserve of tokens, representing the amount of tokens held in reserve or still available for minting
    }

    // The MintERC20 struct is used to track whether an ERC20 token has been deployed
    struct MintERC20 {
        string ticker;    // The symbol or ticker of the token
        bool deployed;    // Whether the token has been deployed; true indicates the token is successfully deployed, false means not yet deployed
    }

    // A nested mapping to store token balances for each token ticker and address
    // The first string represents the token ticker, 
    // and the address represents the user's wallet address.
    mapping(string => mapping(address => uint256)) public balances; 

    // A nested mapping to track the number of tokens minted by each address for each token ticker
    // The string represents the token ticker, and the address is the user's wallet address.
    mapping(string => mapping(address => uint256)) public mintCounts; 

    // A mapping to link token tickers (converted to bytes32) to the MintERC20 struct
    // It tracks deployed tokens and their ticker symbols.
    mapping(bytes32 => MintERC20) private mintHexMap; 

    // A nested mapping to store allowances for token transfers between addresses
    // The string represents the token ticker, the first address is the token owner,
    // and the second address is the spender. The uint256 represents the allowance amount.
    mapping(string => mapping(address => mapping(address => uint256))) public allowances; 

    // A mapping to store details of each token (inscription) by its ticker name
    // The string is the token ticker, and the ERC20Token struct holds the token's information.
    mapping(string => ERC20Token) public inscriptions; 

    // An array to store all token ticker names that have been created
    string[] public tokenNames; 

    // A counter to track the total number of unique token tickers created
    Counters.Counter public totalTickers;

    function deployToken(
        string memory ticker,                // Token ticker (e.g., "ETH", "USDT")
        uint256 maxSupply,                   // Maximum total supply of the token
        uint256 mintLimit,                   // Limit on how many tokens can be minted
        uint256 maxMintPerAddress,           // Maximum tokens an address can mint
        uint256 mintPrice,                   // Price per mint in wei
        uint256 reserve                      // Amount of tokens reserved for the deployer
    ) internal virtual {
        // Ensure a minimum fee of 0.02 ether is paid for deploying a new token
        require(msg.value >= 0.02 ether, "Insufficient deployment fee");

        // Retrieve or create a new ERC20Token struct for the provided ticker
        ERC20Token storage newToken = inscriptions[ticker];

        // Ensure the token doesn't already exist by checking if the deployer is address(0)
        require(newToken.deployer == address(0), "Token already exists");

        // Assign the provided parameters to the new token's properties
        newToken.name = ticker;
        newToken.maxSupply = maxSupply;
        newToken.mintLimit = mintLimit;
        newToken.deployer = msg.sender;             // The address deploying the token
        newToken.deployTime = block.timestamp;      // Timestamp of token deployment
        newToken.maxMintPerAddress = maxMintPerAddress;
        newToken.mintPrice = mintPrice;
        newToken.reserve = reserve;

        // Increment the counter for the total number of tickers created
        totalTickers.increment();

        // Add the token ticker to the list of token names
        tokenNames.push(ticker);

        // Send the ether paid for the deployment to the contract owner
        sendETH(payable(owner), msg.value);

        // If a reserve is specified, allocate tokens to the deployer's balance
        if (reserve != 0) {
            balances[ticker][msg.sender] += reserve;    // Assign reserved tokens to the deployer's balance
            newToken.minted += reserve;                 // Update the total number of minted tokens
            newToken.holders += 1;                      // Increment the holder count
        }
    }

    function inscribeMint(bytes32 mintHash) internal virtual {
        // Retrieve the token's ticker using the provided mint hash
        string memory ticker = mintHexMap[mintHash].ticker;

        // Access the token details from the inscriptions mapping
        ERC20Token storage token = inscriptions[ticker];

        // Ensure the amount sent by the caller matches the mint price for the token
        require(msg.value == token.mintPrice, "Incorrect mint price");

        // If there is a maximum minting limit per address, ensure the user doesn't exceed it
        if (token.maxMintPerAddress != 0) {
            require(
                mintCounts[ticker][msg.sender] + token.mintLimit <= token.maxMintPerAddress,
                "Exceeds max mint per address"
            );
        }
        
        // Ensure the total minted amount after this transaction won't exceed the max supply
        require(
            (token.minted + token.mintLimit) <= token.maxSupply,
            "Exceeds available supply"
        );

        // Update the total minted tokens count
        token.minted += token.mintLimit;

        // Double check that the minted tokens do not exceed the max supply
        require(token.minted <= token.maxSupply, "Minting finished");

        // If this is the first time the caller is minting this token, increment the holders count
        if (balances[ticker][msg.sender] == 0) {
            token.holders += 1;
        }

        // Update the mint count and balance for the caller
        mintCounts[ticker][msg.sender] += token.mintLimit;
        balances[ticker][msg.sender] += token.mintLimit;

        // Send 10% of the mint price to the contract owner
        sendETH(payable(owner), calculatePercentage(msg.value, 10));

        // Send 90% of the mint price to the token deployer
        sendETH(payable(token.deployer), calculatePercentage(msg.value, 90));
    }

    function sendETH(address payable recipient, uint256 amount) private{
        // Attempt to transfer the specified amount of ETH to the recipient
        (bool success, ) = recipient.call{value: amount}("");

        // Revert the transaction if the transfer fails
        require(success, "ETH transfer failed");
    }

    function calculatePercentage(uint256 amount, uint256 percentage) internal pure returns (uint256) {
        // Calculate the percentage of the given amount
        return (amount * percentage) / 100;
    }

    function transferTokens(
        string memory ticker,  // The symbol of the token being transferred
        address from,          // The address of the sender who is transferring the tokens
        address to,            // The address of the recipient who will receive the tokens
        uint256 amount         // The number of tokens to transfer
    ) internal virtual {
        // Retrieve the balance of the sender for the specified token
        uint256 senderBalance = balances[ticker][from];

        // Ensure the sender has enough balance to perform the transfer
        require(senderBalance >= amount, "Insufficient balance for transfer");

        // Perform the transfer operation, subtracting the amount from the sender's balance
        unchecked {
            balances[ticker][from] = senderBalance - amount;
        }

        // If the sender's balance becomes zero after the transfer, reduce the holder count
        if (balances[ticker][from] == 0) {
            inscriptions[ticker].holders -= 1;
        }

        // If the recipient's balance was previously zero and a non-zero amount is transferred, increase the holder count
        if (balances[ticker][to] == 0 && amount > 0) {
            inscriptions[ticker].holders += 1;
        }

        // Add the transferred amount to the recipient's balance
        balances[ticker][to] += amount;
    }


    /**
    * @dev Approves a spender to transfer a specified amount of tokens on behalf of the token holder.
    * 
    * @param ticker The symbol of the token being approved for spending (e.g., "ETH", "USDT").
    * @param from The address of the token holder who is approving the transfer.
    * @param to The address of the spender who is allowed to transfer the tokens.
    * @param amount The maximum number of tokens the spender is allowed to transfer.
    */
    function approveTokens(
        string memory ticker,  // The token symbol for which the approval is being made
        address from,          // The address of the token owner who is giving approval
        address to,            // The address of the spender who is receiving approval
        uint256 amount         // The amount of tokens to approve for the spender
    ) internal virtual {
        // Set the approval amount in the allowances mapping
        allowances[ticker][from][to] = amount;
    }

    /**
    * @dev Transfers tokens from one address to another using the allowance mechanism.
    * 
    * This function checks if the caller has enough allowance to transfer the specified amount of tokens
    * from the `from` address to the `to` address.
    * 
    * @param ticker The symbol of the token being transferred.
    * @param from The address from which tokens will be transferred.
    * @param to The address to which tokens will be transferred.
    * @param amount The number of tokens to transfer from the `from` address to the `to` address.
    */
    function transferTokensFrom(
        string memory ticker,  // The token symbol for the transfer operation
        address from,          // The address from which tokens are being transferred
        address to,            // The address to which tokens are being transferred
        uint256 amount         // The amount of tokens to transfer
    ) internal virtual {
        // Check if the caller has sufficient allowance to perform the transfer
        require(allowances[ticker][from][msg.sender] >= 1, "Insufficient allowance");
        
        // Call the transferTokens function to execute the transfer
        transferTokens(ticker, from, to, amount);
    }


   /**
    * @dev Fallback function that handles incoming Ether and processes the input data.
    * 
    * This function is triggered when the contract receives Ether and no function matches the call.
    * It checks whether the minting process has been deployed for the given input, and if so,
    * it allows only externally owned accounts (EOAs) to inscribe the mint. Otherwise, it calls the
    * internal _inscribe function.
    *
    * @param input The calldata input data containing the minting information as a JSON string.
    * @return An empty byte array.
    */
    fallback(bytes calldata input) external payable returns (bytes memory) {
        // Convert the input data (bytes) into a string
        string memory jsonString = string(input);
        
        // Calculate the hash of the JSON string to identify the mint
        bytes32 mintHash = keccak256(abi.encodePacked(jsonString));
        
        // Check if the minting process has been deployed
        if (mintHexMap[mintHash].deployed) {
            // Ensure that the caller is an externally owned account (EOA)
            require(msg.sender == tx.origin, "Only EOA allowed");
            
            // Call the inscribeMint function to process the minting
            inscribeMint(mintHash);
        } else {
            // If not deployed, call the internal _inscribe function
            _inscribe(jsonString);
        }
        
        // Return an empty byte array
        return "";
    }


   function _inscribe(string memory jsonStr) internal virtual {
        uint256 returnValue;
        JsmnSolLib.Token[] memory tokens;
        (returnValue, tokens, ) = JsmnSolLib.parse(jsonStr, 17);
        require(returnValue == JsmnSolLib.RETURN_SUCCESS, "JSON parsing failed");

        {
        string memory p = JsmnSolLib.getBytes(
            jsonStr,
            tokens[1].start,
            tokens[1].end
        );
        string memory pVal = JsmnSolLib.getBytes(
            jsonStr,
            tokens[2].start,
            tokens[2].end
        );

        string memory op = JsmnSolLib.getBytes(
            jsonStr,
            tokens[3].start,
            tokens[3].end
        );
        string memory tick = JsmnSolLib.getBytes(
            jsonStr,
            tokens[5].start,
            tokens[5].end
        );
        require(
            keccak256(abi.encodePacked(p)) == ERC20_P_HASH &&
                keccak256(abi.encodePacked(pVal)) == ERC20_P_HASH_ERC20 &&
                keccak256(abi.encodePacked(op)) == ERC20_OP_HASH &&
                keccak256(abi.encodePacked(tick)) == ERC20_TICK_HASH,
            "Invalid ERC-20 parameters"
        );
        
        }

        string memory opVal = JsmnSolLib.getBytes(
            jsonStr,
            tokens[4].start,
            tokens[4].end
        );
        string memory tickVal = JsmnSolLib.getBytes(
            jsonStr,
            tokens[6].start,
            tokens[6].end
        );
        if (keccak256(abi.encodePacked(opVal)) == ERC20_OP_HASH_TRANSFER) {
            string memory amt = JsmnSolLib.getBytes(
                jsonStr,
                tokens[7].start,
                tokens[7].end
            );
            string memory toKey = JsmnSolLib.getBytes(
                jsonStr,
                tokens[9].start,
                tokens[9].end
            );
            require(
                keccak256(abi.encodePacked(toKey)) ==
                    ERC20_OP_HASH_TRANSFER_TO &&
                    keccak256(abi.encodePacked(amt)) == ERC20_AMT_HASH,
                "Invalid transfer parameters"
            );
            string memory amtVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[8].start,
                tokens[8].end
            );
            string memory toVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[10].start,
                tokens[10].end
            );
            transferTokens(
                tickVal,
                msg.sender,
                JsmnSolLib.stringToAddress(toVal),
                uint256(JsmnSolLib.parseInt(amtVal, DECIMALS))
            );

        } else if (keccak256(abi.encodePacked(opVal)) == ERC20_OP_HASH_DEPLOY) {
            string memory max = JsmnSolLib.getBytes(
                jsonStr,
                tokens[7].start,
                tokens[7].end
            );

            string memory lim = JsmnSolLib.getBytes(
                jsonStr,
                tokens[9].start,
                tokens[9].end
            );

            string memory maxMint = JsmnSolLib.getBytes(
                jsonStr,
                tokens[11].start,
                tokens[11].end
            );

            string memory mintPrice = JsmnSolLib.getBytes(
                jsonStr,
                tokens[13].start,
                tokens[13].end
            );

            string memory reserve = JsmnSolLib.getBytes(
                jsonStr,
                tokens[15].start,
                tokens[15].end
            );

            require(
                keccak256(abi.encodePacked(max)) == ERC20_MAX_HASH &&
                    keccak256(abi.encodePacked(lim)) == ERC20_LIM_HASH &&
                    keccak256(abi.encodePacked(maxMint)) == ERC20_MAX_MINT &&
                        keccak256(abi.encodePacked(mintPrice)) == ERC20_MINT_PRICE &&
                            keccak256(abi.encodePacked(reserve)) == ERC20_RESERVE,
                "Invalid deployment parameters"
            );

            string memory maxVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[8].start,
                tokens[8].end
            );
            string memory limVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[10].start,
                tokens[10].end
            );
            string memory mintVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[12].start,
                tokens[12].end
            );
            string memory priceVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[14].start,
                tokens[14].end
            );
            string memory reserveVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[16].start,
                tokens[16].end
            );
            MintERC20 storage mintercData = mintHexMap[ keccak256(abi.encodePacked(mintString(tickVal,limVal)))];
            mintercData.deployed = true;
            mintercData.ticker = tickVal;
            deployToken(
                tickVal,
                uint256(JsmnSolLib.parseInt(maxVal, DECIMALS)),
                uint256(JsmnSolLib.parseInt(limVal, DECIMALS)),
                uint256(JsmnSolLib.parseInt(mintVal, DECIMALS)),
                uint256(JsmnSolLib.parseInt(priceVal, DECIMALS)),
                uint256(JsmnSolLib.parseInt(reserveVal, DECIMALS))
            );
        } else if (keccak256(abi.encodePacked(opVal)) == ERC20_OP_HASH_APPROVE) {
            string memory amt = JsmnSolLib.getBytes(
                jsonStr,
                tokens[7].start,
                tokens[7].end
            );
            string memory toKey = JsmnSolLib.getBytes(
                jsonStr,
                tokens[9].start,
                tokens[9].end
            );
            require(
                keccak256(abi.encodePacked(toKey)) ==
                    ERC20_OP_HASH_TRANSFER_TO &&
                    keccak256(abi.encodePacked(amt)) == ERC20_AMT_HASH,
                "Invalid approval parameters"
            );
            string memory amtVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[8].start,
                tokens[8].end
            );
            string memory toVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[10].start,
                tokens[10].end
            );
            approveTokens(
                tickVal,
                msg.sender,
                JsmnSolLib.stringToAddress(toVal),
                uint256(JsmnSolLib.parseInt(amtVal))
            );
        } else if (keccak256(abi.encodePacked(opVal)) == ERC20_OP_HASH_TRANSFERFROM) {
            string memory amt = JsmnSolLib.getBytes(
                jsonStr,
                tokens[7].start,
                tokens[7].end
            );
            string memory toKey = JsmnSolLib.getBytes(
                jsonStr,
                tokens[9].start,
                tokens[9].end
            );
            string memory fromKey = JsmnSolLib.getBytes(
                jsonStr,
                tokens[11].start,
                tokens[11].end
            );
            require(
                keccak256(abi.encodePacked(toKey)) == ERC20_OP_HASH_TRANSFER_TO &&
                keccak256(abi.encodePacked(amt)) == ERC20_AMT_HASH &&
                keccak256(abi.encodePacked(fromKey)) == ERC20_OP_HASH_TRANSFER_FROM,
                "Invalid transferFrom parameters"
            );
            string memory amtVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[8].start,
                tokens[8].end
            );
            string memory toVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[10].start,
                tokens[10].end
            );
            string memory fromVal = JsmnSolLib.getBytes(
                jsonStr,
                tokens[12].start,
                tokens[12].end
            );

            transferTokensFrom(
                tickVal,
                JsmnSolLib.stringToAddress(fromVal),
                JsmnSolLib.stringToAddress(toVal),
                uint256(JsmnSolLib.parseInt(amtVal, DECIMALS))
            );
        } 
    }

    function withdrawETH(address payable _to, uint _amount) external onlyOwner{
        _to.transfer(_amount);
    }

     function withdrawERC20(address token, address to, uint256 value) external onlyOwner{
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    receive() external payable {}

}

// SPDX-License-Identifier: AGPL-3.0-or-later

/*
Copyright (c) 2017 Christoph Niemann
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

pragma solidity ^0.8.1;

library JsmnSolLib {
    enum JsmnType {
        UNDEFINED,
        OBJECT,
        ARRAY,
        STRING,
        PRIMITIVE
    }

    uint256 constant RETURN_SUCCESS = 0;
    uint256 constant RETURN_ERROR_INVALID_JSON = 1;
    uint256 constant RETURN_ERROR_PART = 2;
    uint256 constant RETURN_ERROR_NO_MEM = 3;

    struct Token {
        JsmnType jsmnType;
        uint256 start;
        bool startSet;
        uint256 end;
        bool endSet;
        uint8 size;
    }

    struct Parser {
        uint256 pos;
        uint256 toknext;
        int256 toksuper;
    }

    function init(uint256 length)
        internal
        pure
        returns (Parser memory, Token[] memory)
    {
        Parser memory p = Parser(0, 0, -1);
        Token[] memory t = new Token[](length);
        return (p, t);
    }

    function allocateToken(Parser memory parser, Token[] memory tokens)
        internal
        pure
        returns (bool, Token memory)
    {
        if (parser.toknext >= tokens.length) {
            // no more space in tokens
            return (false, tokens[tokens.length - 1]);
        }
        Token memory token = Token(JsmnType.UNDEFINED, 0, false, 0, false, 0);
        tokens[parser.toknext] = token;
        parser.toknext++;
        return (true, token);
    }

    function fillToken(
        Token memory token,
        JsmnType jsmnType,
        uint256 start,
        uint256 end
    ) internal pure {
        token.jsmnType = jsmnType;
        token.start = start;
        token.startSet = true;
        token.end = end;
        token.endSet = true;
        token.size = 0;
    }

    function parseString(
        Parser memory parser,
        Token[] memory tokens,
        bytes memory s
    ) internal pure returns (uint256) {
        uint256 start = parser.pos;
        bool success;
        Token memory token;
        parser.pos++;

        for (; parser.pos < s.length; parser.pos++) {
            bytes1 c = s[parser.pos];

            // Quote -> end of string
            if (c == '"') {
                (success, token) = allocateToken(parser, tokens);
                if (!success) {
                    parser.pos = start;
                    return RETURN_ERROR_NO_MEM;
                }
                fillToken(token, JsmnType.STRING, start + 1, parser.pos);
                return RETURN_SUCCESS;
            }

            if (uint8(c) == 92 && parser.pos + 1 < s.length) {
                // handle escaped characters: skip over it
                parser.pos++;
                if (
                    s[parser.pos] == '"' ||
                    s[parser.pos] == "/" ||
                    s[parser.pos] == "\\" ||
                    s[parser.pos] == "f" ||
                    s[parser.pos] == "r" ||
                    s[parser.pos] == "n" ||
                    s[parser.pos] == "b" ||
                    s[parser.pos] == "t"
                ) {
                    continue;
                } else {
                    // all other values are INVALID
                    parser.pos = start;
                    return (RETURN_ERROR_INVALID_JSON);
                }
            }
        }
        parser.pos = start;
        return RETURN_ERROR_PART;
    }

    function parsePrimitive(
        Parser memory parser,
        Token[] memory tokens,
        bytes memory s
    ) internal pure returns (uint256) {
        bool found = false;
        uint256 start = parser.pos;
        bytes1 c;
        bool success;
        Token memory token;
        for (; parser.pos < s.length; parser.pos++) {
            c = s[parser.pos];
            if (
                c == " " ||
                c == "\t" ||
                c == "\n" ||
                c == "\r" ||
                c == "," ||
                c == 0x7d ||
                c == 0x5d
            ) {
                found = true;
                break;
            }
            if (uint8(c) < 32 || uint8(c) > 127) {
                parser.pos = start;
                return RETURN_ERROR_INVALID_JSON;
            }
        }
        if (!found) {
            parser.pos = start;
            return RETURN_ERROR_PART;
        }

        // found the end
        (success, token) = allocateToken(parser, tokens);
        if (!success) {
            parser.pos = start;
            return RETURN_ERROR_NO_MEM;
        }
        fillToken(token, JsmnType.PRIMITIVE, start, parser.pos);
        parser.pos--;
        return RETURN_SUCCESS;
    }

    function parse(string memory json, uint256 numberElements)
        internal
        pure
        returns (
            uint256,
            Token[] memory tokens,
            uint256
        )
    {
        bytes memory s = bytes(json);
        bool success;
        Parser memory parser;
        (parser, tokens) = init(numberElements);

        // Token memory token;
        uint256 r;
        uint256 count = parser.toknext;
        uint256 i;
        Token memory token;

        for (; parser.pos < s.length; parser.pos++) {
            bytes1 c = s[parser.pos];

            // 0x7b, 0x5b opening curly parentheses or brackets
            if (c == 0x7b || c == 0x5b) {
                count++;
                (success, token) = allocateToken(parser, tokens);
                if (!success) {
                    return (RETURN_ERROR_NO_MEM, tokens, 0);
                }
                if (parser.toksuper != -1) {
                    tokens[uint256(parser.toksuper)].size++;
                }
                token.jsmnType = (c == 0x7b ? JsmnType.OBJECT : JsmnType.ARRAY);
                token.start = parser.pos;
                token.startSet = true;
                parser.toksuper = int256(parser.toknext - 1);
                continue;
            }

            // closing curly parentheses or brackets
            if (c == 0x7d || c == 0x5d) {
                JsmnType tokenType = (
                    c == 0x7d ? JsmnType.OBJECT : JsmnType.ARRAY
                );
                bool isUpdated = false;
                for (i = parser.toknext - 1; i >= 0; i--) {
                    token = tokens[i];
                    if (token.startSet && !token.endSet) {
                        if (token.jsmnType != tokenType) {
                            // found a token that hasn't been closed but from a different type
                            return (RETURN_ERROR_INVALID_JSON, tokens, 0);
                        }
                        parser.toksuper = -1;
                        tokens[i].end = parser.pos + 1;
                        tokens[i].endSet = true;
                        isUpdated = true;
                        break;
                    }
                }
                if (!isUpdated) {
                    return (RETURN_ERROR_INVALID_JSON, tokens, 0);
                }
                for (; i > 0; i--) {
                    token = tokens[i];
                    if (token.startSet && !token.endSet) {
                        parser.toksuper = int256(i);
                        break;
                    }
                }

                if (i == 0) {
                    token = tokens[i];
                    if (token.startSet && !token.endSet) {
                        parser.toksuper = int128(uint128(i));
                    }
                }
                continue;
            }

            // 0x42
            if (c == '"') {
                r = parseString(parser, tokens, s);

                if (r != RETURN_SUCCESS) {
                    return (r, tokens, 0);
                }
                //JsmnError.INVALID;
                count++;
                if (parser.toksuper != -1)
                    tokens[uint256(parser.toksuper)].size++;
                continue;
            }

            // ' ', \r, \t, \n
            if (c == " " || c == 0x11 || c == 0x12 || c == 0x14) {
                continue;
            }

            // 0x3a
            if (c == ":") {
                parser.toksuper = int256(parser.toknext - 1);
                continue;
            }

            if (c == ",") {
                if (
                    parser.toksuper != -1 &&
                    tokens[uint256(parser.toksuper)].jsmnType !=
                    JsmnType.ARRAY &&
                    tokens[uint256(parser.toksuper)].jsmnType != JsmnType.OBJECT
                ) {
                    for (i = parser.toknext - 1; i >= 0; i--) {
                        if (
                            tokens[i].jsmnType == JsmnType.ARRAY ||
                            tokens[i].jsmnType == JsmnType.OBJECT
                        ) {
                            if (tokens[i].startSet && !tokens[i].endSet) {
                                parser.toksuper = int256(i);
                                break;
                            }
                        }
                    }
                }
                continue;
            }

            // Primitive
            if (
                (c >= "0" && c <= "9") ||
                c == "-" ||
                c == "f" ||
                c == "t" ||
                c == "n"
            ) {
                if (parser.toksuper != -1) {
                    token = tokens[uint256(parser.toksuper)];
                    if (
                        token.jsmnType == JsmnType.OBJECT ||
                        (token.jsmnType == JsmnType.STRING && token.size != 0)
                    ) {
                        return (RETURN_ERROR_INVALID_JSON, tokens, 0);
                    }
                }

                r = parsePrimitive(parser, tokens, s);
                if (r != RETURN_SUCCESS) {
                    return (r, tokens, 0);
                }
                count++;
                if (parser.toksuper != -1) {
                    tokens[uint256(parser.toksuper)].size++;
                }
                continue;
            }

            // printable char
            if (c >= 0x20 && c <= 0x7e) {
                return (RETURN_ERROR_INVALID_JSON, tokens, 0);
            }
        }

        return (RETURN_SUCCESS, tokens, parser.toknext);
    }

    function getBytes(
        string memory json,
        uint256 start,
        uint256 end
    ) internal pure returns (string memory) {
        bytes memory s = bytes(json);
        bytes memory result = new bytes(end - start);
        for (uint256 i = start; i < end; i++) {
            result[i - start] = s[i];
        }
        return string(result);
    }

    // parseInt
    function parseInt(string memory _a) internal pure returns (int256) {
        return parseInt(_a, 0);
    }

    // parseInt(parseFloat*10^_b)
    function parseInt(string memory _a, uint256 _b)
        internal
        pure
        returns (int256)
    {
        bytes memory bresult = bytes(_a);
        int256 mint = 0;
        bool decimals = false;
        bool negative = false;
        for (uint256 i = 0; i < bresult.length; i++) {
            if ((i == 0) && (bresult[i] == "-")) {
                negative = true;
            }
            if ((uint8(bresult[i]) >= 48) && (uint8(bresult[i]) <= 57)) {
                if (decimals) {
                    if (_b == 0) break;
                    else _b--;
                }
                mint *= 10;
                mint += int256(uint256(uint8(bresult[i]) - 48));
            } else if (uint8(bresult[i]) == 46) decimals = true;
        }
        if (_b > 0) mint *= int256(10**_b);
        if (negative) mint *= -1;
        return mint;
    }

    function uint2str(uint256 i) internal pure returns (string memory) {
        if (i == 0) return "0";
        uint256 j = i;
        uint256 len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint256 k = len - 1;
        while (i != 0) {
            bstr[k--] = bytes1(uint8(48 + (i % 10)));
            i /= 10;
        }
        return string(bstr);
    }

    function parseBool(string memory _a) internal pure returns (bool) {
        if (strCompare(_a, "true") == 0) {
            return true;
        } else {
            return false;
        }
    }

    function strCompare(string memory _a, string memory _b)
        internal
        pure
        returns (int256)
    {
        bytes memory a = bytes(_a);
        bytes memory b = bytes(_b);
        uint256 minLength = a.length;
        if (b.length < minLength) minLength = b.length;
        for (uint256 i = 0; i < minLength; i++)
            if (a[i] < b[i]) return -1;
            else if (a[i] > b[i]) return 1;
        if (a.length < b.length) return -1;
        else if (a.length > b.length) return 1;
        else return 0;
    }

    function addressToString(address addr)
        internal
        pure
        returns (string memory)
    {
        //Convert addr to bytes
        bytes20 value = bytes20(uint160(addr));
        bytes memory strBytes = new bytes(42);
        //Encode hex prefix
        strBytes[0] = "0";
        strBytes[1] = "x";
        //Encode bytes usig hex encoding
        for (uint256 i = 0; i < 20; i++) {
            uint8 byteValue = uint8(value[i]);
            strBytes[2 + (i << 1)] = encode((byteValue >> 4) & 0x0f);
            strBytes[3 + (i << 1)] = encode(byteValue & 0x0f);
        }
        return string(strBytes);
    }

    function stringToAddress(string memory data)
        internal
        pure
        returns (address)
    {
        bytes memory strBytes = bytes(data);
        require(
            strBytes.length >= 39 && strBytes.length <= 42,
            "Not hex string"
        );
        //Skip prefix
        uint256 start = 0;
        uint256 bytesBegin = 0;
        if (strBytes[1] == "x" || strBytes[1] == "X") {
            start = 2;
        }
        //Special case: 0xabc. should be 0x0abc
        uint160 addrValue = 0;
        uint256 effectPayloadLen = strBytes.length - start;
        if (effectPayloadLen == 39) {
            addrValue += decode(strBytes[start++]);
            bytesBegin++;
        }
        //Main loop
        for (uint256 i = bytesBegin; i < 20; i++) {
            addrValue <<= 8;
            uint8 tmp1 = decode(strBytes[start]);
            uint8 tmp2 = decode(strBytes[start + 1]);
            uint8 combined = (tmp1 << 4) + tmp2;
            addrValue += combined;
            start += 2;
        }

        return address(addrValue);
    }

    function decode(bytes1 asc) private pure returns (uint8) {
        uint8 val = uint8(asc);
        //0-9
        if (val >= 48 && val <= 57) {
            return val - 48;
        }
        //A-F
        if (val >= 65 && val <= 70) {
            return val - 55;
        }
        //a-f
        return val - 87;
    }

    function encode(uint8 num) private pure returns (bytes1) {
        //0-9 -> 0-9
        if (num >= 0 && num <= 9) {
            return bytes1(num + 48);
        }
        //10-15 -> a-f
        return bytes1(num + 87);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract inputData {
    string constant p1 = '{"p":"erc-20","op":"deploy","tick":"';
    string constant m1 = '","max":"';
  
    function mintData(string memory tick, string memory amt)
        public
        pure
        returns (string memory json, bytes memory jsonHex)
    {
       
        json = mintString(tick,amt);
        jsonHex = bytes(json);
    }

    function mintString(string memory tick, string memory amt)
        internal   
        pure
        returns (string memory json)
    {
        string memory p = '{"p":"erc-20","op":"mint","tick":"';
        string memory m = '","amt":"';
        string memory s = '"}';
        json = string(abi.encodePacked(p, tick, m, amt, s));
    }
   
    function transferData(
        string memory tick,
        string memory to,
        string memory amt
    ) public pure returns (string memory json, bytes memory jsonHex) {
        string memory p = '{"p":"erc-20","op":"transfer","tick":"';
        string memory m = '","amt":"';
        string memory m2 = '", "to":"';
        string memory s = '"}';
        json = string(abi.encodePacked(p, tick, m, amt, m2, to, s));
        jsonHex = bytes(json);
    }

    function depyoyData(
        string memory tick,
        string memory max,
        string memory lim,
        string memory maxMint,
        string memory mintPrice,
        string memory reserve
    ) public pure returns (string memory json, bytes memory jsonHex) {
        string memory m2 = '","lim":"';
        string memory m3 = '","maxMint":"';
        string memory m4 = '","mintPrice":"';
        string memory m5 = '","reserve":"';
        string memory s = '"}';
        bytes memory ss= abi.encodePacked(lim, m3, maxMint, m4, mintPrice, m5, reserve, s);
        json = string(abi.encodePacked(p1, tick, m1, max, m2,ss));
        jsonHex = bytes(json);
    }

    function transferFromData(
        string memory tick,
        string memory to,
        string memory amt,
         string memory from
    ) public pure returns (string memory json, bytes memory jsonHex) {
        string memory p = '{"p":"erc-20","op":"transferFrom","tick":"';
        string memory m = '","amt":"';
        string memory m2 = '", "to":"';
         string memory m3 = '", "from":"';
        string memory s = '"}';
        json = string(abi.encodePacked(p, tick, m, amt, m2, to, m3, from, s));
        jsonHex = bytes(json);
    }
    function approveData(
        string memory tick,
        string memory to,
        string memory amt
    ) public pure returns (string memory json, bytes memory jsonHex) {
        string memory p = '{"p":"erc-20","op":"approve","tick":"';
        string memory m = '","amt":"';
        string memory m2 = '", "to":"';
        string memory s = '"}';
        json = string(abi.encodePacked(p, tick, m, amt, m2, to, s));
        jsonHex = bytes(json);
    }
}

{
  "compilationTarget": {
    "Inscription.sol": "Inscription"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}