clawcontract 0.1.0

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

@@ -0,0 +1,2 @@
+export declare const STAKING_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ncontract BNBStaking {\n    address public owner;\n    uint256 public rewardRate;\n    uint256 public minStake;\n    uint256 public totalStaked;\n\n    struct StakeInfo {\n        uint256 amount;\n        uint256 stakedAt;\n        uint256 rewardDebt;\n    }\n\n    mapping(address => StakeInfo) public stakes;\n\n    event Staked(address indexed user, uint256 amount);\n    event Unstaked(address indexed user, uint256 amount);\n    event RewardClaimed(address indexed user, uint256 reward);\n    event RewardsFunded(address indexed funder, uint256 amount);\n    event RewardRateUpdated(uint256 oldRate, uint256 newRate);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    constructor() {\n        owner = msg.sender;\n        rewardRate = {{REWARD_RATE}};\n        minStake = {{MIN_STAKE}};\n    }\n\n    function stake() external payable {\n        require(msg.value >= minStake, \"Below minimum stake\");\n        StakeInfo storage info = stakes[msg.sender];\n        if (info.amount > 0) {\n            uint256 pending = _pendingReward(msg.sender);\n            if (pending > 0) {\n                info.rewardDebt += pending;\n            }\n        }\n        info.amount += msg.value;\n        info.stakedAt = block.timestamp;\n        totalStaked += msg.value;\n        emit Staked(msg.sender, msg.value);\n    }\n\n    function unstake(uint256 amount) external {\n        StakeInfo storage info = stakes[msg.sender];\n        require(info.amount >= amount, \"Insufficient stake\");\n        uint256 pending = _pendingReward(msg.sender) + info.rewardDebt;\n        info.amount -= amount;\n        info.stakedAt = block.timestamp;\n        info.rewardDebt = 0;\n        totalStaked -= amount;\n        uint256 total = amount + pending;\n        require(address(this).balance >= total, \"Insufficient contract balance\");\n        (bool success, ) = payable(msg.sender).call{value: total}(\"\");\n        require(success, \"Transfer failed\");\n        emit Unstaked(msg.sender, amount);\n        if (pending > 0) {\n            emit RewardClaimed(msg.sender, pending);\n        }\n    }\n\n    function claimReward() external {\n        uint256 pending = _pendingReward(msg.sender) + stakes[msg.sender].rewardDebt;\n        require(pending > 0, \"No rewards\");\n        stakes[msg.sender].stakedAt = block.timestamp;\n        stakes[msg.sender].rewardDebt = 0;\n        require(address(this).balance >= pending, \"Insufficient contract balance\");\n        (bool success, ) = payable(msg.sender).call{value: pending}(\"\");\n        require(success, \"Transfer failed\");\n        emit RewardClaimed(msg.sender, pending);\n    }\n\n    function pendingReward(address user) external view returns (uint256) {\n        return _pendingReward(user) + stakes[user].rewardDebt;\n    }\n\n    function fundRewards() external payable onlyOwner {\n        require(msg.value > 0, \"Must send BNB\");\n        emit RewardsFunded(msg.sender, msg.value);\n    }\n\n    function setRewardRate(uint256 newRate) external onlyOwner {\n        emit RewardRateUpdated(rewardRate, newRate);\n        rewardRate = newRate;\n    }\n\n    function setMinStake(uint256 newMin) external onlyOwner {\n        minStake = newMin;\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 getStakeInfo(address user) external view returns (uint256 amount, uint256 stakedAt, uint256 pending) {\n        StakeInfo storage info = stakes[user];\n        return (info.amount, info.stakedAt, _pendingReward(user) + info.rewardDebt);\n    }\n\n    function _pendingReward(address user) internal view returns (uint256) {\n        StakeInfo storage info = stakes[user];\n        if (info.amount == 0) return 0;\n        uint256 duration = block.timestamp - info.stakedAt;\n        return (info.amount * rewardRate * duration) / (365 days * 10000);\n    }\n\n    receive() external payable {\n        emit RewardsFunded(msg.sender, msg.value);\n    }\n}\n";
+//# sourceMappingURL=staking.d.ts.map

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

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

package/dist/generator/templates/staking.js

@@ -0,0 +1,119 @@
+export const STAKING_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract BNBStaking {
+    address public owner;
+    uint256 public rewardRate;
+    uint256 public minStake;
+    uint256 public totalStaked;
+
+    struct StakeInfo {
+        uint256 amount;
+        uint256 stakedAt;
+        uint256 rewardDebt;
+    }
+
+    mapping(address => StakeInfo) public stakes;
+
+    event Staked(address indexed user, uint256 amount);
+    event Unstaked(address indexed user, uint256 amount);
+    event RewardClaimed(address indexed user, uint256 reward);
+    event RewardsFunded(address indexed funder, uint256 amount);
+    event RewardRateUpdated(uint256 oldRate, uint256 newRate);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    constructor() {
+        owner = msg.sender;
+        rewardRate = {{REWARD_RATE}};
+        minStake = {{MIN_STAKE}};
+    }
+
+    function stake() external payable {
+        require(msg.value >= minStake, "Below minimum stake");
+        StakeInfo storage info = stakes[msg.sender];
+        if (info.amount > 0) {
+            uint256 pending = _pendingReward(msg.sender);
+            if (pending > 0) {
+                info.rewardDebt += pending;
+            }
+        }
+        info.amount += msg.value;
+        info.stakedAt = block.timestamp;
+        totalStaked += msg.value;
+        emit Staked(msg.sender, msg.value);
+    }
+
+    function unstake(uint256 amount) external {
+        StakeInfo storage info = stakes[msg.sender];
+        require(info.amount >= amount, "Insufficient stake");
+        uint256 pending = _pendingReward(msg.sender) + info.rewardDebt;
+        info.amount -= amount;
+        info.stakedAt = block.timestamp;
+        info.rewardDebt = 0;
+        totalStaked -= amount;
+        uint256 total = amount + pending;
+        require(address(this).balance >= total, "Insufficient contract balance");
+        (bool success, ) = payable(msg.sender).call{value: total}("");
+        require(success, "Transfer failed");
+        emit Unstaked(msg.sender, amount);
+        if (pending > 0) {
+            emit RewardClaimed(msg.sender, pending);
+        }
+    }
+
+    function claimReward() external {
+        uint256 pending = _pendingReward(msg.sender) + stakes[msg.sender].rewardDebt;
+        require(pending > 0, "No rewards");
+        stakes[msg.sender].stakedAt = block.timestamp;
+        stakes[msg.sender].rewardDebt = 0;
+        require(address(this).balance >= pending, "Insufficient contract balance");
+        (bool success, ) = payable(msg.sender).call{value: pending}("");
+        require(success, "Transfer failed");
+        emit RewardClaimed(msg.sender, pending);
+    }
+
+    function pendingReward(address user) external view returns (uint256) {
+        return _pendingReward(user) + stakes[user].rewardDebt;
+    }
+
+    function fundRewards() external payable onlyOwner {
+        require(msg.value > 0, "Must send BNB");
+        emit RewardsFunded(msg.sender, msg.value);
+    }
+
+    function setRewardRate(uint256 newRate) external onlyOwner {
+        emit RewardRateUpdated(rewardRate, newRate);
+        rewardRate = newRate;
+    }
+
+    function setMinStake(uint256 newMin) external onlyOwner {
+        minStake = newMin;
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        owner = newOwner;
+    }
+
+    function getStakeInfo(address user) external view returns (uint256 amount, uint256 stakedAt, uint256 pending) {
+        StakeInfo storage info = stakes[user];
+        return (info.amount, info.stakedAt, _pendingReward(user) + info.rewardDebt);
+    }
+
+    function _pendingReward(address user) internal view returns (uint256) {
+        StakeInfo storage info = stakes[user];
+        if (info.amount == 0) return 0;
+        uint256 duration = block.timestamp - info.stakedAt;
+        return (info.amount * rewardRate * duration) / (365 days * 10000);
+    }
+
+    receive() external payable {
+        emit RewardsFunded(msg.sender, msg.value);
+    }
+}
+`;
+//# sourceMappingURL=staking.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const STAKING_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ncontract BNBStaking {\n    address public owner;\n    uint256 public rewardRate;\n    uint256 public minStake;\n    uint256 public totalStaked;\n\n    struct StakeInfo {\n        uint256 amount;\n        uint256 stakedAt;\n        uint256 rewardDebt;\n    }\n\n    mapping(address => StakeInfo) public stakes;\n\n    event Staked(address indexed user, uint256 amount);\n    event Unstaked(address indexed user, uint256 amount);\n    event RewardClaimed(address indexed user, uint256 reward);\n    event RewardsFunded(address indexed funder, uint256 amount);\n    event RewardRateUpdated(uint256 oldRate, uint256 newRate);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    constructor() {\n        owner = msg.sender;\n        rewardRate = {{REWARD_RATE}};\n        minStake = {{MIN_STAKE}};\n    }\n\n    function stake() external payable {\n        require(msg.value >= minStake, \"Below minimum stake\");\n        StakeInfo storage info = stakes[msg.sender];\n        if (info.amount > 0) {\n            uint256 pending = _pendingReward(msg.sender);\n            if (pending > 0) {\n                info.rewardDebt += pending;\n            }\n        }\n        info.amount += msg.value;\n        info.stakedAt = block.timestamp;\n        totalStaked += msg.value;\n        emit Staked(msg.sender, msg.value);\n    }\n\n    function unstake(uint256 amount) external {\n        StakeInfo storage info = stakes[msg.sender];\n        require(info.amount >= amount, \"Insufficient stake\");\n        uint256 pending = _pendingReward(msg.sender) + info.rewardDebt;\n        info.amount -= amount;\n        info.stakedAt = block.timestamp;\n        info.rewardDebt = 0;\n        totalStaked -= amount;\n        uint256 total = amount + pending;\n        require(address(this).balance >= total, \"Insufficient contract balance\");\n        (bool success, ) = payable(msg.sender).call{value: total}(\"\");\n        require(success, \"Transfer failed\");\n        emit Unstaked(msg.sender, amount);\n        if (pending > 0) {\n            emit RewardClaimed(msg.sender, pending);\n        }\n    }\n\n    function claimReward() external {\n        uint256 pending = _pendingReward(msg.sender) + stakes[msg.sender].rewardDebt;\n        require(pending > 0, \"No rewards\");\n        stakes[msg.sender].stakedAt = block.timestamp;\n        stakes[msg.sender].rewardDebt = 0;\n        require(address(this).balance >= pending, \"Insufficient contract balance\");\n        (bool success, ) = payable(msg.sender).call{value: pending}(\"\");\n        require(success, \"Transfer failed\");\n        emit RewardClaimed(msg.sender, pending);\n    }\n\n    function pendingReward(address user) external view returns (uint256) {\n        return _pendingReward(user) + stakes[user].rewardDebt;\n    }\n\n    function fundRewards() external payable onlyOwner {\n        require(msg.value > 0, \"Must send BNB\");\n        emit RewardsFunded(msg.sender, msg.value);\n    }\n\n    function setRewardRate(uint256 newRate) external onlyOwner {\n        emit RewardRateUpdated(rewardRate, newRate);\n        rewardRate = newRate;\n    }\n\n    function setMinStake(uint256 newMin) external onlyOwner {\n        minStake = newMin;\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 getStakeInfo(address user) external view returns (uint256 amount, uint256 stakedAt, uint256 pending) {\n        StakeInfo storage info = stakes[user];\n        return (info.amount, info.stakedAt, _pendingReward(user) + info.rewardDebt);\n    }\n\n    function _pendingReward(address user) internal view returns (uint256) {\n        StakeInfo storage info = stakes[user];\n        if (info.amount == 0) return 0;\n        uint256 duration = block.timestamp - info.stakedAt;\n        return (info.amount * rewardRate * duration) / (365 days * 10000);\n    }\n\n    receive() external payable {\n        emit RewardsFunded(msg.sender, msg.value);\n    }\n}\n";
+//# sourceMappingURL=staking.sol.d.ts.map

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

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

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

@@ -0,0 +1,119 @@
+export const STAKING_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract BNBStaking {
+    address public owner;
+    uint256 public rewardRate;
+    uint256 public minStake;
+    uint256 public totalStaked;
+
+    struct StakeInfo {
+        uint256 amount;
+        uint256 stakedAt;
+        uint256 rewardDebt;
+    }
+
+    mapping(address => StakeInfo) public stakes;
+
+    event Staked(address indexed user, uint256 amount);
+    event Unstaked(address indexed user, uint256 amount);
+    event RewardClaimed(address indexed user, uint256 reward);
+    event RewardsFunded(address indexed funder, uint256 amount);
+    event RewardRateUpdated(uint256 oldRate, uint256 newRate);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    constructor() {
+        owner = msg.sender;
+        rewardRate = {{REWARD_RATE}};
+        minStake = {{MIN_STAKE}};
+    }
+
+    function stake() external payable {
+        require(msg.value >= minStake, "Below minimum stake");
+        StakeInfo storage info = stakes[msg.sender];
+        if (info.amount > 0) {
+            uint256 pending = _pendingReward(msg.sender);
+            if (pending > 0) {
+                info.rewardDebt += pending;
+            }
+        }
+        info.amount += msg.value;
+        info.stakedAt = block.timestamp;
+        totalStaked += msg.value;
+        emit Staked(msg.sender, msg.value);
+    }
+
+    function unstake(uint256 amount) external {
+        StakeInfo storage info = stakes[msg.sender];
+        require(info.amount >= amount, "Insufficient stake");
+        uint256 pending = _pendingReward(msg.sender) + info.rewardDebt;
+        info.amount -= amount;
+        info.stakedAt = block.timestamp;
+        info.rewardDebt = 0;
+        totalStaked -= amount;
+        uint256 total = amount + pending;
+        require(address(this).balance >= total, "Insufficient contract balance");
+        (bool success, ) = payable(msg.sender).call{value: total}("");
+        require(success, "Transfer failed");
+        emit Unstaked(msg.sender, amount);
+        if (pending > 0) {
+            emit RewardClaimed(msg.sender, pending);
+        }
+    }
+
+    function claimReward() external {
+        uint256 pending = _pendingReward(msg.sender) + stakes[msg.sender].rewardDebt;
+        require(pending > 0, "No rewards");
+        stakes[msg.sender].stakedAt = block.timestamp;
+        stakes[msg.sender].rewardDebt = 0;
+        require(address(this).balance >= pending, "Insufficient contract balance");
+        (bool success, ) = payable(msg.sender).call{value: pending}("");
+        require(success, "Transfer failed");
+        emit RewardClaimed(msg.sender, pending);
+    }
+
+    function pendingReward(address user) external view returns (uint256) {
+        return _pendingReward(user) + stakes[user].rewardDebt;
+    }
+
+    function fundRewards() external payable onlyOwner {
+        require(msg.value > 0, "Must send BNB");
+        emit RewardsFunded(msg.sender, msg.value);
+    }
+
+    function setRewardRate(uint256 newRate) external onlyOwner {
+        emit RewardRateUpdated(rewardRate, newRate);
+        rewardRate = newRate;
+    }
+
+    function setMinStake(uint256 newMin) external onlyOwner {
+        minStake = newMin;
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        owner = newOwner;
+    }
+
+    function getStakeInfo(address user) external view returns (uint256 amount, uint256 stakedAt, uint256 pending) {
+        StakeInfo storage info = stakes[user];
+        return (info.amount, info.stakedAt, _pendingReward(user) + info.rewardDebt);
+    }
+
+    function _pendingReward(address user) internal view returns (uint256) {
+        StakeInfo storage info = stakes[user];
+        if (info.amount == 0) return 0;
+        uint256 duration = block.timestamp - info.stakedAt;
+        return (info.amount * rewardRate * duration) / (365 days * 10000);
+    }
+
+    receive() external payable {
+        emit RewardsFunded(msg.sender, msg.value);
+    }
+}
+`;
+//# sourceMappingURL=staking.sol.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const VESTING_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IERC20 {\n    function transfer(address to, uint256 amount) external returns (bool);\n    function balanceOf(address account) external view returns (uint256);\n}\n\ncontract TokenVesting {\n    address public owner;\n    IERC20 public token;\n    address public beneficiary;\n    uint256 public cliffDuration;\n    uint256 public vestingDuration;\n    uint256 public start;\n    uint256 public totalAmount;\n    uint256 public released;\n    bool public revocable;\n    bool public revoked;\n\n    event TokensReleased(uint256 amount);\n    event VestingRevoked(uint256 unreleased);\n    event BeneficiaryUpdated(address indexed oldBeneficiary, address indexed newBeneficiary);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    modifier onlyBeneficiary() {\n        require(msg.sender == beneficiary, \"Not beneficiary\");\n        _;\n    }\n\n    constructor() {\n        owner = msg.sender;\n        token = IERC20({{TOKEN_ADDRESS}});\n        beneficiary = {{BENEFICIARY}};\n        cliffDuration = {{CLIFF_DURATION}};\n        vestingDuration = {{VESTING_DURATION}};\n        revocable = true;\n        start = block.timestamp;\n    }\n\n    function initialize(uint256 amount) external onlyOwner {\n        require(totalAmount == 0, \"Already initialized\");\n        require(amount > 0, \"Amount must be > 0\");\n        totalAmount = amount;\n    }\n\n    function release() external onlyBeneficiary {\n        require(!revoked, \"Vesting revoked\");\n        uint256 releasable = _releasableAmount();\n        require(releasable > 0, \"No tokens to release\");\n        released += releasable;\n        require(token.transfer(beneficiary, releasable), \"Transfer failed\");\n        emit TokensReleased(releasable);\n    }\n\n    function revoke() external onlyOwner {\n        require(revocable, \"Not revocable\");\n        require(!revoked, \"Already revoked\");\n        uint256 releasable = _releasableAmount();\n        if (releasable > 0) {\n            released += releasable;\n            require(token.transfer(beneficiary, releasable), \"Transfer failed\");\n            emit TokensReleased(releasable);\n        }\n        uint256 unreleased = totalAmount - released;\n        revoked = true;\n        if (unreleased > 0) {\n            require(token.transfer(owner, unreleased), \"Transfer failed\");\n        }\n        emit VestingRevoked(unreleased);\n    }\n\n    function releasableAmount() external view returns (uint256) {\n        return _releasableAmount();\n    }\n\n    function vestedAmount() external view returns (uint256) {\n        return _vestedAmount();\n    }\n\n    function updateBeneficiary(address newBeneficiary) external onlyOwner {\n        require(newBeneficiary != address(0), \"Zero address\");\n        require(!revoked, \"Vesting revoked\");\n        emit BeneficiaryUpdated(beneficiary, newBeneficiary);\n        beneficiary = newBeneficiary;\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 vestingSchedule() external view returns (\n        uint256 _start,\n        uint256 _cliff,\n        uint256 _duration,\n        uint256 _total,\n        uint256 _released,\n        uint256 _releasable,\n        bool _revoked\n    ) {\n        return (\n            start,\n            start + cliffDuration,\n            vestingDuration,\n            totalAmount,\n            released,\n            _releasableAmount(),\n            revoked\n        );\n    }\n\n    function _releasableAmount() internal view returns (uint256) {\n        return _vestedAmount() - released;\n    }\n\n    function _vestedAmount() internal view returns (uint256) {\n        if (block.timestamp < start + cliffDuration) {\n            return 0;\n        }\n        uint256 elapsed = block.timestamp - start;\n        if (elapsed >= vestingDuration) {\n            return totalAmount;\n        }\n        return (totalAmount * elapsed) / vestingDuration;\n    }\n}\n";
+//# sourceMappingURL=vesting.d.ts.map

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

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

package/dist/generator/templates/vesting.js

@@ -0,0 +1,133 @@
+export const VESTING_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IERC20 {
+    function transfer(address to, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract TokenVesting {
+    address public owner;
+    IERC20 public token;
+    address public beneficiary;
+    uint256 public cliffDuration;
+    uint256 public vestingDuration;
+    uint256 public start;
+    uint256 public totalAmount;
+    uint256 public released;
+    bool public revocable;
+    bool public revoked;
+
+    event TokensReleased(uint256 amount);
+    event VestingRevoked(uint256 unreleased);
+    event BeneficiaryUpdated(address indexed oldBeneficiary, address indexed newBeneficiary);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    modifier onlyBeneficiary() {
+        require(msg.sender == beneficiary, "Not beneficiary");
+        _;
+    }
+
+    constructor() {
+        owner = msg.sender;
+        token = IERC20({{TOKEN_ADDRESS}});
+        beneficiary = {{BENEFICIARY}};
+        cliffDuration = {{CLIFF_DURATION}};
+        vestingDuration = {{VESTING_DURATION}};
+        revocable = true;
+        start = block.timestamp;
+    }
+
+    function initialize(uint256 amount) external onlyOwner {
+        require(totalAmount == 0, "Already initialized");
+        require(amount > 0, "Amount must be > 0");
+        totalAmount = amount;
+    }
+
+    function release() external onlyBeneficiary {
+        require(!revoked, "Vesting revoked");
+        uint256 releasable = _releasableAmount();
+        require(releasable > 0, "No tokens to release");
+        released += releasable;
+        require(token.transfer(beneficiary, releasable), "Transfer failed");
+        emit TokensReleased(releasable);
+    }
+
+    function revoke() external onlyOwner {
+        require(revocable, "Not revocable");
+        require(!revoked, "Already revoked");
+        uint256 releasable = _releasableAmount();
+        if (releasable > 0) {
+            released += releasable;
+            require(token.transfer(beneficiary, releasable), "Transfer failed");
+            emit TokensReleased(releasable);
+        }
+        uint256 unreleased = totalAmount - released;
+        revoked = true;
+        if (unreleased > 0) {
+            require(token.transfer(owner, unreleased), "Transfer failed");
+        }
+        emit VestingRevoked(unreleased);
+    }
+
+    function releasableAmount() external view returns (uint256) {
+        return _releasableAmount();
+    }
+
+    function vestedAmount() external view returns (uint256) {
+        return _vestedAmount();
+    }
+
+    function updateBeneficiary(address newBeneficiary) external onlyOwner {
+        require(newBeneficiary != address(0), "Zero address");
+        require(!revoked, "Vesting revoked");
+        emit BeneficiaryUpdated(beneficiary, newBeneficiary);
+        beneficiary = newBeneficiary;
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        owner = newOwner;
+    }
+
+    function vestingSchedule() external view returns (
+        uint256 _start,
+        uint256 _cliff,
+        uint256 _duration,
+        uint256 _total,
+        uint256 _released,
+        uint256 _releasable,
+        bool _revoked
+    ) {
+        return (
+            start,
+            start + cliffDuration,
+            vestingDuration,
+            totalAmount,
+            released,
+            _releasableAmount(),
+            revoked
+        );
+    }
+
+    function _releasableAmount() internal view returns (uint256) {
+        return _vestedAmount() - released;
+    }
+
+    function _vestedAmount() internal view returns (uint256) {
+        if (block.timestamp < start + cliffDuration) {
+            return 0;
+        }
+        uint256 elapsed = block.timestamp - start;
+        if (elapsed >= vestingDuration) {
+            return totalAmount;
+        }
+        return (totalAmount * elapsed) / vestingDuration;
+    }
+}
+`;
+//# sourceMappingURL=vesting.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const VESTING_TEMPLATE = "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IERC20 {\n    function transfer(address to, uint256 amount) external returns (bool);\n    function balanceOf(address account) external view returns (uint256);\n}\n\ncontract TokenVesting {\n    address public owner;\n    IERC20 public token;\n    address public beneficiary;\n    uint256 public cliffDuration;\n    uint256 public vestingDuration;\n    uint256 public start;\n    uint256 public totalAmount;\n    uint256 public released;\n    bool public revocable;\n    bool public revoked;\n\n    event TokensReleased(uint256 amount);\n    event VestingRevoked(uint256 unreleased);\n    event BeneficiaryUpdated(address indexed oldBeneficiary, address indexed newBeneficiary);\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n\n    modifier onlyBeneficiary() {\n        require(msg.sender == beneficiary, \"Not beneficiary\");\n        _;\n    }\n\n    constructor() {\n        owner = msg.sender;\n        token = IERC20({{TOKEN_ADDRESS}});\n        beneficiary = {{BENEFICIARY}};\n        cliffDuration = {{CLIFF_DURATION}};\n        vestingDuration = {{VESTING_DURATION}};\n        revocable = true;\n        start = block.timestamp;\n    }\n\n    function initialize(uint256 amount) external onlyOwner {\n        require(totalAmount == 0, \"Already initialized\");\n        require(amount > 0, \"Amount must be > 0\");\n        totalAmount = amount;\n    }\n\n    function release() external onlyBeneficiary {\n        require(!revoked, \"Vesting revoked\");\n        uint256 releasable = _releasableAmount();\n        require(releasable > 0, \"No tokens to release\");\n        released += releasable;\n        require(token.transfer(beneficiary, releasable), \"Transfer failed\");\n        emit TokensReleased(releasable);\n    }\n\n    function revoke() external onlyOwner {\n        require(revocable, \"Not revocable\");\n        require(!revoked, \"Already revoked\");\n        uint256 releasable = _releasableAmount();\n        if (releasable > 0) {\n            released += releasable;\n            require(token.transfer(beneficiary, releasable), \"Transfer failed\");\n            emit TokensReleased(releasable);\n        }\n        uint256 unreleased = totalAmount - released;\n        revoked = true;\n        if (unreleased > 0) {\n            require(token.transfer(owner, unreleased), \"Transfer failed\");\n        }\n        emit VestingRevoked(unreleased);\n    }\n\n    function releasableAmount() external view returns (uint256) {\n        return _releasableAmount();\n    }\n\n    function vestedAmount() external view returns (uint256) {\n        return _vestedAmount();\n    }\n\n    function updateBeneficiary(address newBeneficiary) external onlyOwner {\n        require(newBeneficiary != address(0), \"Zero address\");\n        require(!revoked, \"Vesting revoked\");\n        emit BeneficiaryUpdated(beneficiary, newBeneficiary);\n        beneficiary = newBeneficiary;\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 vestingSchedule() external view returns (\n        uint256 _start,\n        uint256 _cliff,\n        uint256 _duration,\n        uint256 _total,\n        uint256 _released,\n        uint256 _releasable,\n        bool _revoked\n    ) {\n        return (\n            start,\n            start + cliffDuration,\n            vestingDuration,\n            totalAmount,\n            released,\n            _releasableAmount(),\n            revoked\n        );\n    }\n\n    function _releasableAmount() internal view returns (uint256) {\n        return _vestedAmount() - released;\n    }\n\n    function _vestedAmount() internal view returns (uint256) {\n        if (block.timestamp < start + cliffDuration) {\n            return 0;\n        }\n        uint256 elapsed = block.timestamp - start;\n        if (elapsed >= vestingDuration) {\n            return totalAmount;\n        }\n        return (totalAmount * elapsed) / vestingDuration;\n    }\n}\n";
+//# sourceMappingURL=vesting.sol.d.ts.map

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

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

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

@@ -0,0 +1,133 @@
+export const VESTING_TEMPLATE = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IERC20 {
+    function transfer(address to, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract TokenVesting {
+    address public owner;
+    IERC20 public token;
+    address public beneficiary;
+    uint256 public cliffDuration;
+    uint256 public vestingDuration;
+    uint256 public start;
+    uint256 public totalAmount;
+    uint256 public released;
+    bool public revocable;
+    bool public revoked;
+
+    event TokensReleased(uint256 amount);
+    event VestingRevoked(uint256 unreleased);
+    event BeneficiaryUpdated(address indexed oldBeneficiary, address indexed newBeneficiary);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    modifier onlyBeneficiary() {
+        require(msg.sender == beneficiary, "Not beneficiary");
+        _;
+    }
+
+    constructor() {
+        owner = msg.sender;
+        token = IERC20({{TOKEN_ADDRESS}});
+        beneficiary = {{BENEFICIARY}};
+        cliffDuration = {{CLIFF_DURATION}};
+        vestingDuration = {{VESTING_DURATION}};
+        revocable = true;
+        start = block.timestamp;
+    }
+
+    function initialize(uint256 amount) external onlyOwner {
+        require(totalAmount == 0, "Already initialized");
+        require(amount > 0, "Amount must be > 0");
+        totalAmount = amount;
+    }
+
+    function release() external onlyBeneficiary {
+        require(!revoked, "Vesting revoked");
+        uint256 releasable = _releasableAmount();
+        require(releasable > 0, "No tokens to release");
+        released += releasable;
+        require(token.transfer(beneficiary, releasable), "Transfer failed");
+        emit TokensReleased(releasable);
+    }
+
+    function revoke() external onlyOwner {
+        require(revocable, "Not revocable");
+        require(!revoked, "Already revoked");
+        uint256 releasable = _releasableAmount();
+        if (releasable > 0) {
+            released += releasable;
+            require(token.transfer(beneficiary, releasable), "Transfer failed");
+            emit TokensReleased(releasable);
+        }
+        uint256 unreleased = totalAmount - released;
+        revoked = true;
+        if (unreleased > 0) {
+            require(token.transfer(owner, unreleased), "Transfer failed");
+        }
+        emit VestingRevoked(unreleased);
+    }
+
+    function releasableAmount() external view returns (uint256) {
+        return _releasableAmount();
+    }
+
+    function vestedAmount() external view returns (uint256) {
+        return _vestedAmount();
+    }
+
+    function updateBeneficiary(address newBeneficiary) external onlyOwner {
+        require(newBeneficiary != address(0), "Zero address");
+        require(!revoked, "Vesting revoked");
+        emit BeneficiaryUpdated(beneficiary, newBeneficiary);
+        beneficiary = newBeneficiary;
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "New owner is zero address");
+        owner = newOwner;
+    }
+
+    function vestingSchedule() external view returns (
+        uint256 _start,
+        uint256 _cliff,
+        uint256 _duration,
+        uint256 _total,
+        uint256 _released,
+        uint256 _releasable,
+        bool _revoked
+    ) {
+        return (
+            start,
+            start + cliffDuration,
+            vestingDuration,
+            totalAmount,
+            released,
+            _releasableAmount(),
+            revoked
+        );
+    }
+
+    function _releasableAmount() internal view returns (uint256) {
+        return _vestedAmount() - released;
+    }
+
+    function _vestedAmount() internal view returns (uint256) {
+        if (block.timestamp < start + cliffDuration) {
+            return 0;
+        }
+        uint256 elapsed = block.timestamp - start;
+        if (elapsed >= vestingDuration) {
+            return totalAmount;
+        }
+        return (totalAmount * elapsed) / vestingDuration;
+    }
+}
+`;
+//# sourceMappingURL=vesting.sol.js.map

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

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

package/dist/generator/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function extractContractName(source: string): string;
+export declare function sanitizeFileName(name: string): string;
+export declare function writeFileUnique(dir: string, fileName: string, content: string): Promise<string>;
+export declare function ensureOutputDir(dir: string): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/generator/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/generator/utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhE"}

package/dist/generator/utils.js

@@ -0,0 +1,49 @@
+import { writeFile } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+export function extractContractName(source) {
+    const match = source.match(/contract\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:is\s|{)/);
+    if (match) {
+        return match[1];
+    }
+    return "GeneratedContract";
+}
+export function sanitizeFileName(name) {
+    const cleaned = name.replace(/[^a-zA-Z0-9]/g, " ");
+    const pascal = cleaned
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+    if (!pascal) {
+        return "Contract.sol";
+    }
+    return pascal.endsWith(".sol") ? pascal : `${pascal}.sol`;
+}
+export async function writeFileUnique(dir, fileName, content) {
+    const ext = path.extname(fileName);
+    const base = fileName.slice(0, -ext.length);
+    let candidate = path.resolve(dir, fileName);
+    let counter = 0;
+    const maxAttempts = 100;
+    while (counter < maxAttempts) {
+        try {
+            await writeFile(candidate, content, { encoding: "utf-8", flag: "wx" });
+            return candidate;
+        }
+        catch (err) {
+            if (err.code === "EEXIST") {
+                counter++;
+                candidate = path.resolve(dir, `${base}_${counter}${ext}`);
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw new Error(`Could not find unique filename for ${fileName} after ${maxAttempts} attempts`);
+}
+export async function ensureOutputDir(dir) {
+    const resolved = path.resolve(dir);
+    await mkdir(resolved, { recursive: true });
+}
+//# sourceMappingURL=utils.js.map

package/dist/generator/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/generator/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;IAC/E,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;IACnD,MAAM,MAAM,GAAG,OAAO;SACnB,KAAK,CAAC,KAAK,CAAC;SACZ,MAAM,CAAC,OAAO,CAAC;SACf,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;SACzE,IAAI,CAAC,EAAE,CAAC,CAAC;IACZ,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,cAAc,CAAC;IACxB,CAAC;IACD,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,MAAM,CAAC;AAC5D,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,GAAW,EACX,QAAgB,EAChB,OAAe;IAEf,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC5C,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,MAAM,WAAW,GAAG,GAAG,CAAC;IAExB,OAAO,OAAO,GAAG,WAAW,EAAE,CAAC;QAC7B,IAAI,CAAC;YACH,MAAM,SAAS,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACvE,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACtB,IAAK,GAA6B,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrD,OAAO,EAAE,CAAC;gBACV,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC;gBAC1D,SAAS;YACX,CAAC;YACD,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,sCAAsC,QAAQ,UAAU,WAAW,WAAW,CAAC,CAAC;AAClG,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,GAAW;IAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,MAAM,KAAK,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAC7C,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './config/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}