@openzeppelin/compact-contracts 0.1.0 → 0.2.0

package/README.md

@@ -199,7 +199,6 @@ make sure to check out the [contribution guide](CONTRIBUTING.md) in advance.
 >
 > - [Node.js](https://nodejs.org/)
 > - [Yarn](https://yarnpkg.com/getting-started/install)
-> - [Turbo](https://turborepo.com/docs/getting-started/installation)
 > - [Compact](https://docs.midnight.network/blog/compact-developer-tools)
 
 ### Set up the project
@@ -215,20 +214,20 @@ git clone git@github.com:OpenZeppelin/compact-contracts.git
 ```bash
 nvm install && \
 yarn && \
-turbo compact
+yarn compact
 ```
 
 ### Run tests
 
 ```bash
-turbo test
+yarn test
 ```
 
 ### Check/apply Biome formatter
 
 ```bash
-turbo fmt-and-lint
-turbo fmt-and-lint:fix
+yarn fmt-and-lint
+yarn fmt-and-lint:fix
 ```
 
 ### Advanced
@@ -236,8 +235,8 @@ turbo fmt-and-lint:fix
 #### Targeted compilation
 
 ```bash
-turbo compact:access
-turbo compact:archive
+yarn compact:access
+yarn compact:archive
 ...
 ```
 
@@ -246,11 +245,11 @@ turbo compact:archive
 ZK key generation is slow and usually unnecessary during development.
 
 ```bash
-# Individual module compilation (recommended for development)
-turbo compact:token  --filter=@openzeppelin/compact-contracts -- --skip-zk
-
 # Full compilation with skip-zk (use environment variable)
-SKIP_ZK=true turbo compact
+SKIP_ZK=true yarn compact
+
+# Access compilation with skip-zk (this compiles security first as a dependency)
+SKIP_ZK=true yarn compact:access
 ```
 
 #### Clean environment
@@ -258,13 +257,13 @@ SKIP_ZK=true turbo compact
 ```bash
 # WARNING!
 # These are destructive commands
-turbo clean
+yarn clean
 rm -rf .turbo/
 ```
 
 ### Troubleshooting
 
-- **Issues with turbo's cache?** Try cleaning: `turbo clean && rm -rf .turbo/`
+- **Issues with turbo's cache?** Try cleaning: `yarn clean && rm -rf .turbo/`
 - **Node version issues?** Use `nvm use` to switch to the correct version
 
 ## Security

package/access/AccessControl.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (access/AccessControl.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (access/AccessControl.compact)
 
 pragma language_version >= 0.21.0;
 

package/access/Ownable.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (access/Ownable.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (access/Ownable.compact)
 
 pragma language_version >= 0.21.0;
 
@@ -85,9 +85,15 @@ pragma language_version >= 0.21.0;
  */
 module Ownable {
   import CompactStandardLibrary;
-  import "../security/Initializable" prefix Initializable_;
   import "../utils/Utils" prefix Utils_;
 
+  /**
+   * @description Initialization flag, tracked per-module to avoid the compiler's
+   * shared transitive-dependency state bug (LFDT-Minokawa/compact#270). See the
+   * Initializable module for rationale.
+   */
+  export ledger _isInitialized: Boolean;
+
   export ledger _owner: Either<Bytes<32>, ContractAddress>;
 
   /**
@@ -117,11 +123,38 @@ module Ownable {
    * @returns {[]} Empty tuple.
    */
   export circuit initialize(initialOwner: Either<Bytes<32>, ContractAddress>): [] {
-    Initializable_initialize();
+    assertNotInitialized();
+    _isInitialized = true;
     assert(!_isTargetZero(initialOwner), "Ownable: invalid initial owner");
     _transferOwnership(initialOwner);
   }
 
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertInitialized(): [] {
+    assert(_isInitialized, "Ownable: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "Ownable: contract already initialized");
+  }
+
   /**
    * @description Returns the current contract owner.
    *
@@ -134,7 +167,7 @@ module Ownable {
    * @returns {Either<Bytes<32>, ContractAddress>} - The contract owner.
    */
   export circuit owner(): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _owner;
   }
 
@@ -158,7 +191,7 @@ module Ownable {
    * @returns {[]} Empty tuple.
    */
   export circuit transferOwnership(newOwner: Either<Bytes<32>, ContractAddress>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !newOwner.is_left;
     assert(!isContractAddr, "Ownable: unsafe ownership transfer");
     _unsafeTransferOwnership(newOwner);
@@ -184,7 +217,7 @@ module Ownable {
    * @returns {[]} Empty tuple.
    */
   export circuit _unsafeTransferOwnership(newOwner: Either<Bytes<32>, ContractAddress>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assertOnlyOwner();
     assert(!_isTargetZero(newOwner), "Ownable: invalid new owner");
     _unsafeUncheckedTransferOwnership(newOwner);
@@ -205,7 +238,7 @@ module Ownable {
    * @returns {[]} Empty tuple.
    */
   export circuit renounceOwnership(): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assertOnlyOwner();
 
     // We use `left` here because `assertOnlyOwner` would return a misleading
@@ -233,7 +266,7 @@ module Ownable {
    * @returns {[]} Empty tuple.
    */
   export circuit assertOnlyOwner(): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     if (_owner.is_left) {
       assert(_computeAccountId() == _owner.left, "Ownable: caller is not the owner");
     } else {
@@ -260,7 +293,7 @@ module Ownable {
    * @returns {[]} Empty tuple.
    */
   export circuit _transferOwnership(newOwner: Either<Bytes<32>, ContractAddress>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !newOwner.is_left;
     assert(!isContractAddr, "Ownable: unsafe ownership transfer");
     _unsafeUncheckedTransferOwnership(newOwner);
@@ -286,7 +319,7 @@ module Ownable {
   export circuit _unsafeUncheckedTransferOwnership(
                    newOwner: Either<Bytes<32>, ContractAddress>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonAcct = Utils_canonicalize<Bytes<32>, ContractAddress>(newOwner);
     _owner = disclose(canonAcct);
   }

package/access/ShieldedAccessControl.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (access/ShieldedAccessControl.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (access/ShieldedAccessControl.compact)
 
 pragma language_version >= 0.21.0;
 
@@ -168,7 +168,6 @@ pragma language_version >= 0.21.0;
 module ShieldedAccessControl {
   import CompactStandardLibrary;
   import "../utils/Utils" prefix Utils_;
-  import "../security/Initializable" prefix Initializable_;
 
   export enum UpdateType {
     Grant,
@@ -181,6 +180,13 @@ module ShieldedAccessControl {
   export new type AccountIdentifier = Bytes<32>;
   export new type RoleNullifier = Bytes<32>;
 
+  /**
+   * @description Initialization flag, tracked per-module to avoid the compiler's
+   * shared transitive-dependency state bug (LFDT-Minokawa/compact#270). See the
+   * Initializable module for rationale.
+   */
+  export ledger _isInitialized: Boolean;
+
   /**
    * @ledger _operatorRoles
    * @description A Merkle tree of role commitments stored as SHA256(role | accountId | instanceSalt | commitmentDomain)
@@ -259,11 +265,38 @@ module ShieldedAccessControl {
    */
   export circuit initialize(instanceSalt: Bytes<32>): [] {
     assert(instanceSalt != default<Bytes<32>>, "ShieldedAccessControl: Instance salt must not be 0");
-    Initializable_initialize();
+    assertNotInitialized();
+    _isInitialized = true;
 
     _instanceSalt = disclose(instanceSalt);
   }
 
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertInitialized(): [] {
+    assert(_isInitialized, "ShieldedAccessControl: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "ShieldedAccessControl: contract already initialized");
+  }
+
   /**
    * @description The default admin role for all roles. Only accounts with this role will be able to grant or revoke other roles
    * unless custom admin roles are created.
@@ -295,7 +328,7 @@ module ShieldedAccessControl {
    * @return {[]} - Empty tuple.
    */
   export circuit assertOnlyRole(role: RoleIdentifier): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(_uncheckedCanProveRole(role), "ShieldedAccessControl: unauthorized account");
   }
 
@@ -320,7 +353,7 @@ module ShieldedAccessControl {
    * @return {Boolean} - A boolean determining if a caller successfully proved ownership of `role`
    */
   export circuit canProveRole(role: RoleIdentifier): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _uncheckedCanProveRole(role);
   }
 
@@ -417,7 +450,7 @@ module ShieldedAccessControl {
    * @return {[]} - Empty tuple.
    */
   export circuit _grantRole(role: RoleIdentifier, accountId: AccountIdentifier): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     _updateRole(role, accountId, UpdateType.Grant);
   }
 
@@ -449,7 +482,7 @@ module ShieldedAccessControl {
    * @return {[]} - Empty tuple.
    */
   export circuit renounceRole(role: RoleIdentifier, accountIdConfirmation: AccountIdentifier): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     assert(accountIdConfirmation == _computeAccountId(),
            "ShieldedAccessControl: bad confirmation"
@@ -515,7 +548,7 @@ module ShieldedAccessControl {
    * @return {[]} - Empty tuple.
    */
   export circuit _revokeRole(role: RoleIdentifier, accountId: AccountIdentifier): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     _updateRole(role, accountId, UpdateType.Revoke);
   }
 
@@ -599,7 +632,7 @@ module ShieldedAccessControl {
    * @return {[]} - Empty tuple.
    */
   export circuit _setRoleAdmin(role: RoleIdentifier, adminId: RoleIdentifier): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     _adminRoles.insert(disclose(role), disclose(adminId));
   }
 

package/access/ZOwnablePK.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (access/ZOwnablePK.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (access/ZOwnablePK.compact)
 
 pragma language_version >= 0.21.0;
 
@@ -45,7 +45,13 @@ pragma language_version >= 0.21.0;
  */
 module ZOwnablePK {
   import CompactStandardLibrary;
-  import "../security/Initializable" prefix Initializable_;
+
+  /**
+   * @description Initialization flag, tracked per-module to avoid the compiler's
+   * shared transitive-dependency state bug (LFDT-Minokawa/compact#270). See the
+   * Initializable module for rationale.
+   */
+  export ledger _isInitialized: Boolean;
 
   /**
    * @ledger _ownerCommitment
@@ -56,6 +62,7 @@ module ZOwnablePK {
    * A commitment of `default<Bytes<32>>` (i.e., zero) indicates the contract is unowned.
    */
   export ledger _ownerCommitment: Bytes<32>;
+
   /**
    * @ledger _counter
    * @description Internal transfer counter used to prevent commitment reuse.
@@ -64,6 +71,7 @@ module ZOwnablePK {
    * `instanceSalt` to compute unique owner commitments over time.
    */
   export ledger _counter: Counter;
+
   /**
    * @sealed @ledger _instanceSalt
    * @description A per-instance value provided at initialization used to namespace
@@ -104,13 +112,40 @@ module ZOwnablePK {
    * @returns {[]} Empty tuple.
    */
   export circuit initialize(ownerId: Bytes<32>, instanceSalt: Bytes<32>): [] {
-    Initializable_initialize();
+    assertNotInitialized();
+    _isInitialized = true;
 
     assert(ownerId != default<Bytes<32>>, "ZOwnablePK: invalid id");
     _instanceSalt = disclose(instanceSalt);
     _transferOwnership(ownerId);
   }
 
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertInitialized(): [] {
+    assert(_isInitialized, "ZOwnablePK: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "ZOwnablePK: contract already initialized");
+  }
+
   /**
    * @description Returns the current commitment representing the contract owner.
    * The full commitment is: `SHA256(SHA256(pk, nonce), instanceSalt, counter, domain)`.
@@ -124,7 +159,7 @@ module ZOwnablePK {
    * @returns {Bytes<32>} The current owner's commitment.
    */
   export circuit owner(): Bytes<32> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _ownerCommitment;
   }
 
@@ -144,7 +179,7 @@ module ZOwnablePK {
    * @returns {[]} Empty tuple.
    */
   export circuit transferOwnership(newOwnerId: Bytes<32>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     assertOnlyOwner();
     assert(newOwnerId != default<Bytes<32>>, "ZOwnablePK: invalid id");
@@ -166,7 +201,7 @@ module ZOwnablePK {
    * @returns {[]} Empty tuple.
    */
   export circuit renounceOwnership(): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     assertOnlyOwner();
     _ownerCommitment.resetToDefault();
@@ -188,7 +223,7 @@ module ZOwnablePK {
    * @returns {[]} Empty tuple.
    */
   export circuit assertOnlyOwner(): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     const nonce = wit_secretNonce();
     const callerAsEither =
@@ -234,7 +269,7 @@ module ZOwnablePK {
    * @returns {Bytes<32>} The commitment derived from `id` and `counter`.
    */
   export circuit _computeOwnerCommitment(id: Bytes<32>, counter: Uint<64>,): Bytes<32> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return persistentHash<Vector<4, Bytes<32>>>(
              [id, _instanceSalt, counter as Field as Bytes<32>, pad(32, "ZOwnablePK:shield:")]
              );
@@ -296,7 +331,7 @@ module ZOwnablePK {
    * @returns {[]} Empty tuple.
    */
   export circuit _transferOwnership(newOwnerId: Bytes<32>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     _counter.increment(1);
     _ownerCommitment = disclose(_computeOwnerCommitment(newOwnerId, _counter));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/compact-contracts",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenZeppelin Compact contract library",
   "keywords": [
     "openzeppelin",
@@ -33,6 +33,8 @@
     "build": "compact-builder --hierarchical --out dist --clean-dist --exclude '*/archive/*' --exclude 'Mock*' --exclude '*.mock.compact' --copy package.json --copy ../README.md && find dist -type d -empty -delete",
     "test": "SKIP_ZK=true yarn run compact && vitest run",
     "test:coverage": "SKIP_ZK=true yarn run compact && vitest run --coverage",
+    "compact:integration": "SKIP_ZK=true compact compile test/integration/_mocks/SharedInitCollision.compact artifacts/SharedInitCollision && SKIP_ZK=true compact compile test/integration/_mocks/ComposedTokens.compact artifacts/ComposedTokens",
+    "test:integration": "yarn run compact:integration && vitest run --config vitest.integration.config.ts",
     "types": "tsc -p tsconfig.json --noEmit",
     "clean": "git clean -fXd"
   },
@@ -45,10 +47,10 @@
   "devDependencies": {
     "@openzeppelin/compact-simulator": "^0.0.1",
     "@tsconfig/node24": "^24.0.4",
-    "@types/node": "25.7.0",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "^4.1.8",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.7"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
   }
 }

package/security/Initializable.compact

@@ -1,11 +1,27 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (security/Initializable.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (security/Initializable.compact)
 
 pragma language_version >= 0.21.0;
 
 /**
  * @module Initializable
  * @description Initializable provides a simple mechanism that mimics the functionality of a constructor.
+ *
+ * @notice ⚠️ TECHNICAL WARNING: only use this module at the top contract layer, and
+ * import it into at most one module per contract.
+ *
+ * The Compact compiler deduplicates a shared transitive dependency's ledger state
+ * inconsistently depending on directory layout
+ * (https://github.com/LFDT-Minokawa/compact/issues/270, reproduced on compiler
+ * 0.29.0–0.31.0). When two modules in the SAME directory both import this module,
+ * their `_isInitialized` flags collapse into a SINGLE shared ledger slot: calling
+ * `initialize()` on one marks the other as initialized, and the other can never be
+ * initialized independently. Modules in different directories get separate slots.
+ * The result is unpredictable and a security hazard for composed contracts.
+ *
+ * For this reason the OpenZeppelin modules no longer use this module: each tracks
+ * its own `_isInitialized` ledger flag inline. This module is kept for direct,
+ * single-import use and can be reintroduced across modules once #270 is resolved.
  */
 module Initializable {
   import CompactStandardLibrary;

package/security/Pausable.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (security/Pausable.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (security/Pausable.compact)
 
 pragma language_version >= 0.21.0;
 

package/token/FungibleToken.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (token/FungibleToken.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (token/FungibleToken.compact)
 
 pragma language_version >= 0.21.0;
 
@@ -64,9 +64,15 @@ pragma language_version >= 0.21.0;
  */
 module FungibleToken {
   import CompactStandardLibrary;
-  import "../security/Initializable" prefix Initializable_;
   import "../utils/Utils" prefix Utils_;
 
+  /**
+   * @description Initialization flag, tracked per-module to avoid the compiler's
+   * shared transitive-dependency state bug (LFDT-Minokawa/compact#270). See the
+   * Initializable module for rationale.
+   */
+  export ledger _isInitialized: Boolean;
+
   /**
    * @description Mapping from account addresses to their token balances.
    * @type {Either<Bytes<32>, ContractAddress>} account - The account address.
@@ -75,6 +81,7 @@ module FungibleToken {
    * @type {Map<Either<Bytes<32>, ContractAddress>, Uint<128>>} _balances
    */
   export ledger _balances: Map<Either<Bytes<32>, ContractAddress>, Uint<128>>;
+
   /**
    * @description Mapping from owner accounts to spender accounts and their allowances.
    * @type {Either<Bytes<32>, ContractAddress>} account - The owner account address.
@@ -134,12 +141,39 @@ module FungibleToken {
                    symbol_: Opaque<"string">,
                    decimals_: Uint<8>
                    ): [] {
-    Initializable_initialize();
+    assertNotInitialized();
+    _isInitialized = true;
     _name = disclose(name_);
     _symbol = disclose(symbol_);
     _decimals = disclose(decimals_);
   }
 
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertInitialized(): [] {
+    assert(_isInitialized, "FungibleToken: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "FungibleToken: contract already initialized");
+  }
+
   /**
    * @description Returns the token name.
    *
@@ -152,7 +186,7 @@ module FungibleToken {
    * @return {Opaque<"string">} - The token name.
    */
   export circuit name(): Opaque<"string"> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _name;
   }
 
@@ -168,7 +202,7 @@ module FungibleToken {
    * @return {Opaque<"string">} - The token name.
    */
   export circuit symbol(): Opaque<"string"> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _symbol;
   }
 
@@ -184,7 +218,7 @@ module FungibleToken {
    * @return {Uint<8>} - The account's token balance.
    */
   export circuit decimals(): Uint<8> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _decimals;
   }
 
@@ -200,7 +234,7 @@ module FungibleToken {
    * @return {Uint<128>} - The total supply of tokens.
    */
   export circuit totalSupply(): Uint<128> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _totalSupply;
   }
 
@@ -219,7 +253,7 @@ module FungibleToken {
    * @return {Uint<128>} - The account's token balance.
    */
   export circuit balanceOf(account: Either<Bytes<32>, ContractAddress>): Uint<128> {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonAcct = Utils_canonicalize<Bytes<32>, ContractAddress>(account);
 
     if (!_balances.member(disclose(canonAcct))) {
@@ -253,7 +287,7 @@ module FungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !to.is_left;
     assert(!isContractAddr, "FungibleToken: unsafe transfer");
 
@@ -283,7 +317,7 @@ module FungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     const owner = left<Bytes<32>, ContractAddress>(_computeAccountId());
     _unsafeUncheckedTransfer(owner, to, value);
     return true;
@@ -309,7 +343,7 @@ module FungibleToken {
                    owner: Either<Bytes<32>, ContractAddress>,
                    spender: Either<Bytes<32>, ContractAddress>
                    ): Uint<128> {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     const canonSpender = Utils_canonicalize<Bytes<32>, ContractAddress>(spender);
 
@@ -337,7 +371,7 @@ module FungibleToken {
   export circuit approve(spender: Either<Bytes<32>, ContractAddress>,
                          value: Uint<128>
                          ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     const owner = left<Bytes<32>, ContractAddress>(_computeAccountId());
     _approve(owner, spender, value);
@@ -373,7 +407,7 @@ module FungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !to.is_left;
     assert(!isContractAddr, "FungibleToken: unsafe transfer");
     return _unsafeTransferFrom(fromAddress, to, value);
@@ -406,7 +440,7 @@ module FungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     const spender = left<Bytes<32>, ContractAddress>(_computeAccountId());
     _spendAllowance(fromAddress, spender, value);
@@ -443,7 +477,7 @@ module FungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !to.is_left;
     assert(!isContractAddr, "FungibleToken: unsafe transfer");
     _unsafeUncheckedTransfer(fromAddress, to, value);
@@ -474,7 +508,7 @@ module FungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(fromAddress), "FungibleToken: invalid sender");
     assert(!_isTargetZero(to), "FungibleToken: invalid receiver");
 
@@ -501,7 +535,7 @@ module FungibleToken {
                   to: Either<Bytes<32>, ContractAddress>,
                   value: Uint<128>
                   ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonFrom = Utils_canonicalize<Bytes<32>, ContractAddress>(fromAddress);
     const canonTo = Utils_canonicalize<Bytes<32>, ContractAddress>(to);
 
@@ -547,7 +581,7 @@ module FungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit _mint(account: Either<Bytes<32>, ContractAddress>, value: Uint<128>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !account.is_left;
     assert(!isContractAddr, "FungibleToken: unsafe transfer");
     _unsafeMint(account, value);
@@ -575,7 +609,7 @@ module FungibleToken {
                    account: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(account), "FungibleToken: invalid receiver");
     _update(ZERO(), account, value);
   }
@@ -597,7 +631,7 @@ module FungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit _burn(account: Either<Bytes<32>, ContractAddress>, value: Uint<128>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(account), "FungibleToken: invalid sender");
     _update(account, ZERO(), value);
   }
@@ -625,7 +659,7 @@ module FungibleToken {
                    spender: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     const canonSpender = Utils_canonicalize<Bytes<32>, ContractAddress>(spender);
 
@@ -663,7 +697,7 @@ module FungibleToken {
                    spender: Either<Bytes<32>, ContractAddress>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     const canonSpender = Utils_canonicalize<Bytes<32>, ContractAddress>(spender);
 

package/token/MultiToken.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (token/MultiToken.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (token/MultiToken.compact)
 
 pragma language_version >= 0.21.0;
 
@@ -124,9 +124,15 @@ pragma language_version >= 0.21.0;
  */
 module MultiToken {
   import CompactStandardLibrary;
-  import "../security/Initializable" prefix Initializable_;
   import "../utils/Utils" prefix Utils_;
 
+  /**
+   * @description Initialization flag, tracked per-module to avoid the compiler's
+   * shared transitive-dependency state bug (LFDT-Minokawa/compact#270). See the
+   * Initializable module for rationale.
+   */
+  export ledger _isInitialized: Boolean;
+
   /**
    * @description Mapping from token ID to account balances.
    * @type {Uint<128>} id - The token identifier.
@@ -199,10 +205,37 @@ module MultiToken {
    * @return {[]} - Empty tuple.
    */
   export circuit initialize(uri_: Opaque<"string">): [] {
-    Initializable_initialize();
+    assertNotInitialized();
+    _isInitialized = true;
     _setURI(uri_);
   }
 
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertInitialized(): [] {
+    assert(_isInitialized, "MultiToken: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "MultiToken: contract already initialized");
+  }
+
   /**
    * @description This implementation returns the same URI for *all* token types. It relies
    * on the token type ID substitution mechanism defined in the EIP:
@@ -220,7 +253,7 @@ module MultiToken {
    * @return {Opaque<"string">} - The base URI for all tokens.
    */
   export circuit uri(id: Uint<128>): Opaque<"string"> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _uri;
   }
 
@@ -241,7 +274,7 @@ module MultiToken {
                    account: Either<Bytes<32>, ContractAddress>,
                    id: Uint<128>
                    ): Uint<128> {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonAcct = Utils_canonicalize<Bytes<32>, ContractAddress>(account);
 
     if (!_balances.member(disclose(id)) || !_balances.lookup(id).member(disclose(canonAcct))) {
@@ -273,7 +306,7 @@ module MultiToken {
                    operator: Either<Bytes<32>, ContractAddress>,
                    approved: Boolean
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const caller = left<Bytes<32>, ContractAddress>(_computeAccountId());
     _setApprovalForAll(caller, operator, approved);
   }
@@ -295,7 +328,7 @@ module MultiToken {
                    account: Either<Bytes<32>, ContractAddress>,
                    operator: Either<Bytes<32>, ContractAddress>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonAcct = Utils_canonicalize<Bytes<32>, ContractAddress>(account);
     const canonOp = Utils_canonicalize<Bytes<32>, ContractAddress>(operator);
 
@@ -404,7 +437,7 @@ module MultiToken {
                   id: Uint<128>,
                   value: Uint<128>
                   ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonFrom = Utils_canonicalize<Bytes<32>, ContractAddress>(fromAddress);
     const canonTo = Utils_canonicalize<Bytes<32>, ContractAddress>(to);
 
@@ -464,7 +497,7 @@ module MultiToken {
                    id: Uint<128>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     const caller = left<Bytes<32>, ContractAddress>(_computeAccountId());
     const canonFrom = Utils_canonicalize<Bytes<32>, ContractAddress>(fromAddress);
@@ -505,7 +538,7 @@ module MultiToken {
                    id: Uint<128>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
 
     assert(!_isTargetZero(fromAddress), "MultiToken: invalid sender");
     assert(!_isTargetZero(to), "MultiToken: invalid receiver");
@@ -536,7 +569,7 @@ module MultiToken {
    * @return {[]} - Empty tuple.
    */
   export circuit _setURI(newURI: Opaque<"string">): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     _uri = disclose(newURI);
   }
 
@@ -593,7 +626,7 @@ module MultiToken {
                    id: Uint<128>,
                    value: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(to), "MultiToken: invalid receiver");
     _update(ZERO(), to, id, value);
   }
@@ -618,7 +651,7 @@ module MultiToken {
                        id: Uint<128>,
                        value: Uint<128>
                        ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(fromAddress), "MultiToken: invalid sender");
     _update(fromAddress, ZERO(), id, value);
   }
@@ -649,7 +682,7 @@ module MultiToken {
                    operator: Either<Bytes<32>, ContractAddress>,
                    approved: Boolean
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     assert(!_isTargetZero(canonOwner), "MultiToken: invalid owner");
 

package/token/NonFungibleToken.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (token/NonFungibleToken.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (token/NonFungibleToken.compact)
 
 pragma language_version >= 0.21.0;
 
@@ -83,13 +83,19 @@ pragma language_version >= 0.21.0;
 
 module NonFungibleToken {
   import CompactStandardLibrary;
-  import "../security/Initializable" prefix Initializable_;
   import "../utils/Utils" prefix Utils_;
 
   /// Public state
   export sealed ledger _name: Opaque<"string">;
   export sealed ledger _symbol: Opaque<"string">;
 
+  /**
+   * @description Initialization flag, tracked per-module to avoid the compiler's
+   * shared transitive-dependency state bug (LFDT-Minokawa/compact#270). See the
+   * Initializable module for rationale.
+   */
+  export ledger _isInitialized: Boolean;
+
   /**
    * @description Mapping from token IDs to their owner addresses.
    * @type {Uint<128>} tokenId - The unique identifier for a token.
@@ -177,11 +183,38 @@ module NonFungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit initialize(name_: Opaque<"string">, symbol_: Opaque<"string">): [] {
-    Initializable_initialize();
+    assertNotInitialized();
+    _isInitialized = true;
     _name = disclose(name_);
     _symbol = disclose(symbol_);
   }
 
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertInitialized(): [] {
+    assert(_isInitialized, "NonFungibleToken: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "NonFungibleToken: contract already initialized");
+  }
+
   /**
    * @description Returns the number of tokens in `owner`'s account.
    *
@@ -195,7 +228,7 @@ module NonFungibleToken {
    * @return {Uint<128>} - The number of tokens in `owner`'s account.
    */
   export circuit balanceOf(owner: Either<Bytes<32>, ContractAddress>): Uint<128> {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
 
     if (!_balances.member(disclose(canonOwner))) {
@@ -219,7 +252,7 @@ module NonFungibleToken {
    * @return {Either<Bytes<32>, ContractAddress>} - The account that owns the token.
    */
   export circuit ownerOf(tokenId: Uint<128>): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _requireOwned(tokenId);
   }
 
@@ -235,7 +268,7 @@ module NonFungibleToken {
    * @return {Opaque<"string">} - The token name.
    */
   export circuit name(): Opaque<"string"> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _name;
   }
 
@@ -251,7 +284,7 @@ module NonFungibleToken {
    * @return {Opaque<"string">} - The token symbol.
    */
   export circuit symbol(): Opaque<"string"> {
-    Initializable_assertInitialized();
+    assertInitialized();
     return _symbol;
   }
 
@@ -275,7 +308,7 @@ module NonFungibleToken {
    * @return {Opaque<"string">} - the token id's URI.
    */
   export circuit tokenURI(tokenId: Uint<128>): Opaque<"string"> {
-    Initializable_assertInitialized();
+    assertInitialized();
     _requireOwned(tokenId);
 
     if (!_tokenURIs.member(disclose(tokenId))) {
@@ -302,7 +335,7 @@ module NonFungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit _setTokenURI(tokenId: Uint<128>, tokenURI: Opaque<"string">): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     _requireOwned(tokenId);
 
     return _tokenURIs.insert(disclose(tokenId), disclose(tokenURI));
@@ -330,7 +363,7 @@ module NonFungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit approve(to: Either<Bytes<32>, ContractAddress>, tokenId: Uint<128>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const auth = left<Bytes<32>, ContractAddress>(_computeAccountId());
     _approve(to, tokenId, auth);
   }
@@ -349,7 +382,7 @@ module NonFungibleToken {
    * @return {Either<Bytes<32>, ContractAddress>} - The account approved to manage the token
    */
   export circuit getApproved(tokenId: Uint<128>): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     _requireOwned(tokenId);
 
     return _getApproved(tokenId);
@@ -377,7 +410,7 @@ module NonFungibleToken {
                    operator: Either<Bytes<32>, ContractAddress>,
                    approved: Boolean
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const owner = left<Bytes<32>, ContractAddress>(_computeAccountId());
     _setApprovalForAll(owner, operator, approved);
   }
@@ -399,7 +432,7 @@ module NonFungibleToken {
                    owner: Either<Bytes<32>, ContractAddress>,
                    operator: Either<Bytes<32>, ContractAddress>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     const canonOp = Utils_canonicalize<Bytes<32>, ContractAddress>(operator);
 
@@ -439,7 +472,7 @@ module NonFungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !to.is_left;
     assert(!isContractAddr, "NonFungibleToken: unsafe transfer");
 
@@ -476,7 +509,7 @@ module NonFungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(to), "NonFungibleToken: invalid receiver");
     // Setting an "auth" argument enables the `_isAuthorized` check which verifies that the token exists
     // (fromAddress != 0). Therefore, it is not needed to verify that the return value is not 0 here.
@@ -500,7 +533,7 @@ module NonFungibleToken {
    * @return {Either<Bytes<32>, ContractAddress>} - The owner of the token
    */
   export circuit _ownerOf(tokenId: Uint<128>): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     if (!_owners.member(disclose(tokenId))) {
       return ZERO();
     }
@@ -521,7 +554,7 @@ module NonFungibleToken {
    * @return {Either<Bytes<32>, ContractAddress>} - An account approved to spend `tokenId`
    */
   export circuit _getApproved(tokenId: Uint<128>): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     if (!_tokenApprovals.member(disclose(tokenId))) {
       return ZERO();
     }
@@ -551,7 +584,7 @@ module NonFungibleToken {
                    spender: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): Boolean {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     const canonSpender = Utils_canonicalize<Bytes<32>, ContractAddress>(spender);
 
@@ -584,7 +617,7 @@ module NonFungibleToken {
                    spender: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     if (!_isAuthorized(owner, spender, tokenId)) {
       assert(!_isTargetZero(owner), "NonFungibleToken: nonexistent token");
       assert(false, "NonFungibleToken: insufficient approval");
@@ -610,7 +643,7 @@ module NonFungibleToken {
                   tokenId: Uint<128>,
                   auth: Either<Bytes<32>, ContractAddress>
                   ): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonTo = Utils_canonicalize<Bytes<32>, ContractAddress>(to);
     const canonAuth = Utils_canonicalize<Bytes<32>, ContractAddress>(auth);
     const fromAddress = _ownerOf(tokenId);
@@ -659,7 +692,7 @@ module NonFungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit _mint(to: Either<Bytes<32>, ContractAddress>, tokenId: Uint<128>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !to.is_left;
     assert(!isContractAddr, "NonFungibleToken: unsafe transfer");
 
@@ -689,7 +722,7 @@ module NonFungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(to), "NonFungibleToken: invalid receiver");
 
     const previousOwner = _update(to, tokenId, ZERO());
@@ -713,7 +746,7 @@ module NonFungibleToken {
    * @return {[]} - Empty tuple.
    */
   export circuit _burn(tokenId: Uint<128>): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const previousOwner = _update(ZERO(), tokenId, ZERO());
     assert(!_isTargetZero(previousOwner), "NonFungibleToken: invalid sender");
     _tokenURIs.remove(disclose(tokenId));
@@ -746,7 +779,7 @@ module NonFungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const isContractAddr = !to.is_left;
     assert(!isContractAddr, "NonFungibleToken: unsafe transfer");
 
@@ -780,7 +813,7 @@ module NonFungibleToken {
                    to: Either<Bytes<32>, ContractAddress>,
                    tokenId: Uint<128>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     assert(!_isTargetZero(to), "NonFungibleToken: invalid receiver");
 
     const previousOwner = _update(to, tokenId, ZERO());
@@ -812,7 +845,7 @@ module NonFungibleToken {
                    tokenId: Uint<128>,
                    auth: Either<Bytes<32>, ContractAddress>
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     // Canonicalize + normalize `to`
     const canonTo = Utils_canonicalize<Bytes<32>, ContractAddress>(to);
     const normalizedTo = _isTargetZero(canonTo) ? ZERO() : canonTo;
@@ -853,7 +886,7 @@ module NonFungibleToken {
                    operator: Either<Bytes<32>, ContractAddress>,
                    approved: Boolean
                    ): [] {
-    Initializable_assertInitialized();
+    assertInitialized();
     const canonOwner = Utils_canonicalize<Bytes<32>, ContractAddress>(owner);
     assert(!_isTargetZero(canonOwner), "NonFungibleToken: invalid owner");
 
@@ -885,7 +918,7 @@ module NonFungibleToken {
    * @return {Either<Bytes<32>, ContractAddress>} - The owner of `tokenId`
    */
   export circuit _requireOwned(tokenId: Uint<128>): Either<Bytes<32>, ContractAddress> {
-    Initializable_assertInitialized();
+    assertInitialized();
     const owner = _ownerOf(tokenId);
 
     assert(!_isTargetZero(owner), "NonFungibleToken: nonexistent token");

package/utils/Utils.compact

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.1.0 (utils/Utils.compact)
+// OpenZeppelin Compact Contracts v0.2.0 (utils/Utils.compact)
 
 pragma language_version >= 0.21.0;