@openzeppelin/compact-contracts 0.4.0-alpha.3 → 0.4.0-alpha.5

package/access/AccessControl.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (access/AccessControl.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (access/AccessControl.compact)
 
 pragma language_version >= 0.26.0;
 

package/access/Ownable.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (access/Ownable.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (access/Ownable.compact)
 
 pragma language_version >= 0.26.0;
 

package/access/ShieldedAccessControl.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (access/ShieldedAccessControl.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (access/ShieldedAccessControl.compact)
 
 pragma language_version >= 0.26.0;
 

package/access/ZOwnablePK.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (access/ZOwnablePK.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (access/ZOwnablePK.compact)
 
 pragma language_version >= 0.26.0;
 

package/crypto/EcdhMask.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (crypto/EcdhMask.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (crypto/EcdhMask.compact)
 
 pragma language_version >= 0.26.0;
 

package/crypto/Ecdsa.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (crypto/Ecdsa.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (crypto/Ecdsa.compact)
 
 pragma language_version >= 0.26.0;
 

package/crypto/Eip712.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (crypto/Eip712.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (crypto/Eip712.compact)
 
 pragma language_version >= 0.26.0;
 

package/crypto/ElGamal.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (crypto/ElGamal.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (crypto/ElGamal.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/EcdsaSignerManager.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/EcdsaSignerManager.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/EcdsaSignerManager.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -77,13 +77,14 @@ module EcdsaSignerManager {
    * - Can only be called once.
    * - `instanceSalt` should be cryptographically random.
    * - `signerCommitments` must not contain duplicates.
-   * - `threshold` must be non-zero and must not exceed `n`.
-   * - `threshold` must not exceed 2, the number of approvals `assertApprovals`
-   *   verifies.
+   * - `n` must be at least 2, the number of distinct signers `assertApprovals`
+   *   verifies. A smaller set can never satisfy it.
+   * - `threshold` must be 2, the number of approvals `assertApprovals`
+   *   verifies. Any other value would misreport what the circuit enforces.
    *
    * @param {Bytes<32>} instanceSalt - Per-deployment salt for commitment derivation.
    * @param {Vector<n, Bytes<32>>} signerCommitments - Hashed signer identities.
-   * @param {Uint<8>} threshold - Minimum approvals required.
+   * @param {Uint<8>} threshold - Approvals required. Must be 2.
    * @returns {[]} Empty tuple.
    */
   export circuit initialize<#n>(
@@ -93,11 +94,12 @@ module EcdsaSignerManager {
   ): [] {
     assert(Signer_getSignerCount() == 0, "EcdsaSignerManager: signers already registered");
     _instanceSalt = disclose(instanceSalt);
-    assert(threshold <= 2, "EcdsaSignerManager: threshold cannot exceed 2 (assertApprovals verifies 2 signatures)");
+    assert(threshold == 2, "EcdsaSignerManager: threshold must be 2 (assertApprovals verifies 2 signatures)");
 
     for (const commitment of signerCommitments) {
       Signer__addSigner(commitment);
     }
+    assert(Signer_getSignerCount() >= 2, "EcdsaSignerManager: fewer than 2 signers (assertApprovals verifies 2 signatures)");
     Signer__changeThreshold(threshold);
   }
 
@@ -140,7 +142,7 @@ module EcdsaSignerManager {
    * same signer.
    *
    * @dev Both entries are asserted, so the count handed to the threshold check
-   * is always 2 and a threshold below 2 admits nothing extra.
+   * is always 2, matching the only threshold `initialize` accepts.
    *
    * @constraints k=17, rows=64916 (zkir-v3)
    *

package/multisig/ForwarderPrivate.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/ForwarderPrivate.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/ForwarderPrivate.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/ForwarderShielded.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/ForwarderShielded.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/ForwarderShielded.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -41,6 +41,11 @@ pragma language_version >= 0.26.0;
  * coins. Forwarding to a key no one controls strands every deposit
  * permanently. The zero-key guard rejects only the all-zero key, not an
  * otherwise-unspendable one.
+ *
+ * @notice The depositor must encrypt the forwarded output to the parent's
+ * encryption public key, obtained off-chain. The ledger cannot check that
+ * key against `_parent`, so a wrong or missing key leaves the coin
+ * spendable by the parent but invisible to its wallet.
  */
 module ForwarderShielded {
   import CompactStandardLibrary;
@@ -103,20 +108,24 @@ module ForwarderShielded {
    * `sendImmediateShielded` to the stored parent recipient (always the
    * `left` / coin-public-key arm today).
    *
-   * @constraints k=15, rows=24373
+   * @constraints k=15, rows=23197
    *
    * Requirements:
    *
    * - Contract must be initialized.
+   * - The forwarded output must be encrypted to the parent's encryption
+   *   public key (see the module header). If unsure, hand the returned
+   *   `ShieldedSendResult` to the parent so it can recover the coin.
    *
    * @param {ShieldedCoinInfo} coin - The incoming shielded coin.
    *
-   * @returns {[]} Empty tuple.
+   * @returns {ShieldedSendResult} The coin sent to the parent, with no change:
+   * the whole value is forwarded.
    */
-  export circuit _deposit(coin: ShieldedCoinInfo): [] {
+  export circuit _deposit(coin: ShieldedCoinInfo): ShieldedSendResult {
     assertInitialized();
     receiveShielded(disclose(coin));
-    sendImmediateShielded(disclose(coin), _parent, disclose(coin.value));
+    return sendImmediateShielded(disclose(coin), _parent, disclose(coin.value));
   }
 
   // ─── Init guards ────────────────────────────────────────────────

package/multisig/ForwarderUnshielded.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/ForwarderUnshielded.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/ForwarderUnshielded.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/ProposalManager.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/ProposalManager.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/ProposalManager.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/ShieldedTreasury.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/ShieldedTreasury.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/ShieldedTreasury.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/ShieldedTreasuryStateless.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/ShieldedTreasuryStateless.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/ShieldedTreasuryStateless.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/Signer.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/Signer.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/Signer.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/UnshieldedTreasury.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/UnshieldedTreasury.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/UnshieldedTreasury.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -90,8 +90,7 @@ module UnshieldedTreasury {
   // ─── Send ───────────────────────────────────────────────────────
 
   /**
-   * @description Sends unshielded tokens from the treasury. Zero-amount sends
-   * are permitted and are value-preserving no-ops.
+   * @description Sends unshielded tokens from the treasury.
    *
    * @warning Recipients are not validated. An unspendable recipient (such as a
    * zero address) is accepted and permanently removes the funds from the
@@ -111,6 +110,7 @@ module UnshieldedTreasury {
    *
    * Requirements:
    *
+   * - The amount must be non-zero. The ledger rejects zero-value outputs.
    * - The treasury must hold sufficient balance for the given token color.
    *
    * @param {Either<ContractAddress, UserAddress>} recipient - The recipient address.
@@ -124,6 +124,8 @@ module UnshieldedTreasury {
     color: Bytes<32>,
     amount: Uint<128>
   ): [] {
+    assert(amount != 0, "UnshieldedTreasury: zero amount");
+
     const bal = getTokenBalance(color);
     assert(bal >= amount, "UnshieldedTreasury: insufficient balance");
 

package/multisig/examples/ForwarderPrivateExample.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/examples/ForwarderPrivateExample.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/examples/ForwarderPrivateExample.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/examples/ForwarderShieldedExample.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/examples/ForwarderShieldedExample.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/examples/ForwarderShieldedExample.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -24,7 +24,7 @@ pragma language_version >= 0.26.0;
 import CompactStandardLibrary;
 import "../ForwarderShielded" prefix Forwarder_;
 
-export { ZswapCoinPublicKey, ContractAddress, ShieldedCoinInfo, Either };
+export { ZswapCoinPublicKey, ContractAddress, ShieldedCoinInfo, ShieldedSendResult, Maybe, Either };
 
 /**
  * @description Deploys the forwarder bound to a specific parent
@@ -42,12 +42,15 @@ constructor(parent: ZswapCoinPublicKey) {
  * the configured parent. The coin is claimed via `receiveShielded` and
  * immediately re-sent via `sendImmediateShielded`.
  *
+ * The depositor must encrypt the forwarded output to the parent's
+ * encryption public key (see the `ForwarderShielded` header).
+ *
  * @param {ShieldedCoinInfo} coin - The incoming shielded coin.
  *
- * @returns {[]} Empty tuple.
+ * @returns {ShieldedSendResult} The coin sent to the parent, with no change.
  */
-export circuit deposit(coin: ShieldedCoinInfo): [] {
-  Forwarder__deposit(coin);
+export circuit deposit(coin: ShieldedCoinInfo): ShieldedSendResult {
+  return Forwarder__deposit(coin);
 }
 
 /**

package/multisig/examples/ForwarderUnshieldedExample.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/examples/ForwarderUnshieldedExample.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/examples/ForwarderUnshieldedExample.compact)
 
 pragma language_version >= 0.26.0;
 

package/multisig/examples/NativeShieldedTokenIssuerExample.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/examples/NativeShieldedTokenIssuerExample.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/examples/NativeShieldedTokenIssuerExample.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -7,10 +7,14 @@ pragma language_version >= 0.26.0;
  * @title NativeShieldedTokenIssuerExample
  * @description Deployable reference contract for the `NativeShieldedTokenIssuer`
  * preset: a native shielded token whose supply enters only through an
- * ECDSA-authorized mint and leaves only through an ECDSA-authorized burn.
+ * ECDSA-authorized mint, to a holder (`mint`) or to the contract itself
+ * (`mintToSelf`), and leaves only through an ECDSA-authorized burn, of a
+ * holder's coin (`burn`) or of one the contract holds (`burnFromSelf`).
  *
- * The token is non-transferable by construction. There is no transfer circuit,
- * so a holder's only exit is to present the coin back for burn.
+ * Coins minted to holders are ordinary Zswap coins: holders transfer them
+ * through Zswap without the issuer's involvement and redeem by paying one
+ * into a `burn` tx. Only contract-held coins are locked. No send circuit
+ * exists, so they leave through `burnFromSelf` alone.
  */
 
 import CompactStandardLibrary;
@@ -94,20 +98,38 @@ export pure circuit _calculateSignerId(
 
 export circuit mint(
   amount: Uint<64>,
-  recipient: Either<ZswapCoinPublicKey, ContractAddress>,
+  recipient: ZswapCoinPublicKey,
   pubkeys: Vector<2, Secp256k1Point>,
   signatures: Vector<2, Secp256k1EcdsaSignature>
 ): ShieldedCoinInfo {
   return NativeShieldedTokenIssuer_mint(amount, recipient, pubkeys, signatures);
 }
 
+export circuit mintToSelf(
+  amount: Uint<64>,
+  pubkeys: Vector<2, Secp256k1Point>,
+  signatures: Vector<2, Secp256k1EcdsaSignature>
+): ShieldedCoinInfo {
+  return NativeShieldedTokenIssuer_mintToSelf(amount, pubkeys, signatures);
+}
+
 export circuit burn(
+  coin: ShieldedCoinInfo,
+  amount: Uint<128>,
+  refundTo: ZswapCoinPublicKey,
+  pubkeys: Vector<2, Secp256k1Point>,
+  signatures: Vector<2, Secp256k1EcdsaSignature>
+): Maybe<ShieldedCoinInfo> {
+  return NativeShieldedTokenIssuer_burn(coin, amount, refundTo, pubkeys, signatures);
+}
+
+export circuit burnFromSelf(
   coin: QualifiedShieldedCoinInfo,
-  amount: Uint<64>,
+  amount: Uint<128>,
   pubkeys: Vector<2, Secp256k1Point>,
   signatures: Vector<2, Secp256k1EcdsaSignature>
 ): Maybe<ShieldedCoinInfo> {
-  return NativeShieldedTokenIssuer_burn(coin, amount, pubkeys, signatures);
+  return NativeShieldedTokenIssuer_burnFromSelf(coin, amount, pubkeys, signatures);
 }
 
 export circuit getNonce(): Uint<64> {

package/multisig/examples/ShieldedMultiSigV2Example.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.3 (multisig/examples/ShieldedMultiSigV2Example.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.5 (multisig/examples/ShieldedMultiSigV2Example.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -29,7 +29,7 @@ export { _domainSeparator };
  *
  * @param {Bytes<32>} instanceSalt - Random salt for commitment derivation.
  * @param {Vector<3, Bytes<32>>} signerCommitments - Hashed signer identities.
- * @param {Uint<8>} thresh - Minimum approvals required.
+ * @param {Uint<8>} thresh - Approvals required. Must be 2.
  */
 constructor(
   instanceSalt: Bytes<32>,