@openzeppelin/compact-contracts 0.2.0 → 0.3.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/compact-contracts",
-  "version": "0.2.0",
+  "version": "0.3.0-alpha.1",
   "description": "OpenZeppelin Compact contract library",
   "keywords": [
     "openzeppelin",
@@ -21,20 +21,24 @@
   "homepage": "https://docs.openzeppelin.com/contracts-compact/",
   "type": "module",
   "imports": {
-    "#test-utils/address.js": "./test-utils/address.js"
+    "#test-utils/*": "./test-utils/*"
   },
   "scripts": {
-    "compact": "compact-compiler --exclude '*/archive/*'",
-    "compact:access": "compact-compiler --dir access",
-    "compact:archive": "compact-compiler --dir archive",
-    "compact:security": "compact-compiler --dir security",
-    "compact:token": "compact-compiler --dir token",
-    "compact:utils": "compact-compiler --dir utils",
+    "compile": "compact-compiler --exclude '*/archive/*'",
+    "compile:access": "compact-compiler --dir access",
+    "compile:archive": "compact-compiler --dir archive",
+    "compile:crypto": "compact-compiler --dir crypto",
+    "compile:multisig": "compact-compiler --dir multisig",
+    "compile:security": "compact-compiler --dir security",
+    "compile:token": "compact-compiler --dir token",
+    "compile:utils": "compact-compiler --dir utils",
+    "compile:integration": "SKIP_ZK=true compact-compiler --src test/integration/_mocks",
     "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",
+    "test": "vitest run --project unit",
+    "test:coverage": "vitest run --project unit --coverage",
+    "test:integration": "vitest run --project integration",
+    "test:harness": "vitest run --project harness",
+    "test:harness:live": "MIDNIGHT_BACKEND=live vitest run --project harness-live",
     "types": "tsc -p tsconfig.json --noEmit",
     "clean": "git clean -fXd"
   },
@@ -45,12 +49,24 @@
     "@openzeppelin/compact-cli": "^0.0.2"
   },
   "devDependencies": {
-    "@openzeppelin/compact-simulator": "^0.0.1",
+    "@midnight-ntwrk/compact-js": "2.5.1",
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
+    "@midnight-ntwrk/ledger-v8": "8.1.0",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-network-id": "4.1.1",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-protocol": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1",
+    "@midnight-ntwrk/testkit-js": "4.1.1",
+    "@openzeppelin/compact-simulator": "^0.2.0",
     "@tsconfig/node24": "^24.0.4",
-    "@types/node": "25.9.1",
-    "@vitest/coverage-v8": "^4.1.8",
+    "@types/node": "26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "fast-check": "^4.9.0",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
+    "vitest": "^4.1.10"
   }
 }

package/security/Allowlist.compact

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Compact Contracts v0.3.0-alpha.1 (security/Allowlist.compact)
+
+pragma language_version >= 0.23.0;
+
+/**
+ * @module Allowlist
+ * @description A minimal, reusable permit-list keyed by an abstract `Bytes<32>`
+ * account identifier. It answers a single question: is this account a member?
+ *
+ * This module is a pure membership MECHANISM, not a policy. It holds no notion
+ * of "when" the list is enforced and no access control. The mutators (`_allow`,
+ * `_disallow`) are deliberately UNGATED composable primitives: a composing
+ * contract gates them behind its access-control module (the same way a token
+ * gates `_mint` / `_burn`), and decides when to call `assertAllowed` (for
+ * example, only while an "eligibility required" flag is set). Keeping the
+ * enforce-or-not decision in the composing layer leaves this module general
+ * enough to back KYC allowlists, permissioned mints, membership gates, and the
+ * like.
+ *
+ * @notice This is the PUBLIC (transparent) allowlist: membership status is
+ * publicly readable and the approved set is publicly enumerable. That is the
+ * right posture for transparent or public-graph assets. A graph-private asset
+ * should instead use a shielded allowlist (a public allowlist would re-expose
+ * the candidate set and bound the anonymity set).
+ */
+module Allowlist {
+  import CompactStandardLibrary;
+
+  // ---------------------------------------------------------------------------
+  // State
+  // ---------------------------------------------------------------------------
+
+  /** @description Approved accounts. Absent means not allowed. */
+  export ledger _allowed: Set<Bytes<32>>;
+
+  // ---------------------------------------------------------------------------
+  // Views
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @description Returns whether `account` is currently allowed.
+   *
+   * @circuitInfo k=9, rows=305
+   *
+   * @param {Bytes<32>} account - The account to query.
+   * @return {Boolean} - True if `account` is a member of the allowlist.
+   */
+  export circuit isAllowed(account: Bytes<32>): Boolean {
+    return _allowed.member(disclose(account));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Check (the eligibility seam)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @description Asserts that `account` is allowed. The composing contract
+   * decides when this gate applies.
+   *
+   * @circuitInfo k=9, rows=305
+   *
+   * Requirements:
+   *
+   * - `account` is a member of the allowlist.
+   *
+   * @param {Bytes<32>} account - The account that must be allowed.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertAllowed(account: Bytes<32>): [] {
+    assert(isAllowed(account), "Allowlist: account not allowed");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mutators (UNGATED - the composing contract is responsible for gating these)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @description Adds `account` to the allowlist.
+   *
+   * @circuitInfo k=9, rows=303
+   *
+   * @param {Bytes<32>} account - The account to allow.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _allow(account: Bytes<32>): [] {
+    _allowed.insert(disclose(account));
+  }
+
+  /**
+   * @description Removes `account` from the allowlist.
+   *
+   * @circuitInfo k=9, rows=303
+   *
+   * @param {Bytes<32>} account - The account to disallow.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _disallow(account: Bytes<32>): [] {
+    _allowed.remove(disclose(account));
+  }
+}

package/security/Blocklist.compact

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Compact Contracts v0.3.0-alpha.1 (security/Blocklist.compact)
+
+pragma language_version >= 0.23.0;
+
+/**
+ * @module Blocklist
+ * @description A minimal, reusable deny-list keyed by an abstract `Bytes<32>`
+ * account identifier. It answers a single question: is this account blocked?
+ *
+ * This module is a pure membership MECHANISM, not a policy. It holds no notion
+ * of "when" the list is enforced and no access control. The mutators (`_block`,
+ * `_unblock`) are deliberately UNGATED composable primitives: a composing
+ * contract gates them behind its access-control module (the same way a token
+ * gates `_mint` / `_burn`), and decides when to call `assertNotBlocked`. Keeping
+ * the enforce-or-not decision in the composing layer leaves this module general
+ * enough to back sanctions lists, account freezes, abuse denials, and the like.
+ *
+ * @notice This is the PUBLIC (transparent) blocklist: membership status is
+ * publicly readable and the blocked set is publicly enumerable. That is the
+ * right posture for transparent or public-graph assets. A graph-private asset
+ * should instead use a shielded blocklist (a public blocklist would re-expose
+ * the candidate set and bound the anonymity set).
+ */
+module Blocklist {
+  import CompactStandardLibrary;
+
+  // ---------------------------------------------------------------------------
+  // State
+  // ---------------------------------------------------------------------------
+
+  /** @description Blocked accounts. Absent means not blocked. */
+  export ledger _blocked: Set<Bytes<32>>;
+
+  // ---------------------------------------------------------------------------
+  // Views
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @description Returns whether `account` is currently blocked.
+   *
+   * @circuitInfo k=9, rows=305
+   *
+   * @param {Bytes<32>} account - The account to query.
+   * @return {Boolean} - True if `account` is a member of the blocklist.
+   */
+  export circuit isBlocked(account: Bytes<32>): Boolean {
+    return _blocked.member(disclose(account));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Check (the eligibility seam)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @description Asserts that `account` is not blocked. The composing contract
+   * decides when this gate applies.
+   *
+   * @circuitInfo k=9, rows=308
+   *
+   * Requirements:
+   *
+   * - `account` is not a member of the blocklist.
+   *
+   * @param {Bytes<32>} account - The account that must not be blocked.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertNotBlocked(account: Bytes<32>): [] {
+    assert(!isBlocked(account), "Blocklist: account blocked");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mutators (UNGATED - the composing contract is responsible for gating these)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @description Adds `account` to the blocklist.
+   *
+   * @circuitInfo k=9, rows=303
+   *
+   * @param {Bytes<32>} account - The account to block.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _block(account: Bytes<32>): [] {
+    _blocked.insert(disclose(account));
+  }
+
+  /**
+   * @description Removes `account` from the blocklist.
+   *
+   * @circuitInfo k=9, rows=303
+   *
+   * @param {Bytes<32>} account - The account to unblock.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _unblock(account: Bytes<32>): [] {
+    _blocked.remove(disclose(account));
+  }
+}

package/security/Initializable.compact

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.2.0 (security/Initializable.compact)
+// OpenZeppelin Compact Contracts v0.3.0-alpha.1 (security/Initializable.compact)
 
-pragma language_version >= 0.21.0;
+pragma language_version >= 0.23.0;
 
 /**
  * @module Initializable

package/security/Pausable.compact

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Compact Contracts v0.2.0 (security/Pausable.compact)
+// OpenZeppelin Compact Contracts v0.3.0-alpha.1 (security/Pausable.compact)
 
-pragma language_version >= 0.21.0;
+pragma language_version >= 0.23.0;
 
 /**
  * @module Pausable