@nockdev/awf 6.2.0

package/.agent/skills/languages/solidity/data/core.yaml

@@ -0,0 +1,528 @@
+# =============================================================================
+# Solidity Core Patterns (Feb 2026)
+# Version: Solidity 0.8.28
+# =============================================================================
+
+metadata:
+  skill: solidity
+  domain: core
+  version: "0.8.28"
+  updated: "2026-02-05"
+  patterns_count: 5
+
+patterns:
+  - id: sol001
+    name: Smart Contract Basics
+    category: language
+    version: "Solidity0.8"
+    description: |
+      Solidity fundamentals.
+      State, functions, modifiers, events.
+    text: contract function modifier event storage
+    example: |
+      // SPDX-License-Identifier: MIT
+      pragma solidity ^0.8.28;
+
+      /// @title Basic Counter Contract
+      /// @notice Demonstrates Solidity fundamentals
+      contract Counter {
+          // ✅ State variables
+          uint256 public count;
+          address public owner;
+          mapping(address => uint256) public userCounts;
+          
+          // ✅ Events
+          event CountChanged(address indexed user, uint256 newCount);
+          event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+          
+          // ✅ Errors (custom errors save gas)
+          error NotOwner();
+          error InvalidAmount(uint256 provided, uint256 required);
+          
+          // ✅ Modifiers
+          modifier onlyOwner() {
+              if (msg.sender != owner) revert NotOwner();
+              _;
+          }
+          
+          // ✅ Constructor
+          constructor(uint256 initialCount) {
+              count = initialCount;
+              owner = msg.sender;
+          }
+          
+          // ✅ External functions (can only be called externally)
+          function increment() external {
+              count++;
+              userCounts[msg.sender]++;
+              emit CountChanged(msg.sender, count);
+          }
+          
+          // ✅ Public functions (can be called internally and externally)
+          function decrement() public {
+              require(count > 0, "Count cannot be negative");
+              count--;
+              emit CountChanged(msg.sender, count);
+          }
+          
+          // ✅ View functions (read-only, no gas when called externally)
+          function getCount() external view returns (uint256) {
+              return count;
+          }
+          
+          // ✅ Pure functions (no state access)
+          function add(uint256 a, uint256 b) external pure returns (uint256) {
+              return a + b;
+          }
+          
+          // ✅ Payable function
+          function donate() external payable {
+              require(msg.value > 0, "Must send ETH");
+          }
+          
+          // ✅ Transfer ownership
+          function transferOwnership(address newOwner) external onlyOwner {
+              emit OwnershipTransferred(owner, newOwner);
+              owner = newOwner;
+          }
+      }
+    severity: HIGH
+    docs_url: https://docs.soliditylang.org/
+
+  - id: sol002
+    name: ERC Standards
+    category: standards
+    version: "ERC"
+    description: |
+      Common token standards.
+      ERC-20, ERC-721, ERC-1155.
+    text: erc20 erc721 erc1155 token nft
+    example: |
+      // SPDX-License-Identifier: MIT
+      pragma solidity ^0.8.28;
+
+      import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+      import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+      import "@openzeppelin/contracts/access/Ownable.sol";
+
+      /// ✅ ERC-20 Token
+      contract MyToken is ERC20, Ownable {
+          constructor() ERC20("MyToken", "MTK") Ownable(msg.sender) {
+              _mint(msg.sender, 1_000_000 * 10**decimals());
+          }
+          
+          function mint(address to, uint256 amount) external onlyOwner {
+              _mint(to, amount);
+          }
+          
+          function burn(uint256 amount) external {
+              _burn(msg.sender, amount);
+          }
+      }
+
+      /// ✅ ERC-721 NFT
+      contract MyNFT is ERC721, Ownable {
+          uint256 private _nextTokenId;
+          string private _baseTokenURI;
+          uint256 public constant MAX_SUPPLY = 10_000;
+          uint256 public constant MINT_PRICE = 0.05 ether;
+          
+          constructor() ERC721("MyNFT", "MNFT") Ownable(msg.sender) {}
+          
+          function mint() external payable {
+              require(_nextTokenId < MAX_SUPPLY, "Max supply reached");
+              require(msg.value >= MINT_PRICE, "Insufficient payment");
+              
+              uint256 tokenId = _nextTokenId++;
+              _safeMint(msg.sender, tokenId);
+          }
+          
+          function setBaseURI(string calldata baseURI) external onlyOwner {
+              _baseTokenURI = baseURI;
+          }
+          
+          function _baseURI() internal view override returns (string memory) {
+              return _baseTokenURI;
+          }
+          
+          function withdraw() external onlyOwner {
+              (bool success, ) = owner().call{value: address(this).balance}("");
+              require(success, "Transfer failed");
+          }
+      }
+
+      /// ✅ ERC-1155 Multi-Token
+      import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+
+      contract GameItems is ERC1155, Ownable {
+          uint256 public constant GOLD = 0;
+          uint256 public constant SILVER = 1;
+          uint256 public constant SWORD = 2;
+          
+          constructor() ERC1155("https://api.game.com/items/{id}.json") Ownable(msg.sender) {
+              _mint(msg.sender, GOLD, 1000, "");
+              _mint(msg.sender, SILVER, 5000, "");
+              _mint(msg.sender, SWORD, 100, "");
+          }
+          
+          function mintBatch(
+              address to,
+              uint256[] memory ids,
+              uint256[] memory amounts
+          ) external onlyOwner {
+              _mintBatch(to, ids, amounts, "");
+          }
+      }
+    severity: HIGH
+    docs_url: https://eips.ethereum.org/EIPS/eip-20
+
+  - id: sol003
+    name: Security Patterns
+    category: security
+    version: "Solidity0.8"
+    description: |
+      Security best practices.
+      Reentrancy, access control, checks.
+    text: reentrancy guard access control checks effects
+    example: |
+      // SPDX-License-Identifier: MIT
+      pragma solidity ^0.8.28;
+
+      import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+      import "@openzeppelin/contracts/access/AccessControl.sol";
+
+      /// @title Secure Vault
+      /// @notice Demonstrates security patterns
+      contract SecureVault is ReentrancyGuard, AccessControl {
+          bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+          bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
+          
+          mapping(address => uint256) private balances;
+          bool private locked;
+          
+          error InsufficientBalance(uint256 requested, uint256 available);
+          error TransferFailed();
+          error ZeroAddress();
+          error ZeroAmount();
+          
+          constructor() {
+              _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+              _grantRole(ADMIN_ROLE, msg.sender);
+          }
+          
+          /// ✅ Checks-Effects-Interactions pattern
+          function withdraw(uint256 amount) external nonReentrant {
+              // CHECKS
+              if (amount == 0) revert ZeroAmount();
+              uint256 balance = balances[msg.sender];
+              if (balance < amount) {
+                  revert InsufficientBalance(amount, balance);
+              }
+              
+              // EFFECTS (update state before external call)
+              balances[msg.sender] = balance - amount;
+              
+              // INTERACTIONS (external call last)
+              (bool success, ) = msg.sender.call{value: amount}("");
+              if (!success) revert TransferFailed();
+          }
+          
+          /// ✅ Pull over Push pattern
+          mapping(address => uint256) public pendingWithdrawals;
+          
+          function setPendingWithdrawal(address to, uint256 amount) 
+              external 
+              onlyRole(OPERATOR_ROLE) 
+          {
+              pendingWithdrawals[to] += amount;
+          }
+          
+          function claimWithdrawal() external nonReentrant {
+              uint256 amount = pendingWithdrawals[msg.sender];
+              if (amount == 0) revert ZeroAmount();
+              
+              pendingWithdrawals[msg.sender] = 0;
+              
+              (bool success, ) = msg.sender.call{value: amount}("");
+              if (!success) revert TransferFailed();
+          }
+          
+          /// ✅ Input validation
+          function deposit(address to) external payable {
+              if (to == address(0)) revert ZeroAddress();
+              if (msg.value == 0) revert ZeroAmount();
+              balances[to] += msg.value;
+          }
+          
+          /// ✅ Emergency pause
+          bool public paused;
+          
+          modifier whenNotPaused() {
+              require(!paused, "Contract is paused");
+              _;
+          }
+          
+          function pause() external onlyRole(ADMIN_ROLE) {
+              paused = true;
+          }
+          
+          function unpause() external onlyRole(ADMIN_ROLE) {
+              paused = false;
+          }
+      }
+    severity: HIGH
+    docs_url: https://docs.openzeppelin.com/contracts/
+
+  - id: sol004
+    name: DeFi Patterns
+    category: defi
+    version: "DeFi"
+    description: |
+      DeFi protocol patterns.
+      AMM, staking, flash loans.
+    text: swap liquidity stake yield flash loan
+    example: |
+      // SPDX-License-Identifier: MIT
+      pragma solidity ^0.8.28;
+
+      import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+      import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+      /// ✅ Simple AMM (Constant Product)
+      contract SimpleAMM {
+          using SafeERC20 for IERC20;
+          
+          IERC20 public immutable tokenA;
+          IERC20 public immutable tokenB;
+          
+          uint256 public reserveA;
+          uint256 public reserveB;
+          uint256 public totalLiquidity;
+          mapping(address => uint256) public liquidity;
+          
+          uint256 public constant FEE_BPS = 30; // 0.3%
+          
+          constructor(address _tokenA, address _tokenB) {
+              tokenA = IERC20(_tokenA);
+              tokenB = IERC20(_tokenB);
+          }
+          
+          function addLiquidity(uint256 amountA, uint256 amountB) 
+              external 
+              returns (uint256 shares) 
+          {
+              tokenA.safeTransferFrom(msg.sender, address(this), amountA);
+              tokenB.safeTransferFrom(msg.sender, address(this), amountB);
+              
+              if (totalLiquidity == 0) {
+                  shares = sqrt(amountA * amountB);
+              } else {
+                  shares = min(
+                      (amountA * totalLiquidity) / reserveA,
+                      (amountB * totalLiquidity) / reserveB
+                  );
+              }
+              
+              liquidity[msg.sender] += shares;
+              totalLiquidity += shares;
+              reserveA += amountA;
+              reserveB += amountB;
+          }
+          
+          function swap(address tokenIn, uint256 amountIn) 
+              external 
+              returns (uint256 amountOut) 
+          {
+              bool isTokenA = tokenIn == address(tokenA);
+              
+              (IERC20 inToken, IERC20 outToken, uint256 resIn, uint256 resOut) = 
+                  isTokenA 
+                      ? (tokenA, tokenB, reserveA, reserveB)
+                      : (tokenB, tokenA, reserveB, reserveA);
+              
+              inToken.safeTransferFrom(msg.sender, address(this), amountIn);
+              
+              // x * y = k (constant product)
+              uint256 amountInWithFee = amountIn * (10000 - FEE_BPS) / 10000;
+              amountOut = (resOut * amountInWithFee) / (resIn + amountInWithFee);
+              
+              outToken.safeTransfer(msg.sender, amountOut);
+              
+              // Update reserves
+              if (isTokenA) {
+                  reserveA += amountIn;
+                  reserveB -= amountOut;
+              } else {
+                  reserveB += amountIn;
+                  reserveA -= amountOut;
+              }
+          }
+          
+          function sqrt(uint256 x) internal pure returns (uint256) {
+              if (x == 0) return 0;
+              uint256 z = (x + 1) / 2;
+              uint256 y = x;
+              while (z < y) {
+                  y = z;
+                  z = (x / z + z) / 2;
+              }
+              return y;
+          }
+          
+          function min(uint256 a, uint256 b) internal pure returns (uint256) {
+              return a < b ? a : b;
+          }
+      }
+
+      /// ✅ Simple Staking
+      contract StakingRewards {
+          using SafeERC20 for IERC20;
+          
+          IERC20 public stakingToken;
+          IERC20 public rewardToken;
+          
+          uint256 public rewardRate;
+          uint256 public rewardPerTokenStored;
+          uint256 public lastUpdateTime;
+          uint256 public totalStaked;
+          
+          mapping(address => uint256) public userRewardPerTokenPaid;
+          mapping(address => uint256) public rewards;
+          mapping(address => uint256) public stakedBalance;
+          
+          function stake(uint256 amount) external updateReward(msg.sender) {
+              stakingToken.safeTransferFrom(msg.sender, address(this), amount);
+              stakedBalance[msg.sender] += amount;
+              totalStaked += amount;
+          }
+          
+          function withdraw(uint256 amount) external updateReward(msg.sender) {
+              stakedBalance[msg.sender] -= amount;
+              totalStaked -= amount;
+              stakingToken.safeTransfer(msg.sender, amount);
+          }
+          
+          modifier updateReward(address account) {
+              rewardPerTokenStored = rewardPerToken();
+              lastUpdateTime = block.timestamp;
+              rewards[account] = earned(account);
+              userRewardPerTokenPaid[account] = rewardPerTokenStored;
+              _;
+          }
+          
+          function rewardPerToken() public view returns (uint256) {
+              if (totalStaked == 0) return rewardPerTokenStored;
+              return rewardPerTokenStored + 
+                  ((block.timestamp - lastUpdateTime) * rewardRate * 1e18) / totalStaked;
+          }
+          
+          function earned(address account) public view returns (uint256) {
+              return (stakedBalance[account] * 
+                  (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18 
+                  + rewards[account];
+          }
+      }
+    severity: MEDIUM
+    docs_url: https://defillama.com/
+
+  - id: sol005
+    name: Gas Optimization
+    category: optimization
+    version: "Solidity0.8"
+    description: |
+      Gas efficiency patterns.
+      Storage, calldata, packing.
+    text: gas optimize storage calldata pack
+    example: |
+      // SPDX-License-Identifier: MIT
+      pragma solidity ^0.8.28;
+
+      contract GasOptimized {
+          // ✅ Storage packing (fit multiple vars in one slot)
+          // BAD: 3 storage slots
+          // uint256 a;  // slot 0
+          // uint8 b;    // slot 1
+          // uint256 c;  // slot 2
+          
+          // GOOD: 2 storage slots
+          uint128 public valueA;  // slot 0 (16 bytes)
+          uint64 public valueB;   // slot 0 (8 bytes)
+          uint64 public valueC;   // slot 0 (8 bytes) - packed!
+          uint256 public valueD;  // slot 1
+          
+          // ✅ Use calldata for external function args (saves gas)
+          // BAD: memory copies the array
+          function processMemory(uint256[] memory data) external pure returns (uint256) {
+              uint256 sum;
+              for (uint256 i; i < data.length; ++i) {
+                  sum += data[i];
+              }
+              return sum;
+          }
+          
+          // GOOD: calldata doesn't copy
+          function processCalldata(uint256[] calldata data) external pure returns (uint256) {
+              uint256 sum;
+              for (uint256 i; i < data.length; ++i) {
+                  sum += data[i];
+              }
+              return sum;
+          }
+          
+          // ✅ Cache storage in memory
+          uint256[] public items;
+          
+          // BAD: reads storage in each iteration
+          function sumBad() external view returns (uint256 total) {
+              for (uint256 i; i < items.length; ++i) {
+                  total += items[i];
+              }
+          }
+          
+          // GOOD: cache length and use local var
+          function sumGood() external view returns (uint256 total) {
+              uint256[] memory _items = items;  // cache in memory
+              uint256 len = _items.length;
+              for (uint256 i; i < len; ++i) {
+                  total += _items[i];
+              }
+          }
+          
+          // ✅ Use unchecked for safe math
+          function increment(uint256 x) external pure returns (uint256) {
+              // Safe because we check first
+              require(x < type(uint256).max, "Overflow");
+              unchecked {
+                  return x + 1;  // Skips overflow check, saves gas
+              }
+          }
+          
+          // ✅ Use ++i instead of i++
+          function loop() external pure returns (uint256 sum) {
+              for (uint256 i; i < 100; ++i) {  // ++i cheaper than i++
+                  unchecked { sum += i; }
+              }
+          }
+          
+          // ✅ Short-circuit conditionals
+          function check(uint256 a, uint256 b) external pure returns (bool) {
+              // Cheaper check first
+              return a > 0 && expensiveCheck(b);
+          }
+          
+          function expensiveCheck(uint256 b) internal pure returns (bool) {
+              // Simulate expensive operation
+              return b == keccak256(abi.encode(b)).length;
+          }
+          
+          // ✅ Use immutable for constructor-set values
+          address public immutable owner;
+          uint256 public immutable deployTime;
+          
+          constructor() {
+              owner = msg.sender;
+              deployTime = block.timestamp;
+          }
+      }
+    severity: MEDIUM
+    docs_url: https://docs.soliditylang.org/en/latest/internals/optimizer.html