@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/registry/layers/capability/fhe-foundry-private-token/files/PrivateToken.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {FHE, euint32, InEuint32} from "@fhenixprotocol/cofhe-contracts/FHE.sol";
+
+/// @title PrivateToken
+/// @notice ERC20-like token with encrypted balances and encrypted transfer gates.
+contract PrivateToken {
+    string public name;
+    string public symbol;
+    address public minter;
+
+    mapping(address => euint32) private _balances;
+    euint32 private _totalSupply;
+
+    event Transfer(address indexed from, address indexed to);
+
+    constructor(string memory tokenName, string memory tokenSymbol) {
+        name = tokenName;
+        symbol = tokenSymbol;
+        minter = msg.sender;
+        _totalSupply = FHE.asEuint32(0);
+        FHE.allowThis(_totalSupply);
+    }
+
+    function mint(address to, InEuint32 calldata encryptedAmount) external {
+        require(msg.sender == minter, "Only minter");
+        euint32 amount = FHE.asEuint32(encryptedAmount);
+        _balances[to] = FHE.add(_balances[to], amount);
+        _totalSupply = FHE.add(_totalSupply, amount);
+        FHE.allowThis(_balances[to]);
+        FHE.allowThis(_totalSupply);
+        FHE.allow(_balances[to], to);
+    }
+
+    function transfer(address to, InEuint32 calldata encryptedAmount) external {
+        euint32 amount = FHE.asEuint32(encryptedAmount);
+        euint32 zero = FHE.asEuint32(0);
+        euint32 allowedAmount = FHE.select(FHE.gte(_balances[msg.sender], amount), amount, zero);
+
+        _balances[msg.sender] = FHE.sub(_balances[msg.sender], allowedAmount);
+        _balances[to] = FHE.add(_balances[to], allowedAmount);
+        FHE.allowThis(_balances[msg.sender]);
+        FHE.allowThis(_balances[to]);
+        FHE.allow(_balances[msg.sender], msg.sender);
+        FHE.allow(_balances[to], to);
+
+        emit Transfer(msg.sender, to);
+    }
+
+    function encryptedBalanceOf(address account) external view returns (euint32) {
+        return _balances[account];
+    }
+
+    function encryptedTotalSupply() external view returns (euint32) {
+        return _totalSupply;
+    }
+}

package/registry/layers/capability/fhe-foundry-private-token/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "fhe-foundry-private-token",
+  "description": "Fhenix Foundry private token capability with encrypted balances and CoFHE transfer gates.",
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "fhenix",
+      "protocol": "cofhe",
+      "runtime": "foundry",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-private-token", "cofhe-private-token", "forge-build"],
+    "requires": ["fhe-types", "cofhe", "foundry"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["forge build"],
+    "authenticitySignals": ["encrypted balance", "private token", "FHE.add", "FHE.gte", "FHE.select", "FHE.allow"]
+  },
+  "appliesTo": ["fhenix-foundry"],
+  "provides": ["fhe-private-token"],
+  "files": [
+    { "source": "files/PrivateToken.sol", "target": "src/PrivateToken.sol" }
+  ],
+  "contextHints": {
+    "extensionPoints": ["src/PrivateToken.sol"]
+  },
+  "keywords": ["private token", "encrypted balance", "confidential token", "private stablecoin", "fhe token", "encrypted transfer"]
+}

package/registry/layers/capability/fhe-foundry-private-voting/files/PrivateVoting.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {FHE, euint32, InEuint32} from "@fhenixprotocol/cofhe-contracts/FHE.sol";
+
+/// @title PrivateVoting
+/// @notice Encrypted on-chain voting where ballots and tallies stay ciphertexts.
+contract PrivateVoting {
+    address public owner;
+    bool public finalized;
+    uint256 public endTime;
+
+    euint32 private _yesVotes;
+    euint32 private _noVotes;
+    mapping(address => bool) public hasVoted;
+
+    constructor(uint256 durationSeconds) {
+        owner = msg.sender;
+        endTime = block.timestamp + durationSeconds;
+        _yesVotes = FHE.asEuint32(0);
+        _noVotes = FHE.asEuint32(0);
+        FHE.allowThis(_yesVotes);
+        FHE.allowThis(_noVotes);
+    }
+
+    function vote(InEuint32 calldata encryptedVote) external {
+        require(block.timestamp < endTime, "Voting ended");
+        require(!hasVoted[msg.sender], "Already voted");
+
+        euint32 voteValue = FHE.asEuint32(encryptedVote);
+        euint32 one = FHE.asEuint32(1);
+        euint32 zero = FHE.asEuint32(0);
+        euint32 normalizedYes = FHE.select(FHE.gte(voteValue, one), one, zero);
+        euint32 normalizedNo = FHE.select(FHE.gte(voteValue, one), zero, one);
+
+        hasVoted[msg.sender] = true;
+        _yesVotes = FHE.add(_yesVotes, normalizedYes);
+        _noVotes = FHE.add(_noVotes, normalizedNo);
+        FHE.allowThis(_yesVotes);
+        FHE.allowThis(_noVotes);
+    }
+
+    function finalize() external {
+        require(msg.sender == owner, "Only owner");
+        require(block.timestamp >= endTime, "Not ended yet");
+        finalized = true;
+        FHE.allowSender(_yesVotes);
+        FHE.allowSender(_noVotes);
+    }
+
+    function encryptedTallies() external view returns (euint32 yesVotes, euint32 noVotes) {
+        return (_yesVotes, _noVotes);
+    }
+}

package/registry/layers/capability/fhe-foundry-private-voting/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "fhe-foundry-private-voting",
+  "description": "Fhenix Foundry private voting capability with CoFHE encrypted ballots and homomorphic tallies.",
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "fhenix",
+      "protocol": "cofhe",
+      "runtime": "foundry",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-private-voting", "cofhe-private-voting", "forge-build"],
+    "requires": ["fhe-types", "cofhe", "foundry"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["forge build"],
+    "authenticitySignals": ["encrypted voting", "private voting", "secret ballot", "FHE.add", "FHE.gte", "FHE.select"]
+  },
+  "appliesTo": ["fhenix-foundry"],
+  "provides": ["fhe-private-voting"],
+  "files": [
+    { "source": "files/PrivateVoting.sol", "target": "src/PrivateVoting.sol" }
+  ],
+  "contextHints": {
+    "extensionPoints": ["src/PrivateVoting.sol"]
+  },
+  "keywords": ["encrypted voting", "private voting", "fhe voting", "confidential voting", "secret ballot"]
+}

package/registry/layers/capability/fhe-foundry-sealed-auction/files/SealedAuction.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {FHE, euint32, InEuint32} from "@fhenixprotocol/cofhe-contracts/FHE.sol";
+
+/// @title SealedAuction
+/// @notice Sealed-bid auction where bids stay encrypted and winner state is selected homomorphically.
+contract SealedAuction {
+    address public owner;
+    bool public ended;
+    uint256 public endTime;
+
+    euint32 private _highestBid;
+    mapping(address => euint32) private _bids;
+    mapping(address => bool) public hasBid;
+
+    constructor(uint256 durationSeconds) {
+        owner = msg.sender;
+        endTime = block.timestamp + durationSeconds;
+        _highestBid = FHE.asEuint32(0);
+        FHE.allowThis(_highestBid);
+    }
+
+    function bid(InEuint32 calldata encryptedBid) external {
+        require(block.timestamp < endTime, "Auction ended");
+        require(!hasBid[msg.sender], "Already bid");
+
+        euint32 bidAmount = FHE.asEuint32(encryptedBid);
+        euint32 nextHighest = FHE.select(FHE.gte(bidAmount, _highestBid), bidAmount, _highestBid);
+
+        _bids[msg.sender] = bidAmount;
+        _highestBid = nextHighest;
+        hasBid[msg.sender] = true;
+
+        FHE.allowThis(_bids[msg.sender]);
+        FHE.allowThis(_highestBid);
+        FHE.allowSender(bidAmount);
+    }
+
+    function endAuction() external {
+        require(msg.sender == owner, "Only owner");
+        require(block.timestamp >= endTime, "Not ended yet");
+        ended = true;
+        FHE.allowSender(_highestBid);
+    }
+
+    function encryptedBidOf(address bidder) external view returns (euint32) {
+        return _bids[bidder];
+    }
+
+    function encryptedHighestBid() external view returns (euint32) {
+        return _highestBid;
+    }
+}

package/registry/layers/capability/fhe-foundry-sealed-auction/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "fhe-foundry-sealed-auction",
+  "description": "Fhenix Foundry sealed-bid auction capability with CoFHE encrypted bids and winner selection.",
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "fhenix",
+      "protocol": "cofhe",
+      "runtime": "foundry",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-sealed-auction", "cofhe-sealed-auction", "forge-build"],
+    "requires": ["fhe-types", "cofhe", "foundry"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["forge build"],
+    "authenticitySignals": ["sealed bid", "blind auction", "encrypted auction", "FHE.gte", "FHE.select"]
+  },
+  "appliesTo": ["fhenix-foundry"],
+  "provides": ["fhe-sealed-auction"],
+  "files": [
+    { "source": "files/SealedAuction.sol", "target": "src/SealedAuction.sol" }
+  ],
+  "contextHints": {
+    "extensionPoints": ["src/SealedAuction.sol"]
+  },
+  "keywords": ["sealed bid", "sealed-bid", "blind auction", "encrypted auction", "sealed auction", "fhe auction"]
+}

package/registry/layers/capability/fhe-private-token/manifest.json

@@ -1,7 +1,22 @@
 {
   "id": "fhe-private-token",
   "description": "ERC20-like token with encrypted balances using FHE — transfer amounts and balances stay private.",
-  "appliesTo": ["fhenix-contracts", "fhevm-contracts"],
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "fhenix",
+      "protocol": "cofhe",
+      "runtime": "hardhat",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-private-token", "cofhe-private-token", "hardhat-build"],
+    "requires": ["fhe-types", "cofhe", "hardhat"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["npx hardhat compile"],
+    "authenticitySignals": ["encrypted balance", "private token", "FHE.add", "FHE.gte", "FHE.allow"]
+  },
+  "appliesTo": ["fhenix-contracts"],
+  "provides": ["fhe-private-token"],
   "files": [
     { "source": "files/PrivateToken.sol", "target": "contracts/PrivateToken.sol" }
   ],

package/registry/layers/capability/fhe-private-voting/manifest.json

@@ -1,7 +1,22 @@
 {
   "id": "fhe-private-voting",
   "description": "Private on-chain voting using FHE — individual votes stay encrypted, tally computed homomorphically.",
-  "appliesTo": ["fhenix-contracts", "fhevm-contracts"],
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "fhenix",
+      "protocol": "cofhe",
+      "runtime": "hardhat",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-private-voting", "cofhe-private-voting", "hardhat-build"],
+    "requires": ["fhe-types", "cofhe", "hardhat"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["npx hardhat compile"],
+    "authenticitySignals": ["encrypted voting", "private voting", "secret ballot", "FHE.add", "FHE.select"]
+  },
+  "appliesTo": ["fhenix-contracts"],
+  "provides": ["fhe-private-voting"],
   "files": [
     { "source": "files/PrivateVoting.sol", "target": "contracts/PrivateVoting.sol" }
   ],

package/registry/layers/capability/fhe-sealed-auction/manifest.json

@@ -1,12 +1,27 @@
 {
   "id": "fhe-sealed-auction",
   "description": "Sealed-bid auction using FHE — bids stay encrypted, winner determined homomorphically.",
-  "appliesTo": ["fhenix-contracts", "fhevm-contracts"],
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "fhenix",
+      "protocol": "cofhe",
+      "runtime": "hardhat",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-sealed-auction", "cofhe-sealed-auction", "hardhat-build"],
+    "requires": ["fhe-types", "cofhe", "hardhat"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["npx hardhat compile"],
+    "authenticitySignals": ["sealed bid", "blind auction", "encrypted auction", "FHE.gt", "FHE.select"]
+  },
+  "appliesTo": ["fhenix-contracts"],
+  "provides": ["fhe-sealed-auction"],
   "files": [
     { "source": "files/SealedAuction.sol", "target": "contracts/SealedAuction.sol" }
   ],
   "contextHints": {
     "extensionPoints": ["contracts/SealedAuction.sol"]
   },
-  "keywords": ["sealed bid", "blind auction", "encrypted auction", "sealed auction", "fhe auction"]
+  "keywords": ["sealed bid", "sealed-bid", "blind auction", "encrypted auction", "sealed auction", "fhe auction"]
 }

package/registry/layers/capability/fhevm-private-token/files/PrivateToken.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {FHE, euint64, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/// @title PrivateToken
+/// @notice ERC20-like token with encrypted balances using Zama fhEVM.
+contract PrivateToken is ZamaEthereumConfig {
+    string public name;
+    string public symbol;
+    address public minter;
+
+    mapping(address => euint64) private _balances;
+    euint64 private _totalSupply;
+
+    event Transfer(address indexed from, address indexed to);
+
+    constructor(string memory tokenName, string memory tokenSymbol) {
+        name = tokenName;
+        symbol = tokenSymbol;
+        minter = msg.sender;
+        _totalSupply = FHE.asEuint64(0);
+        FHE.allowThis(_totalSupply);
+    }
+
+    function mint(address to, externalEuint64 encryptedAmount, bytes calldata inputProof) external {
+        require(msg.sender == minter, "Only minter");
+        euint64 amount = FHE.fromExternal(encryptedAmount, inputProof);
+        _balances[to] = FHE.add(_balances[to], amount);
+        _totalSupply = FHE.add(_totalSupply, amount);
+        FHE.allowThis(_balances[to]);
+        FHE.allowThis(_totalSupply);
+        FHE.allow(_balances[to], to);
+    }
+
+    function transfer(address to, externalEuint64 encryptedAmount, bytes calldata inputProof) external {
+        euint64 amount = FHE.fromExternal(encryptedAmount, inputProof);
+        euint64 zero = FHE.asEuint64(0);
+        euint64 allowedAmount = FHE.select(FHE.gte(_balances[msg.sender], amount), amount, zero);
+
+        _balances[msg.sender] = FHE.sub(_balances[msg.sender], allowedAmount);
+        _balances[to] = FHE.add(_balances[to], allowedAmount);
+        FHE.allowThis(_balances[msg.sender]);
+        FHE.allowThis(_balances[to]);
+        FHE.allow(_balances[msg.sender], msg.sender);
+        FHE.allow(_balances[to], to);
+
+        emit Transfer(msg.sender, to);
+    }
+
+    function encryptedBalanceOf(address account) external view returns (euint64) {
+        return _balances[account];
+    }
+}

package/registry/layers/capability/fhevm-private-token/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "fhevm-private-token",
+  "description": "Zama fhEVM private token capability with encrypted balances and FHEVM transfer gates.",
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "zama",
+      "protocol": "fhevm",
+      "runtime": "hardhat",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-private-token", "tfhe-private-token", "hardhat-build"],
+    "requires": ["fhe-types", "tfhe", "hardhat"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["npx hardhat compile"],
+    "authenticitySignals": ["encrypted balance", "private token", "externalEuint64", "FHE.fromExternal", "FHE.add", "FHE.gte", "FHE.select", "FHE.allowThis"]
+  },
+  "appliesTo": ["fhevm-contracts"],
+  "provides": ["fhe-private-token"],
+  "files": [
+    { "source": "files/PrivateToken.sol", "target": "contracts/PrivateToken.sol" }
+  ],
+  "contextHints": {
+    "extensionPoints": ["contracts/PrivateToken.sol"]
+  },
+  "keywords": ["private token", "encrypted balance", "confidential token", "private stablecoin", "fhe token", "encrypted transfer"]
+}

package/registry/layers/capability/fhevm-private-voting/files/PrivateVoting.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {FHE, ebool, euint64, externalEbool} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/// @title PrivateVoting
+/// @notice Encrypted on-chain voting using Zama fhEVM encrypted conditionals.
+contract PrivateVoting is ZamaEthereumConfig {
+    address public owner;
+    bool public finalized;
+    uint256 public endTime;
+
+    euint64 private _yesVotes;
+    euint64 private _noVotes;
+    mapping(address => bool) public hasVoted;
+
+    constructor(uint256 durationSeconds) {
+        owner = msg.sender;
+        endTime = block.timestamp + durationSeconds;
+        _yesVotes = FHE.asEuint64(0);
+        _noVotes = FHE.asEuint64(0);
+        FHE.allowThis(_yesVotes);
+        FHE.allowThis(_noVotes);
+    }
+
+    function vote(externalEbool encryptedSupport, bytes calldata inputProof) external {
+        require(block.timestamp < endTime, "Voting ended");
+        require(!hasVoted[msg.sender], "Already voted");
+
+        ebool support = FHE.fromExternal(encryptedSupport, inputProof);
+
+        hasVoted[msg.sender] = true;
+        _yesVotes = FHE.select(support, FHE.add(_yesVotes, 1), _yesVotes);
+        _noVotes = FHE.select(support, _noVotes, FHE.add(_noVotes, 1));
+        FHE.allowThis(_yesVotes);
+        FHE.allowThis(_noVotes);
+    }
+
+    function finalize() external {
+        require(msg.sender == owner, "Only owner");
+        require(block.timestamp >= endTime, "Not ended yet");
+        finalized = true;
+        FHE.allow(_yesVotes, msg.sender);
+        FHE.allow(_noVotes, msg.sender);
+    }
+
+    function encryptedTallies() external view returns (euint64 yesVotes, euint64 noVotes) {
+        return (_yesVotes, _noVotes);
+    }
+}

package/registry/layers/capability/fhevm-private-voting/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "fhevm-private-voting",
+  "description": "Zama fhEVM private voting capability with encrypted ballots and FHEVM tally selection.",
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "zama",
+      "protocol": "fhevm",
+      "runtime": "hardhat",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-private-voting", "tfhe-private-voting", "hardhat-build"],
+    "requires": ["fhe-types", "tfhe", "hardhat"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["npx hardhat compile"],
+    "authenticitySignals": ["encrypted voting", "private voting", "secret ballot", "externalEbool", "FHE.fromExternal", "FHE.add", "FHE.select", "FHE.allowThis"]
+  },
+  "appliesTo": ["fhevm-contracts"],
+  "provides": ["fhe-private-voting"],
+  "files": [
+    { "source": "files/PrivateVoting.sol", "target": "contracts/PrivateVoting.sol" }
+  ],
+  "contextHints": {
+    "extensionPoints": ["contracts/PrivateVoting.sol"]
+  },
+  "keywords": ["encrypted voting", "private voting", "fhe voting", "confidential voting", "secret ballot"]
+}

package/registry/layers/capability/fhevm-sealed-auction/files/SealedAuction.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {FHE, euint64, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/// @title SealedAuction
+/// @notice Sealed-bid auction using Zama fhEVM encrypted conditionals.
+contract SealedAuction is ZamaEthereumConfig {
+    address public owner;
+    bool public ended;
+    uint256 public endTime;
+
+    euint64 private _highestBid;
+    mapping(address => euint64) private _bids;
+    mapping(address => bool) public hasBid;
+
+    constructor(uint256 durationSeconds) {
+        owner = msg.sender;
+        endTime = block.timestamp + durationSeconds;
+        _highestBid = FHE.asEuint64(0);
+        FHE.allowThis(_highestBid);
+    }
+
+    function bid(externalEuint64 encryptedBid, bytes calldata inputProof) external {
+        require(block.timestamp < endTime, "Auction ended");
+        require(!hasBid[msg.sender], "Already bid");
+
+        euint64 bidAmount = FHE.fromExternal(encryptedBid, inputProof);
+        euint64 nextHighest = FHE.select(FHE.gte(bidAmount, _highestBid), bidAmount, _highestBid);
+
+        _bids[msg.sender] = bidAmount;
+        _highestBid = nextHighest;
+        hasBid[msg.sender] = true;
+
+        FHE.allowThis(_bids[msg.sender]);
+        FHE.allowThis(_highestBid);
+        FHE.allow(_bids[msg.sender], msg.sender);
+    }
+
+    function endAuction() external {
+        require(msg.sender == owner, "Only owner");
+        require(block.timestamp >= endTime, "Not ended yet");
+        ended = true;
+        FHE.allow(_highestBid, msg.sender);
+    }
+
+    function encryptedBidOf(address bidder) external view returns (euint64) {
+        return _bids[bidder];
+    }
+
+    function encryptedHighestBid() external view returns (euint64) {
+        return _highestBid;
+    }
+}

package/registry/layers/capability/fhevm-sealed-auction/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "fhevm-sealed-auction",
+  "description": "Zama fhEVM sealed-bid auction capability with encrypted bids and FHEVM winner selection.",
+  "domainPack": {
+    "domain": {
+      "family": "fhe",
+      "provider": "zama",
+      "protocol": "fhevm",
+      "runtime": "hardhat",
+      "surface": "contracts"
+    },
+    "provides": ["fhe-sealed-auction", "tfhe-sealed-auction", "hardhat-build"],
+    "requires": ["fhe-types", "tfhe", "hardhat"],
+    "ambiguityGroup": "fhe-capabilities",
+    "validationCommands": ["npx hardhat compile"],
+    "authenticitySignals": ["sealed bid", "blind auction", "encrypted auction", "externalEuint64", "FHE.fromExternal", "FHE.gte", "FHE.select", "FHE.allowThis"]
+  },
+  "appliesTo": ["fhevm-contracts"],
+  "provides": ["fhe-sealed-auction"],
+  "files": [
+    { "source": "files/SealedAuction.sol", "target": "contracts/SealedAuction.sol" }
+  ],
+  "contextHints": {
+    "extensionPoints": ["contracts/SealedAuction.sol"]
+  },
+  "keywords": ["sealed bid", "sealed-bid", "blind auction", "encrypted auction", "sealed auction", "fhe auction"]
+}

package/registry/layers/capability/layout-auth/manifest.json

@@ -50,6 +50,13 @@
   },
   "tieredKeywords": {
     "archetypes": [
+      "sign in",
+      "sign up",
+      "sign-in",
+      "sign-up",
+      "login page",
+      "register page",
+      "authentication pages",
       "client portal",
       "customer portal",
       "tenant portal",

package/registry/layers/capability/layout-chat/manifest.json

@@ -82,6 +82,9 @@
   },
   "tieredKeywords": {
     "archetypes": [
+      "chat app",
+      "chat interface",
+      "streaming chat",
       "chatbot",
       "chat bot",
       "support bot",

package/registry/layers/capability/tangle-remote-provider/files/remote-config.json

@@ -15,7 +15,7 @@
     {
       "id": "router-tangle",
       "baseUrl": "https://router.tangle.tools",
-      "credentialKey": "TANGLE_ROUTER_API_KEY",
+      "credentialKey": "TANGLE_API_KEY",
       "note": "Tangle's own router — prefer this so billing + observability stays inside the platform."
     }
   ],

package/registry/layers/capability/zk-browser/manifest.json

@@ -91,11 +91,11 @@
     "archetypes": [
       "mixer",
       "privacy-preserving mixer",
-      "private voting",
       "anonymous voting",
       "anonymous credential",
       "nullifier",
       "commitment preimage",
+      "merkle proof",
       "merkle root display",
       "zk proof",
       "zk-snark",

package/registry/layers/framework/aptos-move/files/package.json

@@ -5,5 +5,9 @@
   "scripts": {
     "build": "aptos move compile --named-addresses {{projectName}}=default",
     "test": "aptos move test --named-addresses {{projectName}}=default"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/crm-backend/files/package.json

@@ -18,5 +18,9 @@
     "drizzle-kit": "^0.30.0",
     "typescript": "^5.9.0",
     "@types/node": "^20.17.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/ecommerce-headless/files/package.json

@@ -19,5 +19,9 @@
     "drizzle-kit": "^0.30.0",
     "typescript": "^5.9.0",
     "@types/node": "^20.17.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }