@openzeppelin/compact-contracts 0.4.0-alpha.4 → 0.4.0-alpha.6

package/multisig/presets/ShieldedMultiSigV2.compact

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (multisig/presets/ShieldedMultiSigV2.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (multisig/presets/ShieldedMultiSigV2.compact)
 
 pragma language_version >= 0.26.0;
 
 /**
  * @module ShieldedMultiSigV2
- * @description Privacy-preserving 2-of-3 multisig contract.
+ * @description Privacy-preserving threshold multisig contract.
  *
  * Signer identities are stored as commitments: hashes of ECDSA public
  * keys combined with an instance salt and domain separator. Signature
@@ -14,6 +14,12 @@ pragma language_version >= 0.26.0;
  * and replay protection. All other coordination (signature collection,
  * coin selection) happens off-chain.
  *
+ * `t` is the approval width and the threshold: `execute` verifies exactly
+ * `t` distinct signers. Import as `"../presets/ShieldedMultiSigV2"<t>`; the
+ * implementing contract fixes the signer count `n` at `initialize`. Import
+ * one width per contract: two widths share one signer registry, see
+ * `Secp256k1EcdsaMultisig`.
+ *
  * Treasury is fully stateless meaning coin data is not stored on the public ledger.
  * Deposits call receiveShielded only. The operator discovers coin indices
  * through ZswapOutput events from the indexer, constructs QualifiedShieldedCoinInfo
@@ -23,12 +29,12 @@ pragma language_version >= 0.26.0;
  *
  * @notice Implementing contracts register the signer set from their
  * constructor by calling this module's `initialize`, and MUST NOT import
- * `EcdsaSignerManager` directly.
+ * `Signer` or `Secp256k1EcdsaMultisig` directly.
  */
-module ShieldedMultiSigV2 {
+module ShieldedMultiSigV2<#t> {
   import CompactStandardLibrary;
 
-  import "../EcdsaSignerManager" prefix EcdsaSignerManager_;
+  import "../Secp256k1EcdsaMultisig"<t> prefix Secp256k1EcdsaMultisig_;
   import "../../crypto/Eip712" prefix Eip712_;
   import "../../utils/EvmAbi" prefix EvmAbi_;
   import "../ProposalManager" prefix Proposal_;
@@ -39,8 +45,6 @@ module ShieldedMultiSigV2 {
   // unwritten copy of its state.
   export { Proposal_Recipient };
 
-  // ─── State ──────────────────────────────────────────────────────
-
   /**
    * @description Monotonic operation counter. `execute` reads it as that
    * operation's nonce and then increments, so no two executions share one.
@@ -54,10 +58,8 @@ module ShieldedMultiSigV2 {
    */
   export sealed ledger _domainSeparator: Bytes<32>;
 
-  // ─── Initialization ─────────────────────────────────────────────
-
   /**
-   * @description Registers the signer set and threshold, and fixes the
+   * @description Registers the signer set at threshold `t` and fixes the
    * EIP-712 domain separator.
    *
    * @notice Call from the implementing contract's constructor only. It writes
@@ -82,19 +84,17 @@ module ShieldedMultiSigV2 {
    *
    * - `instanceSalt` should be cryptographically random.
    * - `signerCommitments` must not contain duplicates.
-   * - `thresh` must be non-zero and must not exceed 2.
+   * - `n` must be at least `t`.
    *
    * @param {Bytes<32>} instanceSalt - Per-deployment salt for commitment derivation.
-   * @param {Vector<3, Bytes<32>>} signerCommitments - Hashed signer identities.
-   * @param {Uint<8>} thresh - Minimum approvals required.
+   * @param {Vector<n, Bytes<32>>} signerCommitments - Hashed signer identities.
    * @returns {[]} Empty tuple.
    */
-  export circuit initialize(
+  export circuit initialize<#n>(
     instanceSalt: Bytes<32>,
-    signerCommitments: Vector<3, Bytes<32>>,
-    thresh: Uint<8>
+    signerCommitments: Vector<n, Bytes<32>>
   ): [] {
-    EcdsaSignerManager_initialize<3>(instanceSalt, signerCommitments, thresh);
+    Secp256k1EcdsaMultisig_initialize<n>(instanceSalt, signerCommitments);
 
     const hashedName = keccak256<Bytes<18>>(pad(18, "ShieldedMultiSigV2"));
     const hashedVersion = keccak256<Bytes<1>>(pad(1, "1"));
@@ -127,8 +127,6 @@ module ShieldedMultiSigV2 {
     return typeHash as Bytes<32>;
   }
 
-  // ─── Deposit ────────────────────────────────────────────────────
-
   /**
    * @description Receives a shielded coin into the multisig treasury.
    *
@@ -149,8 +147,6 @@ module ShieldedMultiSigV2 {
     receiveShielded(disclose(coin));
   }
 
-  // ─── Execute ────────────────────────────────────────────────────
-
   /**
    * @description Executes a shielded send authorized by threshold signatures.
    *
@@ -161,25 +157,29 @@ module ShieldedMultiSigV2 {
    * separator. The digest is bound to the contract instance and the full recipient (kind and
    * address), so a signature authorizes exactly one operation on one instance.
    *
-   * Approvals are checked by `EcdsaSignerManager`, which derives each signer's
-   * commitment from their public key and the instance salt, rejects duplicates,
-   * and enforces the threshold.
+   * Approvals are checked by `Secp256k1EcdsaMultisig`, which derives each
+   * signer's commitment from their public key and the instance salt and
+   * rejects duplicates. Constraints below are measured at `t = 2`.
    *
-   * @constraints k=17, rows=104644 (zkir-v3)
+   * @notice `to` must be a `ShieldedUser`. A contract-addressed coin would be
+   * unclaimable, making the transaction malformed.
+   *
+   * @constraints k=17, rows=98969 (zkir-v3)
    *
    * Requirements:
    *
-   * - Both public keys must hash to registered signer commitments.
-   * - Both signatures must be valid over the message hash and use the low-s
+   * - No two entries may be the same signer.
+   * - Every public key must hash to a registered signer commitment.
+   * - Every signature must be valid over the message hash and use the low-s
    *   encoding.
-   * - Signers must not be duplicates.
+   * - `to.kind` must be `ShieldedUser`.
    * - Coin value must be >= amount.
    *
    * @param {Proposal_Recipient} to - The recipient.
    * @param {Uint<128>} amount - The amount to send.
    * @param {QualifiedShieldedCoinInfo} coin - The coin to spend (from operator's pool).
-   * @param {Vector<2, Secp256k1Point>} pubkeys - Public keys of approving signers.
-   * @param {Vector<2, Secp256k1EcdsaSignature>} signatures - ECDSA signatures over the operation.
+   * @param {Vector<t, Secp256k1Point>} pubkeys - Public keys of approving signers.
+   * @param {Vector<t, Secp256k1EcdsaSignature>} signatures - ECDSA signatures over the operation.
    *
    * @returns {ShieldedSendResult} The send result including any change.
    */
@@ -187,8 +187,8 @@ module ShieldedMultiSigV2 {
     to: Proposal_Recipient,
     amount: Uint<128>,
     coin: QualifiedShieldedCoinInfo,
-    pubkeys: Vector<2, Secp256k1Point>,
-    signatures: Vector<2, Secp256k1EcdsaSignature>
+    pubkeys: Vector<t, Secp256k1Point>,
+    signatures: Vector<t, Secp256k1EcdsaSignature>
   ): ShieldedSendResult {
     // Increment nonce
     const currentNonce = _nonce;
@@ -208,18 +208,21 @@ module ShieldedMultiSigV2 {
       EvmAbi_uint128Word(amount)
     ]));
 
-    EcdsaSignerManager_assertApprovals(msgHash, pubkeys, signatures);
+    Secp256k1EcdsaMultisig_assertApprovals(msgHash, pubkeys, signatures);
 
-    // Execute transfer
-    const normalizedRecipient = Proposal_toShieldedRecipient(to);
-    return Treasury__send(coin, normalizedRecipient, amount);
+    assert(
+      to.kind == Proposal_RecipientKind.ShieldedUser,
+      "ShieldedMultiSigV2: recipient must be a coin public key"
+    );
+    const recipient = left<ZswapCoinPublicKey, ContractAddress>(
+      ZswapCoinPublicKey { bytes: to.address }
+    );
+    return Treasury__send(coin, recipient, amount);
   }
 
-  // ─── Commitments ────────────────────────────────────────────────
-
   /**
    * @description Computes a signer commitment from a secp256k1 public key,
-   * as `persistentHash(pkX, pkY, salt, "multisig:signer:")`.
+   * as `persistentHash(pkX, pkY, salt, "Secp256k1EcdsaMultisig:signer")`.
    *
    * Pure, so the deployer can derive constructor commitments off-chain.
    *
@@ -236,11 +239,9 @@ module ShieldedMultiSigV2 {
     pk: Secp256k1Point,
     salt: Bytes<32>
   ): Bytes<32> {
-    return EcdsaSignerManager_calculateSignerId(pk, salt);
+    return Secp256k1EcdsaMultisig_calculateSignerId(pk, salt);
   }
 
-  // ─── View ───────────────────────────────────────────────────────
-
   /**
    * @description Returns the nonce the next `execute` digest will bind to.
    *
@@ -260,7 +261,7 @@ module ShieldedMultiSigV2 {
    * @returns {Uint<8>} The signer count.
    */
   export circuit getSignerCount(): Uint<8> {
-    return EcdsaSignerManager_getSignerCount();
+    return Secp256k1EcdsaMultisig_getSignerCount();
   }
 
   /**
@@ -271,7 +272,7 @@ module ShieldedMultiSigV2 {
    * @returns {Uint<8>} The threshold.
    */
   export circuit getThreshold(): Uint<8> {
-    return EcdsaSignerManager_getThreshold();
+    return Secp256k1EcdsaMultisig_getThreshold();
   }
 
   /**
@@ -283,6 +284,6 @@ module ShieldedMultiSigV2 {
    * @returns {Boolean} True if registered.
    */
   export circuit isSigner(commitment: Bytes<32>): Boolean {
-    return EcdsaSignerManager_isSigner(commitment);
+    return Secp256k1EcdsaMultisig_isSigner(commitment);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/compact-contracts",
-  "version": "0.4.0-alpha.4",
+  "version": "0.4.0-alpha.6",
   "description": "OpenZeppelin Compact contract library",
   "keywords": [
     "openzeppelin",
@@ -65,7 +65,7 @@
     "@noble/curves": "^2.2.0",
     "@noble/hashes": "^2.4.0",
     "@openzeppelin/compact-deployer": "^0.3.1",
-    "@openzeppelin/compact-simulator": "^0.4.0",
+    "@openzeppelin/compact-simulator": "^0.4.1",
     "@tsconfig/node24": "^24.0.5",
     "@types/node": "26.6.2",
     "@vitest/coverage-v8": "^5.0.0",

package/security/Allowlist.compact

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

package/security/Blocklist.compact

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

package/security/Initializable.compact

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

package/security/Pausable.compact

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

package/token/ConfidentialFungibleToken.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (token/ConfidentialFungibleToken.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/ConfidentialFungibleToken.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -242,6 +242,22 @@ pragma language_version >= 0.26.0;
  * Raising the limit itself is a node-side change, tracked upstream:
  * https://github.com/midnightntwrk/midnight-node/issues/1202.
  *
+ * Upgrades. Add operations, never change how existing state is derived or laid
+ * out. A CMA upgrade swaps verifier keys on an instance whose ledger already
+ * holds data so whatever that data was written under has to stay fixed e.g. slot
+ * indices, nonce and key derivation, stored encodings. Slot changes at least
+ * show up in a diff. Key derivation is the quiet one. `_encryptionKeys` holds
+ * the key `derivePk` returned at `register` time, `register` refuses a second
+ * key for an account id, and the id does not move (untagged by design, see
+ * `Utils.computeAccountId`), so a circuit deriving a different key leaves
+ * `assertDecryptsTo` and `_assertOwnsEncryptionKey` rejecting the stored one
+ * with no way to re-register. This means balances, pending balances, escrow and
+ * memos are all permanently unreachable. An instance's derivation is fixed when
+ * it is deployed, so off-chain code mirroring `derivePk` must use that one for
+ * the life of the instance. Adopting a newer derivation cannot recover an
+ * instance whose keys were stored under the old one. A changed derivation
+ * applies to fresh deployments only.
+ *
  * Residual griefing. The dual-balance split (see `sweep`) stops dust
  * credits from churning a victim's spendable ciphertext, but every `_credit`
  * still appends a memo, and only the recipient can `clearMemos`. An attacker

package/token/FungibleToken.compact

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

package/token/MultiToken.compact

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

package/token/NativeShieldedToken.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (token/NativeShieldedToken.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/NativeShieldedToken.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -232,7 +232,7 @@ module NativeShieldedToken {
    * ledger state: it is the contract's holding and is not otherwise
    * recoverable.
    *
-   * @constraints k=14, rows=16033
+   * @constraints k=14, rows=10221
    *
    * Requirements:
    *

package/token/NativeShieldedTokenCore.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (token/NativeShieldedTokenCore.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/NativeShieldedTokenCore.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -51,9 +51,10 @@ pragma language_version >= 0.26.0;
  * The ledger accepts a contract-addressed commitment only if the recipient
  * contract's own call claims it as a shielded receive in the same transaction,
  * and no primitive claims a receive on another contract's behalf. So the
- * address arm is accepted only for `kernel.self()`, where `_mint` / `_burn`
- * claim the coin themselves in the same call. The flavors do not expose the
- * arm at all: they take a `ZswapCoinPublicKey` and offer `_mintToSelf` for
+ * address arm is accepted only for `kernel.self()`, which `mintShieldedToken`
+ * and `sendShielded` claim as a receive themselves. A `receiveShielded` on top
+ * emits a duplicate output for the same commitment. The flavors do not expose
+ * the arm at all: they take a `ZswapCoinPublicKey` and offer `_mintToSelf` for
  * contract-held coins.
  *
  * @dev Burn variants
@@ -235,7 +236,7 @@ module NativeShieldedTokenCore {
    * @dev The caller is fully responsible for nonce uniqueness. Reusing a
    * nonce for the same (domain, value, recipient) produces a duplicate
    * commitment, which the protocol rejects. A `right(kernel.self())` recipient
-   * is claimed via `receiveShielded` in this same call, so the consumer SHOULD
+   * is claimed by `mintShieldedToken` in this same call, so the consumer SHOULD
    * persist the returned coin info: it is the contract's holding and is not
    * otherwise recoverable.
    *
@@ -243,7 +244,7 @@ module NativeShieldedTokenCore {
    * recipient; callers SHOULD deliver it out of band. Wallets cannot detect
    * contract-minted coins by scanning the chain.
    *
-   * @constraints k=15, rows=16980
+   * @constraints k=14, rows=11109
    *
    * Requirements:
    *
@@ -269,12 +270,7 @@ module NativeShieldedTokenCore {
     assert(!Utils_isKeyOrAddressZero(recipient), "NativeShieldedToken: invalid recipient");
     assert(recipient.is_left || recipient.right == self, "NativeShieldedToken: recipient contract must be self");
 
-    const coin = mintShieldedToken(disclose(domain), disclose(amount), disclose(nonce), disclose(recipient));
-    if (disclose(!recipient.is_left)) {
-      receiveShielded(coin);
-    }
-
-    return coin;
+    return mintShieldedToken(disclose(domain), disclose(amount), disclose(nonce), disclose(recipient));
   }
 
   /**
@@ -289,14 +285,14 @@ module NativeShieldedTokenCore {
    * @dev The coin is received by the contract and spent in the same
    * transaction, so the spend goes through `sendImmediateShielded` (the
    * transient path). For coins the contract already holds, use
-   * `_burnFromSelf` instead. A `right(kernel.self())` refund is claimed via
-   * `receiveShielded` in this same call.
+   * `_burnFromSelf` instead. A `right(kernel.self())` refund is claimed by
+   * `sendImmediateShielded` in this same call.
    *
    * @notice The returned refund coin info is the only copy available to
    * `refundTo`; callers SHOULD deliver it out of band. Wallets cannot detect
    * contract-sent coins by scanning the chain.
    *
-   * @constraints k=16, rows=53639
+   * @constraints k=16, rows=47764
    *
    * Requirements:
    *
@@ -338,9 +334,6 @@ module NativeShieldedTokenCore {
         disclose(refundTo),
         disclose(sendRes.change.value.value)
       );
-      if (disclose(!refundTo.is_left)) {
-        receiveShielded(refundRes.sent);
-      }
       return some<ShieldedCoinInfo>(refundRes.sent);
     }
     return none<ShieldedCoinInfo>();

package/token/NativeShieldedTokenFamily.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (token/NativeShieldedTokenFamily.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/NativeShieldedTokenFamily.compact)
 
 pragma language_version >= 0.26.0;
 
@@ -230,7 +230,7 @@ module NativeShieldedTokenFamily {
    * ledger state: it is the contract's holding and is not otherwise
    * recoverable.
    *
-   * @constraints k=14, rows=16309
+   * @constraints k=14, rows=10497
    *
    * Requirements:
    *

package/token/NonFungibleToken.compact

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

package/token/examples/ZOwnableNativeShieldedTokenExample.compact

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/examples/ZOwnableNativeShieldedTokenExample.compact)
+
+pragma language_version >= 0.26.0;
+
+/**
+ * @title ZOwnableNativeShieldedTokenExample
+ * @description Deployable reference contract for the
+ * `ZOwnableNativeShieldedToken` preset: a native shielded token that only a
+ * single shielded owner mints and burns. Holders transfer coins through
+ * Zswap directly.
+ */
+
+import CompactStandardLibrary;
+
+import "../presets/ZOwnableNativeShieldedToken" prefix ZOwnableNativeShieldedToken_;
+
+export { ZswapCoinPublicKey, ContractAddress, Either, Maybe, ShieldedCoinInfo };
+
+// Surface the preset's state unprefixed so `ledger()` readers use the keys the
+// modules declare.
+import {
+  _ownerCommitment,
+  _counter,
+  _instanceSalt,
+  _ownableIsInitialized,
+  _domain,
+  _name,
+  _symbol,
+  _decimals,
+  _isInitialized,
+  _totalMinted,
+  _totalBurned,
+} from "../presets/ZOwnableNativeShieldedToken";
+export {
+  _ownerCommitment,
+  _counter,
+  _instanceSalt,
+  _ownableIsInitialized,
+  _domain,
+  _name,
+  _symbol,
+  _decimals,
+  _isInitialized,
+  _totalMinted,
+  _totalBurned,
+};
+
+/**
+ * @description Deploys the token with its owner, domain and metadata.
+ *
+ * @warning `ownerId` must be `_computeOwnerId(pk, secretNonce)` for the coin
+ * public key the owner's wallet will supply as `ownPublicKey()`. The circuit
+ * cannot check this at deploy; any other key leaves the contract with no
+ * usable owner and no recovery.
+ *
+ * @param {Bytes<32>} ownerId - `_computeOwnerId(pk, secretNonce)` of the owner.
+ * @param {Bytes<32>} instanceSalt - Random per-deployment salt for the owner commitment.
+ * @param {Bytes<32>} tokenDomain - Domain of this contract's token color.
+ */
+constructor(
+  ownerId: Bytes<32>,
+  instanceSalt: Bytes<32>,
+  tokenDomain: Bytes<32>,
+  name_: Opaque<"string">,
+  symbol_: Opaque<"string">,
+  decimals_: Uint<8>,
+) {
+  ZOwnableNativeShieldedToken_initialize(
+    ownerId,
+    instanceSalt,
+    tokenDomain,
+    name_,
+    symbol_,
+    decimals_,
+  );
+}
+
+export circuit mint(recipient: ZswapCoinPublicKey, amount: Uint<64>, nonce: Bytes<32>): ShieldedCoinInfo {
+  return ZOwnableNativeShieldedToken_mint(recipient, amount, nonce);
+}
+
+export circuit burn(coin: ShieldedCoinInfo, amount: Uint<64>, refundTo: ZswapCoinPublicKey): Maybe<ShieldedCoinInfo> {
+  return ZOwnableNativeShieldedToken_burn(coin, amount, refundTo);
+}
+
+export circuit transferOwnership(newOwnerId: Bytes<32>): [] {
+  ZOwnableNativeShieldedToken_transferOwnership(newOwnerId);
+}
+
+export circuit renounceOwnership(): [] {
+  ZOwnableNativeShieldedToken_renounceOwnership();
+}
+
+export circuit owner(): Bytes<32> {
+  return ZOwnableNativeShieldedToken_owner();
+}
+
+export pure circuit _computeOwnerId(pk: Either<ZswapCoinPublicKey, ContractAddress>, nonce: Bytes<32>): Bytes<32> {
+  return ZOwnableNativeShieldedToken__computeOwnerId(pk, nonce);
+}
+
+export circuit totalMinted(): Uint<128> {
+  return ZOwnableNativeShieldedToken_totalMinted();
+}
+
+export circuit tokenColor(): Bytes<32> {
+  return ZOwnableNativeShieldedToken_tokenColor();
+}

package/token/extensions/ConfidentialFungibleTokenPublicSupply.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (token/extensions/ConfidentialFungibleTokenPublicSupply.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/extensions/ConfidentialFungibleTokenPublicSupply.compact)
 
 pragma language_version >= 0.26.0;
 

package/token/extensions/NativeShieldedTokenDerivedNonce.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.4.0-alpha.4 (token/extensions/NativeShieldedTokenDerivedNonce.compact)
+// OpenZeppelin Compact Contracts v0.4.0-alpha.6 (token/extensions/NativeShieldedTokenDerivedNonce.compact)
 
 pragma language_version >= 0.26.0;