@buenos_andres/contracts 0.0.1-test.1

package/dist/access/AccessControl.compact

@@ -0,0 +1,321 @@
+// SPDX-License-Identifier: MIT
+
+pragma language_version >= 0.16.0;
+
+/**
+ * @module AccessControl
+ * @description An unshielded AccessControl library.
+ * This module provides a role-based access control mechanism, where roles can be used to
+ * represent a set of permissions.
+ *
+ * Roles are referred to by their `Bytes<32>` identifier. These should be exposed
+ * in the top-level contract and be unique. One way to achieve this is by
+ * using `export sealed ledger` hash digests that are initialized in the top-level contract:
+ *
+ * ```typescript
+ * import CompactStandardLibrary;
+ * import "./node_modules/@daddy-compact/accessControl/src/AccessControl" prefix AccessControl_;
+ *
+ * export sealed ledger MY_ROLE: Bytes<32>;
+ *
+ * constructor() {
+ *  MY_ROLE = persistentHash<Bytes<32>>(pad(32, "MY_ROLE"));
+ * }
+ * ```
+ *
+ * To restrict access to a circuit, use {assertOnlyRole}:
+ *
+ * ```typescript
+ * circuit foo(): [] {
+ *  assertOnlyRole(MY_ROLE);
+ *  ...
+ * }
+ * ```
+ *
+ * Roles can be granted and revoked dynamically via the {grantRole} and
+ * {revokeRole} circuits. Each role has an associated admin role, and only
+ * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
+ *
+ * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
+ * that only accounts with this role will be able to grant or revoke other
+ * roles. More complex role relationships can be created by using
+ * {_setRoleAdmin}. To set a custom `DEFAULT_ADMIN_ROLE`, implement the `Initializable`
+ * module and set `DEFAULT_ADMIN_ROLE` in the `initialize()` circuit.
+ *
+ * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
+ * grant and revoke this role. Extra precautions should be taken to secure
+ * accounts that have been granted it.
+ *
+ * @notice Roles can only be granted to ZswapCoinPublicKeys
+ * through the main role approval circuits (`grantRole` and `_grantRole`).
+ * In other words, role approvals to contract addresses are disallowed through these
+ * circuits.
+ * This is because Compact currently does not support contract-to-contract calls which means
+ * if a contract is granted a role, the contract cannot directly call the protected
+ * circuit.
+ *
+ * @notice This module does offer an experimental circuit that allows roles to be granted
+ * to contract addresses (`_unsafeGrantRole`).
+ * Note that the circuit name is very explicit ("unsafe") with this experimental circuit.
+ * Until contract-to-contract calls are supported,
+ * there is no direct way for a contract to call protected circuits.
+ *
+ * @notice The unsafe circuits are planned to become deprecated once contract-to-contract calls
+ * are supported.
+ *
+ * @notice Missing Features and Improvements:
+ *
+ * - Role events
+ * - An ERC165-like interface
+ */
+module AccessControl {
+  import CompactStandardLibrary;
+  import "../utils/Utils" prefix Utils_;
+
+  /**
+   * @description Mapping from a role identifier -> account -> its permissions.
+   * @type {Bytes<32>} roleId - A hash representing a role identifier.
+   * @type {Map<Either<ZswapCoinPublicKey, ContractAddress>, Boolean>} hasRole - A mapping from an account to a
+   * Boolean determining if the account is approved for a role.
+   * @type {Map<roleId, hasRole>}
+   * @type {Map<Bytes<32>, Map<Either<ZswapCoinPublicKey, ContractAddress>, Boolean>} _operatorRoles
+   */
+  export ledger _operatorRoles: Map<Bytes<32>, Map<Either<ZswapCoinPublicKey, ContractAddress>, Boolean>>;
+
+  /**
+   * @description Mapping from a role identifier to an admin role identifier.
+   * @type {Bytes<32>} roleId - A hash representing a role identifier.
+   * @type {Bytes<32>} adminId - A hash representing an admin identifier.
+   * @type {Map<roleId, adminId>}
+   * @type {Map<Bytes<32>, Bytes<32>>} _adminRoles
+   */
+  export ledger _adminRoles: Map<Bytes<32>, Bytes<32>>;
+
+  export ledger DEFAULT_ADMIN_ROLE: Bytes<32>;
+
+   /**
+    * @description Returns `true` if `account` has been granted `roleId`.
+    *
+    * @circuitInfo k=10, rows=487
+    *
+    * @param {Bytes<32>} roleId - The role identifier.
+    * @param {Either<ZswapCoinPublicKey, ContractAddress>} account - The account to query.
+    * @return {Boolean} - Whether the account has the specified role.
+    */
+  export circuit hasRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): Boolean {
+    if (
+      _operatorRoles.member(disclose(roleId)) &&
+      _operatorRoles
+        .lookup(roleId)
+        .member(disclose(account))
+      ) {
+      return _operatorRoles
+        .lookup(roleId)
+        .lookup(disclose(account));
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * @description Reverts if `ownPublicKey()` is missing `roleId`.
+   *
+   * @circuitInfo k=10, rows=345
+   *
+   * Requirements:
+   *
+   * - The caller must have `roleId`.
+   * - The caller must not be a ContractAddress
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertOnlyRole(roleId: Bytes<32>): [] {
+    _checkRole(roleId, left<ZswapCoinPublicKey,ContractAddress>(ownPublicKey()));
+  }
+
+  /**
+   * @description Reverts if `account` is missing `roleId`.
+   *
+   * @circuitInfo k=10, rows=467
+   *
+   * Requirements:
+   *
+   * - `account` must have `roleId`.
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} account - The account to query.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _checkRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    assert(hasRole(roleId, account), "AccessControl: unauthorized account");
+  }
+
+  /**
+   * @description Returns the admin role that controls `roleId` or
+   * a byte array with all zero bytes if `roleId` doesn't exist. See {grantRole} and {revokeRole}.
+   *
+   * To change a role’s admin use {_setRoleAdmin}.
+   *
+   * @circuitInfo k=10, rows=207
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @return {Bytes<32>} roleAdmin - The admin role that controls `roleId`.
+   */
+  export circuit getRoleAdmin(roleId: Bytes<32>): Bytes<32> {
+    if (_adminRoles.member(disclose(roleId))) {
+      return _adminRoles.lookup(disclose(roleId));
+    }
+    return default<Bytes<32>>;
+  }
+
+  /**
+   * @description Grants `roleId` to `account`.
+   *
+   * @circuitInfo k=10, rows=994
+   *
+   * Requirements:
+   *
+   * - `account` must not be a ContractAddress.
+   * - The caller must have `roleId`'s admin role.
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} account - A ZswapCoinPublicKey or ContractAddress.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit grantRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    assertOnlyRole(getRoleAdmin(roleId));
+    _grantRole(roleId, account);
+  }
+
+  /**
+   * @description Revokes `roleId` from `account`.
+   *
+   * @circuitInfo k=10, rows=827
+   *
+   * Requirements:
+   *
+   * - The caller must have `roleId`'s admin role.
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} account - A ZswapCoinPublicKey or ContractAddress.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit revokeRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    assertOnlyRole(getRoleAdmin(roleId));
+    _revokeRole(roleId, account);
+  }
+
+ /**
+  * @description Revokes `roleId` from the calling account.
+  *
+  * @notice Roles are often managed via {grantRole} and {revokeRole}: this circuit's
+  * purpose is to provide a mechanism for accounts to lose their privileges
+  * if they are compromised (such as when a trusted device is misplaced).
+  *
+  * @circuitInfo k=10, rows=640
+  *
+  * Requirements:
+  *
+  * - The caller must be `callerConfirmation`.
+  * - The caller must not be a `ContractAddress`.
+  *
+  * @param {Bytes<32>} roleId - The role identifier.
+  * @param {Either<ZswapCoinPublicKey, ContractAddress>} callerConfirmation - A ZswapCoinPublicKey or ContractAddress.
+  * @return {[]} - Empty tuple.
+  */
+  export circuit renounceRole(roleId: Bytes<32>, callerConfirmation: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    assert(callerConfirmation == left<ZswapCoinPublicKey,ContractAddress>(ownPublicKey()), "AccessControl: bad confirmation");
+
+    _revokeRole(roleId, callerConfirmation);
+  }
+
+  /**
+   * @description Sets `adminRole` as `roleId`'s admin role.
+   *
+   * @circuitInfo k=10, rows=209
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Bytes<32>} adminRole - The admin role identifier.
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _setRoleAdmin(roleId: Bytes<32>, adminRole: Bytes<32>): [] {
+    _adminRoles.insert(disclose(roleId), disclose(adminRole));
+  }
+
+  /**
+   * @description Attempts to grant `roleId` to `account` and returns a boolean indicating if `roleId` was granted.
+   * Internal circuit without access restriction.
+   *
+   * @circuitInfo k=10, rows=734
+   *
+   * Requirements:
+   *
+   * - `account` must not be a ContractAddress.
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} account - A ZswapCoinPublicKey or ContractAddress.
+   * @return {Boolean} roleGranted - A boolean indicating if `roleId` was granted.
+   */
+  export circuit _grantRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): Boolean {
+    assert(!Utils_isContractAddress(account), "AccessControl: unsafe role approval");
+    return _unsafeGrantRole(roleId, account);
+  }
+
+  /**
+   * @description Attempts to grant `roleId` to `account` and returns a boolean indicating if `roleId` was granted.
+   * Internal circuit without access restriction. It does NOT check if the role is granted to a ContractAddress.
+   *
+   * @circuitInfo k=10, rows=733
+   *
+   * @notice External smart contracts cannot call the token contract at this time, so granting a role to an ContractAddress may
+   * render a circuit permanently inaccessible.
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} account - A ZswapCoinPublicKey or ContractAddress.
+   * @return {Boolean} roleGranted - A boolean indicating if `role` was granted.
+   */
+  export circuit _unsafeGrantRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): Boolean {
+    if (hasRole(roleId, account)) {
+      return false;
+    }
+
+    if (!_operatorRoles.member(disclose(roleId))) {
+      _operatorRoles.insert(
+        disclose(roleId),
+        default<Map<
+          Either<ZswapCoinPublicKey, ContractAddress>,
+          Boolean
+        >>
+      );
+      _operatorRoles
+        .lookup(roleId)
+        .insert(disclose(account), true);
+      return true;
+    }
+
+    _operatorRoles.lookup(roleId).insert(disclose(account), true);
+    return true;
+  }
+
+  /**
+   * @description Attempts to revoke `roleId` from `account` and returns a boolean indicating if `roleId` was revoked.
+   * Internal circuit without access restriction.
+   *
+   * @circuitInfo k=10, rows=563
+   *
+   * @param {Bytes<32>} roleId - The role identifier.
+   * @param {Bytes<32>} adminRole - The admin role identifier.
+   * @return {Boolean} roleRevoked - A boolean indicating if `roleId` was revoked.
+   */
+  export circuit _revokeRole(roleId: Bytes<32>, account: Either<ZswapCoinPublicKey, ContractAddress>): Boolean {
+    if (!hasRole(roleId, account)) {
+      return false;
+    }
+
+    _operatorRoles
+      .lookup(roleId)
+      .insert(disclose(account), false);
+    return true;
+  }
+}

package/dist/access/Ownable.compact

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: MIT
+
+pragma language_version >= 0.16.0;
+
+/**
+ * @module Ownable
+ * @description An unshielded Ownable library.
+ * This modules provides a basic access control mechanism, where there is an owner
+ * that can be granted exclusive access to specific circuits.
+ * This approach is perfectly reasonable for contracts that have a single administrative user.
+ *
+ * The initial owner must be set by using the `initialize` circuit during construction.
+ * This can later be changed with `transferOwnership`.
+ *
+ * @notice Ownership can only be transferred to ZswapCoinPublicKeys
+ * through the main transfer circuits (`transferOwnership` and `_transferOwnership`).
+ * In other words, ownership transfers to contract addresses are disallowed through these
+ * circuits.
+ * This is because Compact currently does not support contract-to-contract calls which means
+ * if a contract is granted ownership, the owner contract cannot directly call the protected
+ * circuit.
+ *
+ * @notice This module does offer experimental circuits that allow ownership to be granted
+ * to contract addresses (`_unsafeTransferOwnership` and `_unsafeUncheckedTransferOwnership`).
+ * Note that the circuit names are very explicit ("unsafe") with these experimental circuits.
+ * Until contract-to-contract calls are supported,
+ * there is no direct way for a contract to call circuits of other contracts
+ * or transfer ownership back to a user.
+ *
+ * @notice The unsafe circuits are planned to become deprecated once contract-to-contract calls
+ * are supported.
+ */
+module Ownable {
+  import CompactStandardLibrary;
+  import "../security/Initializable" prefix Initializable_;
+  import "../utils/Utils" prefix Utils_;
+
+  export ledger _owner: Either<ZswapCoinPublicKey, ContractAddress>;
+
+  /**
+   * @description Initializes the contract by setting the `initialOwner`.
+   * This must be called in the contract's constructor.
+   *
+   * @circuitInfo k=10, rows=258
+   *
+   * Requirements:
+   *
+   * - Contract is not already initialized.
+   * - `initialOwner` is not a ContractAddress.
+   * - `initialOwner` is not the zero address.
+   *
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} initialOwner - The initial owner of the contract.
+   * @returns {[]} Empty tuple.
+   */
+  export circuit initialize(initialOwner: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    Initializable_initialize();
+    assert(!Utils_isKeyOrAddressZero(initialOwner), "Ownable: invalid initial owner");
+    _transferOwnership(initialOwner);
+  }
+
+  /**
+   * @description Returns the current contract owner.
+   *
+   * @circuitInfo k=10, rows=84
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   *
+   * @returns {Either<ZswapCoinPublicKey, ContractAddress> } - The contract owner.
+   */
+  export circuit owner(): Either<ZswapCoinPublicKey, ContractAddress> {
+    Initializable_assertInitialized();
+    return _owner;
+  }
+
+  /**
+   * @description Transfers ownership of the contract to `newOwner`.
+   *
+   * @circuitInfo k=10, rows=338
+   *
+   * @notice Ownership transfers to contract addresses are currently disallowed until contract-to-contract
+   * interactions are supported in Compact.
+   * This restriction prevents permanently disabling access to a circuit.
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   * - The caller is the current contract owner.
+   * - `newOwner` is not a ContractAddress.
+   * - `newOwner` is not the zero address.
+   *
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} newOwner - The new owner.
+   * @returns {[]} Empty tuple.
+   */
+  export circuit transferOwnership(newOwner: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    Initializable_assertInitialized();
+    assert(!Utils_isContractAddress(newOwner), "Ownable: unsafe ownership transfer");
+    _unsafeTransferOwnership(newOwner);
+  }
+
+  /**
+   * @description Unsafe variant of `transferOwnership`.
+   *
+   * @circuitInfo k=10, rows=335
+   *
+   * @warning Ownership transfers to contract addresses are considered unsafe because contract-to-contract
+   * calls are not currently supported.
+   * Ownership privileges sent to a contract address may become uncallable.
+   * Once contract-to-contract calls are supported, this circuit may be deprecated.
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   * - The caller is the current contract owner.
+   * - `newOwner` is not the zero address.
+   *
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} newOwner - The new owner.
+   * @returns {[]} Empty tuple.
+   */
+  export circuit _unsafeTransferOwnership(newOwner: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    Initializable_assertInitialized();
+    assertOnlyOwner();
+    assert(!Utils_isKeyOrAddressZero(newOwner), "Ownable: invalid new owner");
+    _unsafeUncheckedTransferOwnership(newOwner);
+  }
+
+  /**
+   * @description Leaves the contract without an owner.
+   * It will not be possible to call `assertOnlyOnwer` circuits anymore.
+   * Can only be called by the current owner.
+   *
+   * @circuitInfo k=10, rows=124
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   * - The caller is the current contract owner.
+   *
+   * @returns {[]} Empty tuple.
+   */
+  export circuit renounceOwnership(): [] {
+    Initializable_assertInitialized();
+    assertOnlyOwner();
+    _transferOwnership(burnAddress());
+  }
+
+  /**
+   * @description Throws if called by any account other than the owner.
+   * Use this to restrict access of specific circuits to the owner.
+   *
+   * @circuitInfo k=10, rows=115
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   * - The caller is the current contract owner.
+   *
+   * @returns {[]} Empty tuple.
+   */
+  export circuit assertOnlyOwner(): [] {
+    Initializable_assertInitialized();
+    const caller = ownPublicKey();
+    assert(caller == _owner.left, "Ownable: caller is not the owner");
+  }
+
+  /**
+   * @description Transfers ownership of the contract to `newOwner` without
+   * enforcing permission checks on the caller.
+   *
+   * @circuitInfo k=10, rows=219
+   *
+   * @notice Ownership transfers to contract addresses are currently disallowed until contract-to-contract
+   * interactions are supported in Compact.
+   * This restriction prevents circuits from being inadvertently locked in contracts.
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   * - `newOwner` is not a ContractAddress.
+   *
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} newOwner - The new owner.
+   * @returns {[]} Empty tuple.
+   */
+  export circuit _transferOwnership(newOwner: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    Initializable_assertInitialized();
+    assert(!Utils_isContractAddress(newOwner), "Ownable: unsafe ownership transfer");
+    _unsafeUncheckedTransferOwnership(newOwner);
+  }
+
+  /**
+   * @description Unsafe variant of `_transferOwnership`.
+   *
+   * @circuitInfo k=10, rows=216
+   *
+   * @warning Ownership transfers to contract addresses are considered unsafe because contract-to-contract
+   * calls are not currently supported.
+   * Ownership privileges sent to a contract address may become uncallable.
+   * Once contract-to-contract calls are supported, this circuit may be deprecated.
+   *
+   * Requirements:
+   *
+   * - Contract is initialized.
+   *
+   * @param {Either<ZswapCoinPublicKey, ContractAddress>} newOwner - The new owner.
+   * @returns {[]} Empty tuple.
+   */
+  export circuit _unsafeUncheckedTransferOwnership(newOwner: Either<ZswapCoinPublicKey, ContractAddress>): [] {
+    Initializable_assertInitialized();
+    _owner = disclose(newOwner);
+  }
+}

package/dist/access/witnesses/AccessControlWitnesses.d.ts

@@ -0,0 +1,2 @@
+export type AccessControlPrivateState = Record<string, never>;
+export declare const AccessControlWitnesses: {};

package/dist/access/witnesses/AccessControlWitnesses.js

@@ -0,0 +1 @@
+export const AccessControlWitnesses = {};

package/dist/access/witnesses/AccessControlWitnesses.ts

@@ -0,0 +1,3 @@
+// This is how we type an empty object.
+export type AccessControlPrivateState = Record<string, never>;
+export const AccessControlWitnesses = {};

package/dist/access/witnesses/OwnableWitnesses.d.ts

@@ -0,0 +1,2 @@
+export type OwnablePrivateState = Record<string, never>;
+export declare const OwnableWitnesses: {};

package/dist/access/witnesses/OwnableWitnesses.js

@@ -0,0 +1 @@
+export const OwnableWitnesses = {};

package/dist/access/witnesses/OwnableWitnesses.ts

@@ -0,0 +1,3 @@
+// This is how we type an empty object.
+export type OwnablePrivateState = Record<string, never>;
+export const OwnableWitnesses = {};

package/dist/security/Initializable.compact

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+
+pragma language_version >= 0.16.0;
+
+/**
+ * @module Initializable
+ * @description Initializable provides a simple mechanism that mimics the functionality of a constructor.
+ */
+module Initializable {
+  import CompactStandardLibrary;
+
+  export ledger _isInitialized: Boolean;
+
+  /**
+   * @description Initializes the state thus ensuring the calling circuit can only be called once.
+   *
+   * @circuitInfo k=10, rows=38
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit initialize(): [] {
+    assertNotInitialized();
+    _isInitialized = true;
+  }
+
+  /**
+   * @description Asserts that the contract has been initialized, throwing an error if not.
+   *
+   * @circuitInfo k=10, rows=31
+   *
+   * Requirements:
+   *
+   * - Contract must be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertInitialized(): [] {
+    assert(_isInitialized, "Initializable: contract not initialized");
+  }
+
+  /**
+   * @description Asserts that the contract has not been initialized, throwing an error if it has.
+   *
+   * @circuitInfo k=10, rows=35
+   *
+   * Requirements:
+   *
+   * - Contract must not be initialized.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertNotInitialized(): [] {
+    assert(!_isInitialized, "Initializable: contract already initialized");
+  }
+}

package/dist/security/Pausable.compact

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+
+pragma language_version >= 0.16.0;
+
+/**
+ * @module Pausable
+ * @description Pausable allows the implementing contract to implement
+ * an emergency stop mechanism. Only circuits that call `assertPaused`
+ * or `assertNotPaused` will be affected by this mechanism.
+ */
+module Pausable {
+  import CompactStandardLibrary;
+
+  export ledger _isPaused: Boolean;
+
+  /**
+   * @description Returns true if the contract is paused, and false otherwise.
+   *
+   * @circuitInfo k=10, rows=32
+   *
+   * @return {Boolean} True if paused.
+   */
+  export circuit isPaused(): Boolean {
+    return _isPaused;
+  }
+
+  /**
+   * @description Makes a circuit only callable when the contract is paused.
+   *
+   * @circuitInfo k=10, rows=31
+   *
+   * Requirements:
+   *
+   * - Contract must be paused.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertPaused(): [] {
+    assert(_isPaused, "Pausable: not paused");
+  }
+
+  /**
+   * @description Makes a circuit only callable when the contract is not paused.
+   *
+   * @circuitInfo k=10, rows=35
+   *
+   * Requirements:
+   *
+   * - Contract must not be paused.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit assertNotPaused(): [] {
+    assert(!_isPaused, "Pausable: paused");
+  }
+
+  /**
+   * @description Triggers a stopped state.
+   *
+   * @circuitInfo k=10, rows=38
+   *
+   * Requirements:
+   *
+   * - Contract must not be paused.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _pause(): [] {
+    assertNotPaused();
+    _isPaused = true;
+  }
+
+  /**
+   * @description Lifts the pause on the contract.
+   *
+   * @circuitInfo k=10, rows=34
+   *
+   * Requirements:
+   *
+   * - Contract must be paused.
+   *
+   * @return {[]} - Empty tuple.
+   */
+  export circuit _unpause(): [] {
+    assertPaused();
+    _isPaused = false;
+  }
+}