clawcontract 0.1.0

package/dist/generator/llm.js

@@ -0,0 +1,71 @@
+const SOLIDITY_SYSTEM_PROMPT = `You are a Solidity smart contract developer specializing in BNB Smart Chain and opBNB.
+Follow these rules strictly:
+- Use Solidity ^0.8.20
+- Contracts must be fully self-contained with NO import statements
+- Ensure compatibility with BSC and opBNB (EVM-compatible)
+- Always include an SPDX license identifier comment at the top (e.g., // SPDX-License-Identifier: MIT)
+- Return ONLY the Solidity source code, no markdown fences, no explanations`;
+const OPENROUTER_MODEL = process.env.OPENROUTER_MODEL || "anthropic/claude-sonnet-4-20250514";
+const MAX_TOKENS = 4096;
+function stripMarkdownFences(text) {
+    return text.replace(/^```(?:solidity)?\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+}
+async function openRouterChat(apiKey, userMessage) {
+    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/clawcontract",
+            "X-Title": "ClawContract",
+        },
+        body: JSON.stringify({
+            model: OPENROUTER_MODEL,
+            max_tokens: MAX_TOKENS,
+            messages: [
+                { role: "system", content: SOLIDITY_SYSTEM_PROMPT },
+                { role: "user", content: userMessage },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`OpenRouter API error (${response.status}): ${errorText.slice(0, 200)}`);
+    }
+    const data = (await response.json());
+    if (data.error?.message) {
+        throw new Error(`OpenRouter error: ${data.error.message}`);
+    }
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+        throw new Error("No text response from OpenRouter");
+    }
+    return stripMarkdownFences(content.trim());
+}
+function createOpenRouterClient(apiKey) {
+    return {
+        isAvailable: () => true,
+        provider: () => "openrouter",
+        customizeContract: (template, description) => openRouterChat(apiKey, `I have the following Solidity contract template:\n\n${template}\n\nUser request: "${description}"\n\nCustomize this template based on the user's request. Fill in all placeholder values (anything in {{DOUBLE_BRACES}}) with appropriate values extracted from the description. Add any additional features the user requested. Keep the contract self-contained with no imports. Return ONLY the complete Solidity source code.`),
+        generateContract: (description) => openRouterChat(apiKey, `Generate a complete Solidity smart contract based on this description:\n\n"${description}"\n\nThe contract must be:\n- Fully self-contained (no imports)\n- Compatible with BSC/opBNB\n- Using Solidity ^0.8.20\n- Well-structured with appropriate access control\n- Including relevant events and error handling\n\nReturn ONLY the Solidity source code.`),
+        suggestFixes: (code, issues) => {
+            const issueList = issues.map((i, idx) => `${idx + 1}. ${i}`).join("\n");
+            return openRouterChat(apiKey, `The following Solidity contract has security issues found by Slither:\n\nContract:\n${code}\n\nIssues:\n${issueList}\n\nFix all the listed issues and return the corrected Solidity source code. Keep the contract self-contained with no imports. Return ONLY the complete fixed Solidity source code.`);
+        },
+    };
+}
+const NULL_CLIENT = {
+    isAvailable: () => false,
+    provider: () => null,
+    customizeContract: () => { throw new Error("No LLM API key configured. Set OPENROUTER_API_KEY."); },
+    generateContract: () => { throw new Error("No LLM API key configured. Set OPENROUTER_API_KEY."); },
+    suggestFixes: () => { throw new Error("No LLM API key configured. Set OPENROUTER_API_KEY."); },
+};
+export function createLLMClient() {
+    const openrouterKey = process.env.OPENROUTER_API_KEY;
+    if (openrouterKey) {
+        return createOpenRouterClient(openrouterKey);
+    }
+    return NULL_CLIENT;
+}
+//# sourceMappingURL=llm.js.map

package/dist/generator/llm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.js","sourceRoot":"","sources":["../../src/generator/llm.ts"],"names":[],"mappings":"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"}

package/dist/generator/templates/erc20.d.ts

@@ -0,0 +1,2 @@
+export declare const ERC20_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ncontract {{TOKEN_NAME}} {\n    string public name;\n    string public symbol;\n    uint8 public decimals;\n    uint256 public totalSupply;\n    address public owner;\n    bool public paused;\n\n    mapping(address => uint256) public balanceOf;\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    event Transfer(address indexed from, address indexed to, uint256 value);\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Paused(address account);\n    event Unpaused(address account);\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    modifier whenNotPaused() {\n        require(!paused, \"Paused\");\n        _;\n    }\n\n    constructor() {\n        name = \"{{TOKEN_NAME}}\";\n        symbol = \"{{TOKEN_SYMBOL}}\";\n        decimals = {{DECIMALS}};\n        owner = {{OWNER_ADDRESS}};\n        paused = false;\n        uint256 initialSupply = {{INITIAL_SUPPLY}} * (10 ** uint256(decimals));\n        totalSupply = initialSupply;\n        balanceOf[owner] = initialSupply;\n        emit Transfer(address(0), owner, initialSupply);\n    }\n\n    function transfer(address to, uint256 value) external whenNotPaused returns (bool) {\n        require(to != address(0), \"Transfer to zero address\");\n        require(balanceOf[msg.sender] >= value, \"Insufficient balance\");\n        balanceOf[msg.sender] -= value;\n        balanceOf[to] += value;\n        emit Transfer(msg.sender, to, value);\n        return true;\n    }\n\n    function approve(address spender, uint256 value) external whenNotPaused returns (bool) {\n        require(spender != address(0), \"Approve to zero address\");\n        allowance[msg.sender][spender] = value;\n        emit Approval(msg.sender, spender, value);\n        return true;\n    }\n\n    function transferFrom(address from, address to, uint256 value) external whenNotPaused returns (bool) {\n        require(to != address(0), \"Transfer to zero address\");\n        require(balanceOf[from] >= value, \"Insufficient balance\");\n        require(allowance[from][msg.sender] >= value, \"Insufficient allowance\");\n        balanceOf[from] -= value;\n        balanceOf[to] += value;\n        allowance[from][msg.sender] -= value;\n        emit Transfer(from, to, value);\n        return true;\n    }\n\n    function mint(address to, uint256 value) external onlyOwner whenNotPaused {\n        require(to != address(0), \"Mint to zero address\");\n        totalSupply += value;\n        balanceOf[to] += value;\n        emit Transfer(address(0), to, value);\n    }\n\n    function burn(uint256 value) external whenNotPaused {\n        require(balanceOf[msg.sender] >= value, \"Insufficient balance\");\n        balanceOf[msg.sender] -= value;\n        totalSupply -= value;\n        emit Transfer(msg.sender, address(0), value);\n    }\n\n    function pause() external onlyOwner {\n        paused = true;\n        emit Paused(msg.sender);\n    }\n\n    function unpause() external onlyOwner {\n        paused = false;\n        emit Unpaused(msg.sender);\n    }\n\n    function transferOwnership(address newOwner) external onlyOwner {\n        require(newOwner != address(0), \"New owner is zero address\");\n        emit OwnershipTransferred(owner, newOwner);\n        owner = newOwner;\n    }\n\n    function renounceOwnership() external onlyOwner {\n        emit OwnershipTransferred(owner, address(0));\n        owner = address(0);\n    }\n}\n";
+//# sourceMappingURL=erc20.d.ts.map

package/dist/generator/templates/erc20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20.d.ts","sourceRoot":"","sources":["../../../src/generator/templates/erc20.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,glHAwG1B,CAAC"}

package/dist/generator/templates/erc20.js

@@ -0,0 +1,106 @@
+export const ERC20_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract {{TOKEN_NAME}} {
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    uint256 public totalSupply;
+    address public owner;
+    bool public paused;
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Paused(address account);
+    event Unpaused(address account);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    modifier whenNotPaused() {
+        require(!paused, "Paused");
+        _;
+    }
+
+    constructor() {
+        name = "{{TOKEN_NAME}}";
+        symbol = "{{TOKEN_SYMBOL}}";
+        decimals = {{DECIMALS}};
+        owner = {{OWNER_ADDRESS}};
+        paused = false;
+        uint256 initialSupply = {{INITIAL_SUPPLY}} * (10 ** uint256(decimals));
+        totalSupply = initialSupply;
+        balanceOf[owner] = initialSupply;
+        emit Transfer(address(0), owner, initialSupply);
+    }
+
+    function transfer(address to, uint256 value) external whenNotPaused returns (bool) {
+        require(to != address(0), "Transfer to zero address");
+        require(balanceOf[msg.sender] >= value, "Insufficient balance");
+        balanceOf[msg.sender] -= value;
+        balanceOf[to] += value;
+        emit Transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function approve(address spender, uint256 value) external whenNotPaused returns (bool) {
+        require(spender != address(0), "Approve to zero address");
+        allowance[msg.sender][spender] = value;
+        emit Approval(msg.sender, spender, value);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 value) external whenNotPaused returns (bool) {
+        require(to != address(0), "Transfer to zero address");
+        require(balanceOf[from] >= value, "Insufficient balance");
+        require(allowance[from][msg.sender] >= value, "Insufficient allowance");
+        balanceOf[from] -= value;
+        balanceOf[to] += value;
+        allowance[from][msg.sender] -= value;
+        emit Transfer(from, to, value);
+        return true;
+    }
+
+    function mint(address to, uint256 value) external onlyOwner whenNotPaused {
+        require(to != address(0), "Mint to zero address");
+        totalSupply += value;
+        balanceOf[to] += value;
+        emit Transfer(address(0), to, value);
+    }
+
+    function burn(uint256 value) external whenNotPaused {
+        require(balanceOf[msg.sender] >= value, "Insufficient balance");
+        balanceOf[msg.sender] -= value;
+        totalSupply -= value;
+        emit Transfer(msg.sender, address(0), value);
+    }
+
+    function pause() external onlyOwner {
+        paused = true;
+        emit Paused(msg.sender);
+    }
+
+    function unpause() external onlyOwner {
+        paused = false;
+        emit Unpaused(msg.sender);
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    function renounceOwnership() external onlyOwner {
+        emit OwnershipTransferred(owner, address(0));
+        owner = address(0);
+    }
+}
+`;
+//# sourceMappingURL=erc20.js.map

package/dist/generator/templates/erc20.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20.js","sourceRoot":"","sources":["../../../src/generator/templates/erc20.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwG7B,CAAC"}

package/dist/generator/templates/erc20.sol.d.ts

@@ -0,0 +1,2 @@
+export declare const ERC20_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ncontract {{TOKEN_NAME}} {\n    string public name;\n    string public symbol;\n    uint8 public decimals;\n    uint256 public totalSupply;\n    address public owner;\n    bool public paused;\n\n    mapping(address => uint256) public balanceOf;\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    event Transfer(address indexed from, address indexed to, uint256 value);\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Paused(address account);\n    event Unpaused(address account);\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    modifier whenNotPaused() {\n        require(!paused, \"Paused\");\n        _;\n    }\n\n    constructor() {\n        name = \"{{TOKEN_NAME}}\";\n        symbol = \"{{TOKEN_SYMBOL}}\";\n        decimals = {{DECIMALS}};\n        owner = {{OWNER_ADDRESS}};\n        paused = false;\n        uint256 initialSupply = {{INITIAL_SUPPLY}} * (10 ** uint256(decimals));\n        totalSupply = initialSupply;\n        balanceOf[owner] = initialSupply;\n        emit Transfer(address(0), owner, initialSupply);\n    }\n\n    function transfer(address to, uint256 value) external whenNotPaused returns (bool) {\n        require(to != address(0), \"Transfer to zero address\");\n        require(balanceOf[msg.sender] >= value, \"Insufficient balance\");\n        balanceOf[msg.sender] -= value;\n        balanceOf[to] += value;\n        emit Transfer(msg.sender, to, value);\n        return true;\n    }\n\n    function approve(address spender, uint256 value) external whenNotPaused returns (bool) {\n        require(spender != address(0), \"Approve to zero address\");\n        allowance[msg.sender][spender] = value;\n        emit Approval(msg.sender, spender, value);\n        return true;\n    }\n\n    function transferFrom(address from, address to, uint256 value) external whenNotPaused returns (bool) {\n        require(to != address(0), \"Transfer to zero address\");\n        require(balanceOf[from] >= value, \"Insufficient balance\");\n        require(allowance[from][msg.sender] >= value, \"Insufficient allowance\");\n        balanceOf[from] -= value;\n        balanceOf[to] += value;\n        allowance[from][msg.sender] -= value;\n        emit Transfer(from, to, value);\n        return true;\n    }\n\n    function mint(address to, uint256 value) external onlyOwner whenNotPaused {\n        require(to != address(0), \"Mint to zero address\");\n        totalSupply += value;\n        balanceOf[to] += value;\n        emit Transfer(address(0), to, value);\n    }\n\n    function burn(uint256 value) external whenNotPaused {\n        require(balanceOf[msg.sender] >= value, \"Insufficient balance\");\n        balanceOf[msg.sender] -= value;\n        totalSupply -= value;\n        emit Transfer(msg.sender, address(0), value);\n    }\n\n    function pause() external onlyOwner {\n        paused = true;\n        emit Paused(msg.sender);\n    }\n\n    function unpause() external onlyOwner {\n        paused = false;\n        emit Unpaused(msg.sender);\n    }\n\n    function transferOwnership(address newOwner) external onlyOwner {\n        require(newOwner != address(0), \"New owner is zero address\");\n        emit OwnershipTransferred(owner, newOwner);\n        owner = newOwner;\n    }\n\n    function renounceOwnership() external onlyOwner {\n        emit OwnershipTransferred(owner, address(0));\n        owner = address(0);\n    }\n}\n";
+//# sourceMappingURL=erc20.sol.d.ts.map

package/dist/generator/templates/erc20.sol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20.sol.d.ts","sourceRoot":"","sources":["../../../src/generator/templates/erc20.sol.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,glHAwG1B,CAAC"}

package/dist/generator/templates/erc20.sol.js

@@ -0,0 +1,106 @@
+export const ERC20_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract {{TOKEN_NAME}} {
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    uint256 public totalSupply;
+    address public owner;
+    bool public paused;
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Paused(address account);
+    event Unpaused(address account);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    modifier whenNotPaused() {
+        require(!paused, "Paused");
+        _;
+    }
+
+    constructor() {
+        name = "{{TOKEN_NAME}}";
+        symbol = "{{TOKEN_SYMBOL}}";
+        decimals = {{DECIMALS}};
+        owner = {{OWNER_ADDRESS}};
+        paused = false;
+        uint256 initialSupply = {{INITIAL_SUPPLY}} * (10 ** uint256(decimals));
+        totalSupply = initialSupply;
+        balanceOf[owner] = initialSupply;
+        emit Transfer(address(0), owner, initialSupply);
+    }
+
+    function transfer(address to, uint256 value) external whenNotPaused returns (bool) {
+        require(to != address(0), "Transfer to zero address");
+        require(balanceOf[msg.sender] >= value, "Insufficient balance");
+        balanceOf[msg.sender] -= value;
+        balanceOf[to] += value;
+        emit Transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function approve(address spender, uint256 value) external whenNotPaused returns (bool) {
+        require(spender != address(0), "Approve to zero address");
+        allowance[msg.sender][spender] = value;
+        emit Approval(msg.sender, spender, value);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 value) external whenNotPaused returns (bool) {
+        require(to != address(0), "Transfer to zero address");
+        require(balanceOf[from] >= value, "Insufficient balance");
+        require(allowance[from][msg.sender] >= value, "Insufficient allowance");
+        balanceOf[from] -= value;
+        balanceOf[to] += value;
+        allowance[from][msg.sender] -= value;
+        emit Transfer(from, to, value);
+        return true;
+    }
+
+    function mint(address to, uint256 value) external onlyOwner whenNotPaused {
+        require(to != address(0), "Mint to zero address");
+        totalSupply += value;
+        balanceOf[to] += value;
+        emit Transfer(address(0), to, value);
+    }
+
+    function burn(uint256 value) external whenNotPaused {
+        require(balanceOf[msg.sender] >= value, "Insufficient balance");
+        balanceOf[msg.sender] -= value;
+        totalSupply -= value;
+        emit Transfer(msg.sender, address(0), value);
+    }
+
+    function pause() external onlyOwner {
+        paused = true;
+        emit Paused(msg.sender);
+    }
+
+    function unpause() external onlyOwner {
+        paused = false;
+        emit Unpaused(msg.sender);
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    function renounceOwnership() external onlyOwner {
+        emit OwnershipTransferred(owner, address(0));
+        owner = address(0);
+    }
+}
+`;
+//# sourceMappingURL=erc20.sol.js.map

package/dist/generator/templates/erc20.sol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20.sol.js","sourceRoot":"","sources":["../../../src/generator/templates/erc20.sol.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwG7B,CAAC"}

package/dist/generator/templates/erc721.d.ts

@@ -0,0 +1,2 @@
+export declare const ERC721_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IERC721Receiver {\n    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\n}\n\ncontract {{NFT_NAME}} {\n    string public name;\n    string public symbol;\n    string public baseURI;\n    address public owner;\n    uint256 public totalSupply;\n    uint256 public maxSupply;\n\n    mapping(uint256 => address) private _owners;\n    mapping(address => uint256) private _balances;\n    mapping(uint256 => address) private _tokenApprovals;\n    mapping(address => mapping(address => bool)) private _operatorApprovals;\n    mapping(uint256 => string) private _tokenURIs;\n\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    constructor() {\n        name = \"{{NFT_NAME}}\";\n        symbol = \"{{NFT_SYMBOL}}\";\n        baseURI = \"{{BASE_URI}}\";\n        maxSupply = {{MAX_SUPPLY}};\n        owner = msg.sender;\n    }\n\n    function balanceOf(address _owner) external view returns (uint256) {\n        require(_owner != address(0), \"Zero address\");\n        return _balances[_owner];\n    }\n\n    function ownerOf(uint256 tokenId) public view returns (address) {\n        address tokenOwner = _owners[tokenId];\n        require(tokenOwner != address(0), \"Token does not exist\");\n        return tokenOwner;\n    }\n\n    function tokenURI(uint256 tokenId) external view returns (string memory) {\n        require(_owners[tokenId] != address(0), \"Token does not exist\");\n        string memory _tokenURI = _tokenURIs[tokenId];\n        if (bytes(_tokenURI).length > 0) {\n            return _tokenURI;\n        }\n        return string(abi.encodePacked(baseURI, _toString(tokenId)));\n    }\n\n    function approve(address to, uint256 tokenId) external {\n        address tokenOwner = ownerOf(tokenId);\n        require(msg.sender == tokenOwner || _operatorApprovals[tokenOwner][msg.sender], \"Not authorized\");\n        _tokenApprovals[tokenId] = to;\n        emit Approval(tokenOwner, to, tokenId);\n    }\n\n    function getApproved(uint256 tokenId) public view returns (address) {\n        require(_owners[tokenId] != address(0), \"Token does not exist\");\n        return _tokenApprovals[tokenId];\n    }\n\n    function setApprovalForAll(address operator, bool approved) external {\n        require(operator != msg.sender, \"Approve to caller\");\n        _operatorApprovals[msg.sender][operator] = approved;\n        emit ApprovalForAll(msg.sender, operator, approved);\n    }\n\n    function isApprovedForAll(address _owner, address operator) public view returns (bool) {\n        return _operatorApprovals[_owner][operator];\n    }\n\n    function transferFrom(address from, address to, uint256 tokenId) public {\n        require(_isApprovedOrOwner(msg.sender, tokenId), \"Not authorized\");\n        _transfer(from, to, tokenId);\n    }\n\n    function safeTransferFrom(address from, address to, uint256 tokenId) external {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {\n        transferFrom(from, to, tokenId);\n        require(_checkOnERC721Received(from, to, tokenId, data), \"Non-ERC721Receiver\");\n    }\n\n    function mint(address to) external onlyOwner returns (uint256) {\n        require(to != address(0), \"Mint to zero address\");\n        uint256 tokenId = totalSupply + 1;\n        require(tokenId <= maxSupply, \"Max supply reached\");\n        totalSupply = tokenId;\n        _balances[to] += 1;\n        _owners[tokenId] = to;\n        emit Transfer(address(0), to, tokenId);\n        return tokenId;\n    }\n\n    function mintWithURI(address to, string calldata uri) external onlyOwner returns (uint256) {\n        require(to != address(0), \"Mint to zero address\");\n        uint256 tokenId = totalSupply + 1;\n        require(tokenId <= maxSupply, \"Max supply reached\");\n        totalSupply = tokenId;\n        _balances[to] += 1;\n        _owners[tokenId] = to;\n        _tokenURIs[tokenId] = uri;\n        emit Transfer(address(0), to, tokenId);\n        return tokenId;\n    }\n\n    function setBaseURI(string calldata newBaseURI) external onlyOwner {\n        baseURI = newBaseURI;\n    }\n\n    function transferOwnership(address newOwner) external onlyOwner {\n        require(newOwner != address(0), \"New owner is zero address\");\n        owner = newOwner;\n    }\n\n    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {\n        return interfaceId == 0x80ac58cd || interfaceId == 0x5b5e139f || interfaceId == 0x01ffc9a7;\n    }\n\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        require(ownerOf(tokenId) == from, \"Not token owner\");\n        require(to != address(0), \"Transfer to zero address\");\n        _tokenApprovals[tokenId] = address(0);\n        _balances[from] -= 1;\n        _balances[to] += 1;\n        _owners[tokenId] = to;\n        emit Transfer(from, to, tokenId);\n    }\n\n    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {\n        address tokenOwner = ownerOf(tokenId);\n        return (spender == tokenOwner || getApproved(tokenId) == spender || isApprovedForAll(tokenOwner, spender));\n    }\n\n    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private returns (bool) {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {\n                return retval == IERC721Receiver.onERC721Received.selector;\n            } catch {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    function _toString(uint256 value) internal pure returns (string memory) {\n        if (value == 0) return \"0\";\n        uint256 temp = value;\n        uint256 digits;\n        while (temp != 0) { digits++; temp /= 10; }\n        bytes memory buffer = new bytes(digits);\n        while (value != 0) { digits--; buffer[digits] = bytes1(uint8(48 + (value % 10))); value /= 10; }\n        return string(buffer);\n    }\n}\n";
+//# sourceMappingURL=erc721.d.ts.map

package/dist/generator/templates/erc721.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc721.d.ts","sourceRoot":"","sources":["../../../src/generator/templates/erc721.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,06MAsK3B,CAAC"}

package/dist/generator/templates/erc721.js

@@ -0,0 +1,168 @@
+export const ERC721_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IERC721Receiver {
+    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
+}
+
+contract {{NFT_NAME}} {
+    string public name;
+    string public symbol;
+    string public baseURI;
+    address public owner;
+    uint256 public totalSupply;
+    uint256 public maxSupply;
+
+    mapping(uint256 => address) private _owners;
+    mapping(address => uint256) private _balances;
+    mapping(uint256 => address) private _tokenApprovals;
+    mapping(address => mapping(address => bool)) private _operatorApprovals;
+    mapping(uint256 => string) private _tokenURIs;
+
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    constructor() {
+        name = "{{NFT_NAME}}";
+        symbol = "{{NFT_SYMBOL}}";
+        baseURI = "{{BASE_URI}}";
+        maxSupply = {{MAX_SUPPLY}};
+        owner = msg.sender;
+    }
+
+    function balanceOf(address _owner) external view returns (uint256) {
+        require(_owner != address(0), "Zero address");
+        return _balances[_owner];
+    }
+
+    function ownerOf(uint256 tokenId) public view returns (address) {
+        address tokenOwner = _owners[tokenId];
+        require(tokenOwner != address(0), "Token does not exist");
+        return tokenOwner;
+    }
+
+    function tokenURI(uint256 tokenId) external view returns (string memory) {
+        require(_owners[tokenId] != address(0), "Token does not exist");
+        string memory _tokenURI = _tokenURIs[tokenId];
+        if (bytes(_tokenURI).length > 0) {
+            return _tokenURI;
+        }
+        return string(abi.encodePacked(baseURI, _toString(tokenId)));
+    }
+
+    function approve(address to, uint256 tokenId) external {
+        address tokenOwner = ownerOf(tokenId);
+        require(msg.sender == tokenOwner || _operatorApprovals[tokenOwner][msg.sender], "Not authorized");
+        _tokenApprovals[tokenId] = to;
+        emit Approval(tokenOwner, to, tokenId);
+    }
+
+    function getApproved(uint256 tokenId) public view returns (address) {
+        require(_owners[tokenId] != address(0), "Token does not exist");
+        return _tokenApprovals[tokenId];
+    }
+
+    function setApprovalForAll(address operator, bool approved) external {
+        require(operator != msg.sender, "Approve to caller");
+        _operatorApprovals[msg.sender][operator] = approved;
+        emit ApprovalForAll(msg.sender, operator, approved);
+    }
+
+    function isApprovedForAll(address _owner, address operator) public view returns (bool) {
+        return _operatorApprovals[_owner][operator];
+    }
+
+    function transferFrom(address from, address to, uint256 tokenId) public {
+        require(_isApprovedOrOwner(msg.sender, tokenId), "Not authorized");
+        _transfer(from, to, tokenId);
+    }
+
+    function safeTransferFrom(address from, address to, uint256 tokenId) external {
+        safeTransferFrom(from, to, tokenId, "");
+    }
+
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
+        transferFrom(from, to, tokenId);
+        require(_checkOnERC721Received(from, to, tokenId, data), "Non-ERC721Receiver");
+    }
+
+    function mint(address to) external onlyOwner returns (uint256) {
+        require(to != address(0), "Mint to zero address");
+        uint256 tokenId = totalSupply + 1;
+        require(tokenId <= maxSupply, "Max supply reached");
+        totalSupply = tokenId;
+        _balances[to] += 1;
+        _owners[tokenId] = to;
+        emit Transfer(address(0), to, tokenId);
+        return tokenId;
+    }
+
+    function mintWithURI(address to, string calldata uri) external onlyOwner returns (uint256) {
+        require(to != address(0), "Mint to zero address");
+        uint256 tokenId = totalSupply + 1;
+        require(tokenId <= maxSupply, "Max supply reached");
+        totalSupply = tokenId;
+        _balances[to] += 1;
+        _owners[tokenId] = to;
+        _tokenURIs[tokenId] = uri;
+        emit Transfer(address(0), to, tokenId);
+        return tokenId;
+    }
+
+    function setBaseURI(string calldata newBaseURI) external onlyOwner {
+        baseURI = newBaseURI;
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        owner = newOwner;
+    }
+
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
+        return interfaceId == 0x80ac58cd || interfaceId == 0x5b5e139f || interfaceId == 0x01ffc9a7;
+    }
+
+    function _transfer(address from, address to, uint256 tokenId) internal {
+        require(ownerOf(tokenId) == from, "Not token owner");
+        require(to != address(0), "Transfer to zero address");
+        _tokenApprovals[tokenId] = address(0);
+        _balances[from] -= 1;
+        _balances[to] += 1;
+        _owners[tokenId] = to;
+        emit Transfer(from, to, tokenId);
+    }
+
+    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
+        address tokenOwner = ownerOf(tokenId);
+        return (spender == tokenOwner || getApproved(tokenId) == spender || isApprovedForAll(tokenOwner, spender));
+    }
+
+    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private returns (bool) {
+        if (to.code.length > 0) {
+            try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {
+                return retval == IERC721Receiver.onERC721Received.selector;
+            } catch {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function _toString(uint256 value) internal pure returns (string memory) {
+        if (value == 0) return "0";
+        uint256 temp = value;
+        uint256 digits;
+        while (temp != 0) { digits++; temp /= 10; }
+        bytes memory buffer = new bytes(digits);
+        while (value != 0) { digits--; buffer[digits] = bytes1(uint8(48 + (value % 10))); value /= 10; }
+        return string(buffer);
+    }
+}
+`;
+//# sourceMappingURL=erc721.js.map

package/dist/generator/templates/erc721.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc721.js","sourceRoot":"","sources":["../../../src/generator/templates/erc721.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsK9B,CAAC"}

package/dist/generator/templates/erc721.sol.d.ts

@@ -0,0 +1,2 @@
+export declare const ERC721_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IERC721Receiver {\n    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\n}\n\ncontract {{NFT_NAME}} {\n    string public name;\n    string public symbol;\n    string public baseURI;\n    address public owner;\n    uint256 public totalSupply;\n    uint256 public maxSupply;\n\n    mapping(uint256 => address) private _owners;\n    mapping(address => uint256) private _balances;\n    mapping(uint256 => address) private _tokenApprovals;\n    mapping(address => mapping(address => bool)) private _operatorApprovals;\n    mapping(uint256 => string) private _tokenURIs;\n\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    constructor() {\n        name = \"{{NFT_NAME}}\";\n        symbol = \"{{NFT_SYMBOL}}\";\n        baseURI = \"{{BASE_URI}}\";\n        maxSupply = {{MAX_SUPPLY}};\n        owner = msg.sender;\n    }\n\n    function balanceOf(address _owner) external view returns (uint256) {\n        require(_owner != address(0), \"Zero address\");\n        return _balances[_owner];\n    }\n\n    function ownerOf(uint256 tokenId) public view returns (address) {\n        address tokenOwner = _owners[tokenId];\n        require(tokenOwner != address(0), \"Token does not exist\");\n        return tokenOwner;\n    }\n\n    function tokenURI(uint256 tokenId) external view returns (string memory) {\n        require(_owners[tokenId] != address(0), \"Token does not exist\");\n        string memory _tokenURI = _tokenURIs[tokenId];\n        if (bytes(_tokenURI).length > 0) {\n            return _tokenURI;\n        }\n        return string(abi.encodePacked(baseURI, _toString(tokenId)));\n    }\n\n    function approve(address to, uint256 tokenId) external {\n        address tokenOwner = ownerOf(tokenId);\n        require(msg.sender == tokenOwner || _operatorApprovals[tokenOwner][msg.sender], \"Not authorized\");\n        _tokenApprovals[tokenId] = to;\n        emit Approval(tokenOwner, to, tokenId);\n    }\n\n    function getApproved(uint256 tokenId) public view returns (address) {\n        require(_owners[tokenId] != address(0), \"Token does not exist\");\n        return _tokenApprovals[tokenId];\n    }\n\n    function setApprovalForAll(address operator, bool approved) external {\n        require(operator != msg.sender, \"Approve to caller\");\n        _operatorApprovals[msg.sender][operator] = approved;\n        emit ApprovalForAll(msg.sender, operator, approved);\n    }\n\n    function isApprovedForAll(address _owner, address operator) public view returns (bool) {\n        return _operatorApprovals[_owner][operator];\n    }\n\n    function transferFrom(address from, address to, uint256 tokenId) public {\n        require(_isApprovedOrOwner(msg.sender, tokenId), \"Not authorized\");\n        _transfer(from, to, tokenId);\n    }\n\n    function safeTransferFrom(address from, address to, uint256 tokenId) external {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {\n        transferFrom(from, to, tokenId);\n        require(_checkOnERC721Received(from, to, tokenId, data), \"Non-ERC721Receiver\");\n    }\n\n    function mint(address to) external onlyOwner returns (uint256) {\n        require(to != address(0), \"Mint to zero address\");\n        uint256 tokenId = totalSupply + 1;\n        require(tokenId <= maxSupply, \"Max supply reached\");\n        totalSupply = tokenId;\n        _balances[to] += 1;\n        _owners[tokenId] = to;\n        emit Transfer(address(0), to, tokenId);\n        return tokenId;\n    }\n\n    function mintWithURI(address to, string calldata uri) external onlyOwner returns (uint256) {\n        require(to != address(0), \"Mint to zero address\");\n        uint256 tokenId = totalSupply + 1;\n        require(tokenId <= maxSupply, \"Max supply reached\");\n        totalSupply = tokenId;\n        _balances[to] += 1;\n        _owners[tokenId] = to;\n        _tokenURIs[tokenId] = uri;\n        emit Transfer(address(0), to, tokenId);\n        return tokenId;\n    }\n\n    function setBaseURI(string calldata newBaseURI) external onlyOwner {\n        baseURI = newBaseURI;\n    }\n\n    function transferOwnership(address newOwner) external onlyOwner {\n        require(newOwner != address(0), \"New owner is zero address\");\n        owner = newOwner;\n    }\n\n    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {\n        return interfaceId == 0x80ac58cd || interfaceId == 0x5b5e139f || interfaceId == 0x01ffc9a7;\n    }\n\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        require(ownerOf(tokenId) == from, \"Not token owner\");\n        require(to != address(0), \"Transfer to zero address\");\n        _tokenApprovals[tokenId] = address(0);\n        _balances[from] -= 1;\n        _balances[to] += 1;\n        _owners[tokenId] = to;\n        emit Transfer(from, to, tokenId);\n    }\n\n    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {\n        address tokenOwner = ownerOf(tokenId);\n        return (spender == tokenOwner || getApproved(tokenId) == spender || isApprovedForAll(tokenOwner, spender));\n    }\n\n    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private returns (bool) {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {\n                return retval == IERC721Receiver.onERC721Received.selector;\n            } catch {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    function _toString(uint256 value) internal pure returns (string memory) {\n        if (value == 0) return \"0\";\n        uint256 temp = value;\n        uint256 digits;\n        while (temp != 0) { digits++; temp /= 10; }\n        bytes memory buffer = new bytes(digits);\n        while (value != 0) { digits--; buffer[digits] = bytes1(uint8(48 + (value % 10))); value /= 10; }\n        return string(buffer);\n    }\n}\n";
+//# sourceMappingURL=erc721.sol.d.ts.map

package/dist/generator/templates/erc721.sol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc721.sol.d.ts","sourceRoot":"","sources":["../../../src/generator/templates/erc721.sol.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,06MAsK3B,CAAC"}