clawcontract 0.1.0

package/dist/generator/templates/erc721.sol.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.sol.js.map

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

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

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

@@ -0,0 +1,21 @@
+export { ERC20_TEMPLATE } from "./erc20.js";
+export { ERC721_TEMPLATE } from "./erc721.js";
+export { STAKING_TEMPLATE } from "./staking.js";
+export { VESTING_TEMPLATE } from "./vesting.js";
+export { MULTISIG_TEMPLATE } from "./multisig.js";
+export interface ContractTemplate {
+    name: string;
+    description: string;
+    template: string;
+    placeholders: string[];
+    keywords: string[];
+}
+export declare const TEMPLATES: ContractTemplate[];
+export interface TemplateMatch {
+    template: ContractTemplate;
+    score: number;
+    confidence: "high" | "low";
+}
+export declare function findTemplateByKeyword(query: string): TemplateMatch | null;
+export declare function fillTemplate(template: string, values: Record<string, string>): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generator/templates/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,eAAO,MAAM,SAAS,EAAE,gBAAgB,EAsHvC,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,KAAK,CAAC;CAC5B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CA0BzE;AAED,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAOR"}

package/dist/generator/templates/index.js

@@ -0,0 +1,157 @@
+import { ERC20_TEMPLATE } from "./erc20.js";
+import { ERC721_TEMPLATE } from "./erc721.js";
+import { STAKING_TEMPLATE } from "./staking.js";
+import { VESTING_TEMPLATE } from "./vesting.js";
+import { MULTISIG_TEMPLATE } from "./multisig.js";
+export { ERC20_TEMPLATE } from "./erc20.js";
+export { ERC721_TEMPLATE } from "./erc721.js";
+export { STAKING_TEMPLATE } from "./staking.js";
+export { VESTING_TEMPLATE } from "./vesting.js";
+export { MULTISIG_TEMPLATE } from "./multisig.js";
+export const TEMPLATES = [
+    {
+        name: "ERC-20 Token",
+        description: "A standard fungible token with mint, burn, and pause functionality. Suitable for creating custom tokens on BSC.",
+        template: ERC20_TEMPLATE,
+        placeholders: [
+            "{{TOKEN_NAME}}",
+            "{{TOKEN_SYMBOL}}",
+            "{{DECIMALS}}",
+            "{{INITIAL_SUPPLY}}",
+            "{{OWNER_ADDRESS}}",
+        ],
+        keywords: [
+            "token",
+            "coin",
+            "fungible",
+            "erc20",
+            "bep20",
+            "currency",
+            "mint",
+            "mintable",
+            "burnable",
+            "pausable",
+            "supply",
+        ],
+    },
+    {
+        name: "ERC-721 NFT",
+        description: "A non-fungible token contract with auto-incrementing IDs, token URI storage, and owner-only minting.",
+        template: ERC721_TEMPLATE,
+        placeholders: [
+            "{{NFT_NAME}}",
+            "{{NFT_SYMBOL}}",
+            "{{MAX_SUPPLY}}",
+            "{{BASE_URI}}",
+        ],
+        keywords: [
+            "nft",
+            "collectible",
+            "non-fungible",
+            "erc721",
+            "artwork",
+            "digital art",
+            "collection",
+            "mint nft",
+            "pfp",
+            "metadata",
+        ],
+    },
+    {
+        name: "BNB Staking",
+        description: "A staking contract for native BNB with configurable reward rates and time-based reward calculation.",
+        template: STAKING_TEMPLATE,
+        placeholders: ["{{REWARD_RATE}}", "{{MIN_STAKE}}"],
+        keywords: [
+            "stake",
+            "staking",
+            "yield",
+            "farm",
+            "farming",
+            "rewards",
+            "apy",
+            "apr",
+            "earn",
+            "deposit",
+            "bnb staking",
+            "passive income",
+        ],
+    },
+    {
+        name: "Token Vesting",
+        description: "A linear token vesting contract with cliff period, revocable by owner. Suitable for team token distribution.",
+        template: VESTING_TEMPLATE,
+        placeholders: [
+            "{{TOKEN_ADDRESS}}",
+            "{{BENEFICIARY}}",
+            "{{CLIFF_DURATION}}",
+            "{{VESTING_DURATION}}",
+        ],
+        keywords: [
+            "vesting",
+            "vest",
+            "cliff",
+            "lock",
+            "token lock",
+            "distribution",
+            "team tokens",
+            "schedule",
+            "unlock",
+            "linear vesting",
+            "release",
+        ],
+    },
+    {
+        name: "Multisig Wallet",
+        description: "A multi-signature wallet requiring multiple owner confirmations to execute transactions.",
+        template: MULTISIG_TEMPLATE,
+        placeholders: ["{{REQUIRED_CONFIRMATIONS}}"],
+        keywords: [
+            "multisig",
+            "multi-sig",
+            "multi signature",
+            "wallet",
+            "safe",
+            "gnosis",
+            "treasury",
+            "shared wallet",
+            "governance",
+            "approval",
+            "confirm",
+            "multi-owner",
+        ],
+    },
+];
+export function findTemplateByKeyword(query) {
+    const lower = query.toLowerCase();
+    let bestMatch = null;
+    let bestScore = 0;
+    for (const template of TEMPLATES) {
+        let score = 0;
+        let matchedKeywords = 0;
+        for (const keyword of template.keywords) {
+            if (lower.includes(keyword)) {
+                score += keyword.length;
+                matchedKeywords++;
+            }
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestMatch = template;
+        }
+    }
+    if (!bestMatch || bestScore === 0) {
+        return null;
+    }
+    const confidence = bestScore >= 8 ? "high" : "low";
+    return { template: bestMatch, score: bestScore, confidence };
+}
+export function fillTemplate(template, values) {
+    let result = template;
+    for (const [placeholder, value] of Object.entries(values)) {
+        const key = placeholder.startsWith("{{") ? placeholder : `{{${placeholder}}}`;
+        result = result.split(key).join(value);
+    }
+    return result;
+}
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const MULTISIG_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ncontract MultisigWallet {\n    address[] public owners;\n    uint256 public required;\n    uint256 public transactionCount;\n\n    struct Transaction {\n        address to;\n        uint256 value;\n        bytes data;\n        bool executed;\n        uint256 confirmations;\n    }\n\n    mapping(uint256 => Transaction) public transactions;\n    mapping(address => bool) public isOwner;\n    mapping(uint256 => mapping(address => bool)) public confirmations;\n\n    event Submitted(uint256 indexed txId, address indexed submitter, address indexed to, uint256 value);\n    event Confirmed(uint256 indexed txId, address indexed confirmer);\n    event Revoked(uint256 indexed txId, address indexed revoker);\n    event Executed(uint256 indexed txId);\n    event ExecutionFailed(uint256 indexed txId);\n    event Deposited(address indexed sender, uint256 value);\n\n    modifier onlyOwner() {\n        require(isOwner[msg.sender], \"Not owner\");\n        _;\n    }\n\n    modifier txExists(uint256 txId) {\n        require(txId < transactionCount, \"Tx does not exist\");\n        _;\n    }\n\n    modifier notExecuted(uint256 txId) {\n        require(!transactions[txId].executed, \"Already executed\");\n        _;\n    }\n\n    modifier notConfirmed(uint256 txId) {\n        require(!confirmations[txId][msg.sender], \"Already confirmed\");\n        _;\n    }\n\n    constructor(address[] memory _owners) {\n        require(_owners.length > 0, \"Owners required\");\n        uint256 _required = {{REQUIRED_CONFIRMATIONS}};\n        require(_required > 0 && _required <= _owners.length, \"Invalid required count\");\n        for (uint256 i = 0; i < _owners.length; i++) {\n            address o = _owners[i];\n            require(o != address(0), \"Invalid owner\");\n            require(!isOwner[o], \"Duplicate owner\");\n            isOwner[o] = true;\n            owners.push(o);\n        }\n        required = _required;\n    }\n\n    function submit(address to, uint256 value, bytes calldata data) external onlyOwner returns (uint256) {\n        uint256 txId = transactionCount;\n        transactions[txId] = Transaction({\n            to: to,\n            value: value,\n            data: data,\n            executed: false,\n            confirmations: 0\n        });\n        transactionCount++;\n        emit Submitted(txId, msg.sender, to, value);\n        return txId;\n    }\n\n    function confirm(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) notConfirmed(txId) {\n        Transaction storage t = transactions[txId];\n        t.confirmations++;\n        confirmations[txId][msg.sender] = true;\n        emit Confirmed(txId, msg.sender);\n    }\n\n    function execute(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {\n        Transaction storage t = transactions[txId];\n        require(t.confirmations >= required, \"Not enough confirmations\");\n        t.executed = true;\n        (bool success, ) = t.to.call{value: t.value}(t.data);\n        if (success) {\n            emit Executed(txId);\n        } else {\n            t.executed = false;\n            emit ExecutionFailed(txId);\n        }\n    }\n\n    function revoke(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {\n        require(confirmations[txId][msg.sender], \"Not confirmed\");\n        Transaction storage t = transactions[txId];\n        t.confirmations--;\n        confirmations[txId][msg.sender] = false;\n        emit Revoked(txId, msg.sender);\n    }\n\n    function getOwners() external view returns (address[] memory) {\n        return owners;\n    }\n\n    function getTransaction(uint256 txId) external view txExists(txId) returns (\n        address to,\n        uint256 value,\n        bytes memory data,\n        bool executed,\n        uint256 numConfirmations\n    ) {\n        Transaction storage t = transactions[txId];\n        return (t.to, t.value, t.data, t.executed, t.confirmations);\n    }\n\n    function getTransactionCount(bool pending, bool executed) external view returns (uint256 count) {\n        for (uint256 i = 0; i < transactionCount; i++) {\n            if ((pending && !transactions[i].executed) || (executed && transactions[i].executed)) {\n                count++;\n            }\n        }\n    }\n\n    function isConfirmed(uint256 txId) external view returns (bool) {\n        return transactions[txId].confirmations >= required;\n    }\n\n    receive() external payable {\n        emit Deposited(msg.sender, msg.value);\n    }\n}\n";
+//# sourceMappingURL=multisig.d.ts.map

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

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

package/dist/generator/templates/multisig.js

@@ -0,0 +1,136 @@
+export const MULTISIG_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract MultisigWallet {
+    address[] public owners;
+    uint256 public required;
+    uint256 public transactionCount;
+
+    struct Transaction {
+        address to;
+        uint256 value;
+        bytes data;
+        bool executed;
+        uint256 confirmations;
+    }
+
+    mapping(uint256 => Transaction) public transactions;
+    mapping(address => bool) public isOwner;
+    mapping(uint256 => mapping(address => bool)) public confirmations;
+
+    event Submitted(uint256 indexed txId, address indexed submitter, address indexed to, uint256 value);
+    event Confirmed(uint256 indexed txId, address indexed confirmer);
+    event Revoked(uint256 indexed txId, address indexed revoker);
+    event Executed(uint256 indexed txId);
+    event ExecutionFailed(uint256 indexed txId);
+    event Deposited(address indexed sender, uint256 value);
+
+    modifier onlyOwner() {
+        require(isOwner[msg.sender], "Not owner");
+        _;
+    }
+
+    modifier txExists(uint256 txId) {
+        require(txId < transactionCount, "Tx does not exist");
+        _;
+    }
+
+    modifier notExecuted(uint256 txId) {
+        require(!transactions[txId].executed, "Already executed");
+        _;
+    }
+
+    modifier notConfirmed(uint256 txId) {
+        require(!confirmations[txId][msg.sender], "Already confirmed");
+        _;
+    }
+
+    constructor(address[] memory _owners) {
+        require(_owners.length > 0, "Owners required");
+        uint256 _required = {{REQUIRED_CONFIRMATIONS}};
+        require(_required > 0 && _required <= _owners.length, "Invalid required count");
+        for (uint256 i = 0; i < _owners.length; i++) {
+            address o = _owners[i];
+            require(o != address(0), "Invalid owner");
+            require(!isOwner[o], "Duplicate owner");
+            isOwner[o] = true;
+            owners.push(o);
+        }
+        required = _required;
+    }
+
+    function submit(address to, uint256 value, bytes calldata data) external onlyOwner returns (uint256) {
+        uint256 txId = transactionCount;
+        transactions[txId] = Transaction({
+            to: to,
+            value: value,
+            data: data,
+            executed: false,
+            confirmations: 0
+        });
+        transactionCount++;
+        emit Submitted(txId, msg.sender, to, value);
+        return txId;
+    }
+
+    function confirm(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) notConfirmed(txId) {
+        Transaction storage t = transactions[txId];
+        t.confirmations++;
+        confirmations[txId][msg.sender] = true;
+        emit Confirmed(txId, msg.sender);
+    }
+
+    function execute(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {
+        Transaction storage t = transactions[txId];
+        require(t.confirmations >= required, "Not enough confirmations");
+        t.executed = true;
+        (bool success, ) = t.to.call{value: t.value}(t.data);
+        if (success) {
+            emit Executed(txId);
+        } else {
+            t.executed = false;
+            emit ExecutionFailed(txId);
+        }
+    }
+
+    function revoke(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {
+        require(confirmations[txId][msg.sender], "Not confirmed");
+        Transaction storage t = transactions[txId];
+        t.confirmations--;
+        confirmations[txId][msg.sender] = false;
+        emit Revoked(txId, msg.sender);
+    }
+
+    function getOwners() external view returns (address[] memory) {
+        return owners;
+    }
+
+    function getTransaction(uint256 txId) external view txExists(txId) returns (
+        address to,
+        uint256 value,
+        bytes memory data,
+        bool executed,
+        uint256 numConfirmations
+    ) {
+        Transaction storage t = transactions[txId];
+        return (t.to, t.value, t.data, t.executed, t.confirmations);
+    }
+
+    function getTransactionCount(bool pending, bool executed) external view returns (uint256 count) {
+        for (uint256 i = 0; i < transactionCount; i++) {
+            if ((pending && !transactions[i].executed) || (executed && transactions[i].executed)) {
+                count++;
+            }
+        }
+    }
+
+    function isConfirmed(uint256 txId) external view returns (bool) {
+        return transactions[txId].confirmations >= required;
+    }
+
+    receive() external payable {
+        emit Deposited(msg.sender, msg.value);
+    }
+}
+`;
+//# sourceMappingURL=multisig.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const MULTISIG_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ncontract MultisigWallet {\n    address[] public owners;\n    uint256 public required;\n    uint256 public transactionCount;\n\n    struct Transaction {\n        address to;\n        uint256 value;\n        bytes data;\n        bool executed;\n        uint256 confirmations;\n    }\n\n    mapping(uint256 => Transaction) public transactions;\n    mapping(address => bool) public isOwner;\n    mapping(uint256 => mapping(address => bool)) public confirmations;\n\n    event Submitted(uint256 indexed txId, address indexed submitter, address indexed to, uint256 value);\n    event Confirmed(uint256 indexed txId, address indexed confirmer);\n    event Revoked(uint256 indexed txId, address indexed revoker);\n    event Executed(uint256 indexed txId);\n    event ExecutionFailed(uint256 indexed txId);\n    event Deposited(address indexed sender, uint256 value);\n\n    modifier onlyOwner() {\n        require(isOwner[msg.sender], \"Not owner\");\n        _;\n    }\n\n    modifier txExists(uint256 txId) {\n        require(txId < transactionCount, \"Tx does not exist\");\n        _;\n    }\n\n    modifier notExecuted(uint256 txId) {\n        require(!transactions[txId].executed, \"Already executed\");\n        _;\n    }\n\n    modifier notConfirmed(uint256 txId) {\n        require(!confirmations[txId][msg.sender], \"Already confirmed\");\n        _;\n    }\n\n    constructor(address[] memory _owners) {\n        require(_owners.length > 0, \"Owners required\");\n        uint256 _required = {{REQUIRED_CONFIRMATIONS}};\n        require(_required > 0 && _required <= _owners.length, \"Invalid required count\");\n        for (uint256 i = 0; i < _owners.length; i++) {\n            address o = _owners[i];\n            require(o != address(0), \"Invalid owner\");\n            require(!isOwner[o], \"Duplicate owner\");\n            isOwner[o] = true;\n            owners.push(o);\n        }\n        required = _required;\n    }\n\n    function submit(address to, uint256 value, bytes calldata data) external onlyOwner returns (uint256) {\n        uint256 txId = transactionCount;\n        transactions[txId] = Transaction({\n            to: to,\n            value: value,\n            data: data,\n            executed: false,\n            confirmations: 0\n        });\n        transactionCount++;\n        emit Submitted(txId, msg.sender, to, value);\n        return txId;\n    }\n\n    function confirm(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) notConfirmed(txId) {\n        Transaction storage t = transactions[txId];\n        t.confirmations++;\n        confirmations[txId][msg.sender] = true;\n        emit Confirmed(txId, msg.sender);\n    }\n\n    function execute(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {\n        Transaction storage t = transactions[txId];\n        require(t.confirmations >= required, \"Not enough confirmations\");\n        t.executed = true;\n        (bool success, ) = t.to.call{value: t.value}(t.data);\n        if (success) {\n            emit Executed(txId);\n        } else {\n            t.executed = false;\n            emit ExecutionFailed(txId);\n        }\n    }\n\n    function revoke(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {\n        require(confirmations[txId][msg.sender], \"Not confirmed\");\n        Transaction storage t = transactions[txId];\n        t.confirmations--;\n        confirmations[txId][msg.sender] = false;\n        emit Revoked(txId, msg.sender);\n    }\n\n    function getOwners() external view returns (address[] memory) {\n        return owners;\n    }\n\n    function getTransaction(uint256 txId) external view txExists(txId) returns (\n        address to,\n        uint256 value,\n        bytes memory data,\n        bool executed,\n        uint256 numConfirmations\n    ) {\n        Transaction storage t = transactions[txId];\n        return (t.to, t.value, t.data, t.executed, t.confirmations);\n    }\n\n    function getTransactionCount(bool pending, bool executed) external view returns (uint256 count) {\n        for (uint256 i = 0; i < transactionCount; i++) {\n            if ((pending && !transactions[i].executed) || (executed && transactions[i].executed)) {\n                count++;\n            }\n        }\n    }\n\n    function isConfirmed(uint256 txId) external view returns (bool) {\n        return transactions[txId].confirmations >= required;\n    }\n\n    receive() external payable {\n        emit Deposited(msg.sender, msg.value);\n    }\n}\n";
+//# sourceMappingURL=multisig.sol.d.ts.map

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

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

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

@@ -0,0 +1,136 @@
+export const MULTISIG_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract MultisigWallet {
+    address[] public owners;
+    uint256 public required;
+    uint256 public transactionCount;
+
+    struct Transaction {
+        address to;
+        uint256 value;
+        bytes data;
+        bool executed;
+        uint256 confirmations;
+    }
+
+    mapping(uint256 => Transaction) public transactions;
+    mapping(address => bool) public isOwner;
+    mapping(uint256 => mapping(address => bool)) public confirmations;
+
+    event Submitted(uint256 indexed txId, address indexed submitter, address indexed to, uint256 value);
+    event Confirmed(uint256 indexed txId, address indexed confirmer);
+    event Revoked(uint256 indexed txId, address indexed revoker);
+    event Executed(uint256 indexed txId);
+    event ExecutionFailed(uint256 indexed txId);
+    event Deposited(address indexed sender, uint256 value);
+
+    modifier onlyOwner() {
+        require(isOwner[msg.sender], "Not owner");
+        _;
+    }
+
+    modifier txExists(uint256 txId) {
+        require(txId < transactionCount, "Tx does not exist");
+        _;
+    }
+
+    modifier notExecuted(uint256 txId) {
+        require(!transactions[txId].executed, "Already executed");
+        _;
+    }
+
+    modifier notConfirmed(uint256 txId) {
+        require(!confirmations[txId][msg.sender], "Already confirmed");
+        _;
+    }
+
+    constructor(address[] memory _owners) {
+        require(_owners.length > 0, "Owners required");
+        uint256 _required = {{REQUIRED_CONFIRMATIONS}};
+        require(_required > 0 && _required <= _owners.length, "Invalid required count");
+        for (uint256 i = 0; i < _owners.length; i++) {
+            address o = _owners[i];
+            require(o != address(0), "Invalid owner");
+            require(!isOwner[o], "Duplicate owner");
+            isOwner[o] = true;
+            owners.push(o);
+        }
+        required = _required;
+    }
+
+    function submit(address to, uint256 value, bytes calldata data) external onlyOwner returns (uint256) {
+        uint256 txId = transactionCount;
+        transactions[txId] = Transaction({
+            to: to,
+            value: value,
+            data: data,
+            executed: false,
+            confirmations: 0
+        });
+        transactionCount++;
+        emit Submitted(txId, msg.sender, to, value);
+        return txId;
+    }
+
+    function confirm(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) notConfirmed(txId) {
+        Transaction storage t = transactions[txId];
+        t.confirmations++;
+        confirmations[txId][msg.sender] = true;
+        emit Confirmed(txId, msg.sender);
+    }
+
+    function execute(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {
+        Transaction storage t = transactions[txId];
+        require(t.confirmations >= required, "Not enough confirmations");
+        t.executed = true;
+        (bool success, ) = t.to.call{value: t.value}(t.data);
+        if (success) {
+            emit Executed(txId);
+        } else {
+            t.executed = false;
+            emit ExecutionFailed(txId);
+        }
+    }
+
+    function revoke(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {
+        require(confirmations[txId][msg.sender], "Not confirmed");
+        Transaction storage t = transactions[txId];
+        t.confirmations--;
+        confirmations[txId][msg.sender] = false;
+        emit Revoked(txId, msg.sender);
+    }
+
+    function getOwners() external view returns (address[] memory) {
+        return owners;
+    }
+
+    function getTransaction(uint256 txId) external view txExists(txId) returns (
+        address to,
+        uint256 value,
+        bytes memory data,
+        bool executed,
+        uint256 numConfirmations
+    ) {
+        Transaction storage t = transactions[txId];
+        return (t.to, t.value, t.data, t.executed, t.confirmations);
+    }
+
+    function getTransactionCount(bool pending, bool executed) external view returns (uint256 count) {
+        for (uint256 i = 0; i < transactionCount; i++) {
+            if ((pending && !transactions[i].executed) || (executed && transactions[i].executed)) {
+                count++;
+            }
+        }
+    }
+
+    function isConfirmed(uint256 txId) external view returns (bool) {
+        return transactions[txId].confirmations >= required;
+    }
+
+    receive() external payable {
+        emit Deposited(msg.sender, msg.value);
+    }
+}
+`;
+//# sourceMappingURL=multisig.sol.js.map

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

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