@towns-protocol/contracts 0.0.430 → 0.0.432

package/README.md

@@ -58,11 +58,10 @@ The system also supports cross-chain delegation between Ethereum L1 and Base L2,
 
 ## Requirements
 
-Install [yarn](https://yarnpkg.com/getting-started/install) via corepack:
+Install [Bun](https://bun.sh/):
 
 ```shell
-npm install -g corepack
-corepack enable
+curl -fsSL https://bun.sh/install | bash
 ```
 
 Install [Foundry](https://github.com/foundry-rs/foundry):
@@ -77,7 +76,7 @@ foundryup
 Clone the repo, then:
 
 ```shell
-yarn
+bun install
 ```
 
 **To compile the smart contracts:**

package/docs/permitAndStake_integration_guide.md

@@ -39,7 +39,7 @@ function permitAndStake(
 #### Dependencies
 
 ```bash
-yarn add @uniswap/permit2-sdk viem
+bun add @uniswap/permit2-sdk viem
 ```
 
 #### Complete Integration Example

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.430",
+  "version": "0.0.432",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
-    "format": "yarn prettier:write",
-    "lint": "yarn solhint \"{script,src,tests}/**/*.sol\"",
+    "format": "bun run prettier:write",
+    "lint": "bun run solhint \"{script,src,tests}/**/*.sol\"",
     "prettier:check": "prettier --check \"**/*.{sol,json,js,md,yml,ts}\" --ignore-path \".prettierignore\"",
     "prettier:write": "prettier --write \"**/*.{sol,json,js,md,yml,ts}\" --ignore-path \".prettierignore\"",
     "snapshot": "forge snapshot --isolate",
     "test": "forge test --ffi --nmc Fork --fuzz-runs 4096",
-    "test:unit": "yarn test",
+    "test:unit": "bun run test",
     "typings": "wagmi generate"
   },
   "dependencies": {
-    "@erc6900/reference-implementation": "https://github.com/erc6900/reference-implementation/archive/refs/tags/v0.8.0.tar.gz",
+    "@erc6900/reference-implementation": "github:erc6900/reference-implementation#v0.8.0",
     "@ethereum-attestation-service/eas-contracts": "^1.8.0",
     "@layerzerolabs/oft-evm": "^3.1.4",
     "@openzeppelin/contracts": "^5.4.0",
@@ -33,7 +33,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.430",
+    "@towns-protocol/prettier-config": "^0.0.432",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
     "prettier": "^3.5.3",
@@ -47,11 +47,8 @@
     "scripts/**/*.sol",
     "README.md"
   ],
-  "installConfig": {
-    "hoistingLimits": "dependencies"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "200adfdd8222b53b62d2af9609ed04f3eb831584"
+  "gitHead": "aed1393cc61f669c852b2d244630e27ae27a5922"
 }

package/scripts/bytecode-diff/README.md

@@ -0,0 +1,182 @@
+# Bytecode-Diff Tool
+
+Bytecode-Diff is a tool to retrieve and display contract bytecode diff for Base deployed contracts and Solidity source compiled bytecode compiled with forge. It provides functionality to run source code diffs or remote bytecode diffs and create reports that detail changes between two compiled bytecode versions of contracts.
+
+## Prerequisites
+
+- Go 1.22 or later
+- Base RPC Provider URL
+- River Chain RPC Provider URL
+- Basescan API Key
+
+## Usage
+
+### Local Source Code Diff
+
+Compile contracts with forge and run source code diff comparing nearest commit report with checked out commit.
+
+The basic command structure is:
+
+```bash
+# ensure contracts are compiled with forge
+cd ../../packages/contracts
+make build
+# disable go.work file since bytecode-diff is not a module in parent go workspace
+go mod download
+# run source diff from checked out commitSha compared nearest commit with a source diff report in SOURCE_DIFF_DIR
+GOWORK=off go run main.go -v -s
+
+# write report with contract addresses, their keccak256 compilaed bytecode hash under two keys, existing and updated.
+➜  bytecode-diff ✗ yq eval '.existing' source-diffs/00adc44f_08292024_5.yaml
+Architect: 0xd291e489716f2c9cfc2e2c6047ce777159969943c85d09c51aaf7bbad10f7c13
+ArchitectBase: 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+ArchitectStorage: 0x86159d997458669c4df8af2da4b5ce9ca742099a3f854c5eb3e718e16a74e4da
+Banning: 0xde1354882fd30088cce4b00ff720a6dbc8c9f25653477c6ee99e20e17edb6068
+BanningBase: 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+BanningStorage: 0x86159d997458669c4df8af2da4b5ce9ca742099a3f854c5eb3e718e16a74e4da
+ChannelBase: 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+...
+```
+
+### Run pairwise remote bytecode diff on facets deployed to two networks
+
+Runs bytecode diff from deployed facets for diamonds in alpha, beta, and omega environments as per source coordinates of diamonds for each environment.
+
+```bash
+# compare omega against beta facets and facet selectors
+GOWORK=off go run ./main.go beta omega -v
+
+# output facet implementation changes by facet or selectors that are missing from omega
+➜  bytecode-diff git:(jt/net-62-contract-differ) ✗ yq eval deployed-diffs/facet_diff_090324_18.yaml
+diamonds:
+  - name: spaceOwner
+    source: beta
+    target: omega
+    facets:
+      - sourceContractName: ""
+        sourceFacetAddress: 0xfa98a1648761e494fc7d6efe5a06e357a76bd6fb
+        selectorsDiff:
+          - "0x3953801b"
+          - "0x91de4a83"
+        sourceBytecodeHash: 0xf86d9dbe53c89e14fa69cde925cca02b6efad519fe172f7b04d9515d7700a59b
+        sourceVerified: false
+        targetVerified: false
+      - sourceContractName: SpaceOwner
+        sourceFacetAddress: 0x30c912d8ceb9793e4cd240862acfd0e6c4436c52
+        targetContractAddresses:
+          - 0x63bC35259Ac32DF43Fba3b890F0F74951451976A
+          - 0xe7EB1313f0E7076616534225e16E971B72b50C42
+        selectorsDiff: []
+        sourceBytecodeHash: 0x461b53ab37fd24283ecd63eb0d4e71bd554a266036c73caf6d2ac39c435e7732
+        targetBytecodeHashes:
+          - 0x86d20161a13671a6138b80551e94dd8c1638bc5151807ff2194aa1e50cdb3cac
+          - 0xff0a94e93a4f4f6ee0ecd0d0e469e55ca40f1ab6c10e6af9da5b2b597f32b178
+        sourceVerified: true
+        targetVerified: true
+      - sourceContractName: ""
+        sourceFacetAddress: 0xdba2ce6125cc6b7f93c63d181a0780d5b421940b
+        selectorsDiff:
+          - "0x0d653654"
+          - "0x466a18de"
+        sourceBytecodeHash: 0x583c2852056f90c96ed1cab935489f644b8ef564e0a7f11564925d07cf3bc593
+        sourceVerified: false
+        targetVerified: false
+
+```
+
+### Run keccak256 hash generation on deployed contracts
+
+```bash
+GOWORK=off go run main.go add-hashes beta deployed-diffs/facet_diff_090624_1.yaml
+
+# output to new yaml file suffixed with _hashed.yaml including bytecodeHash for each contract in deployments section
+➜  bytecode-diff git:(jt/net-62-upgrade-script-2) ✗ yq e '.deployments' deployed-diffs/facet_diff_090624_1_hashed.yaml
+Architect:
+  address: 0xa18a3df4f63cdcae943d9c76730adf2812388de4
+  baseScanLink: https://sepolia.basescan.org/tx/0x4280ef1300fe001e7d85e7495eba13fc99be53ee7a7060e753d466f8bebf1622
+  bytecodeHash: 0x20d0a86e9ea31a39663285aacfe88705983520a4482a7bac5ada891c9adfe090
+  deploymentDate: 2024-09-06 19:04
+  transactionHash: 0x4280ef1300fe001e7d85e7495eba13fc99be53ee7a7060e753d466f8bebf1622
+Banning:
+  address: 0x4d88d1fbba6ce6bcdb4381549ee0b7c0d2b56919
+  baseScanLink: https://sepolia.basescan.org/tx/0x4ccbaf9750bcd0971975e73a24b05f1c51d4703cf72a406356c79eb54de9c33c
+  bytecodeHash: 0xa2ce3e77ba060ff1d59ed384e1c6c5788f308ad8bbbef612eb3e5de4e1d79de8
+  deploymentDate: 2024-09-06 19:05
+  transactionHash: 0x4ccbaf9750bcd0971975e73a24b05f1c51d4703cf72a406356c79eb54de9c33c
+...
+```
+
+### Flags
+
+```bash
+➜  bytecode-diff ✗ GOWORK=off go run ./main.go --help
+A tool to retrieve and display contract bytecode diff for Base
+
+Usage:
+  bytecode-diff [source_environment] [target_environment] [flags]
+
+Flags:
+  -b, --base-rpc string           Base RPC provider URL
+      --base-sepolia-rpc string   Base Sepolia RPC provider URL
+      --compiled-facets string    Path to compiled facets
+      --deployments string        Path to deployments directory (default "../../packages/contracts/deployments")
+      --facets string             Path to facet source files
+  -h, --help                      help for bytecode-diff
+      --log-level string          Set the logging level (debug, info, warn, error) (default "info")
+      --report-out-dir string     Path to report output directory (default "deployed-diffs")
+      --source-diff-log string    Path to diff log file (default "source-diffs")
+  -s, --source-diff-only          Run source code diff
+  -v, --verbose                   Enable verbose output
+```
+
+### Environment Variables
+
+You can also set the following environment variables instead of using flags:
+
+- `BASE_RPC_URL`: Base RPC provider URL
+- `BASE_SEPOLIA_RPC_URL`: Base Sepolia RPC provider URL
+- `FACET_SOURCE_PATH`: Path to facet source files
+- `ETHERSCAN_API_KEY`: Your API key for Etherscan.
+- `COMPILED_FACETS_PATH`: (Optional) Path to compiled facets
+- `DEPLOYMENTS_PATH`: (Optional) Path to deployed contracts
+- `REPORT_OUT_DIR`: (Optional) Path to report output directory
+- `SOURCE_DIFF_DIR`: (Optional) Path to source diff reports
+
+## Examples
+
+1. Run source code diff with all parameters specified via flags:
+
+```
+./bytecode-diff --source-diff-only \
+  --source-diff-dir /path/to/source-diff-reports \
+  --facets /path/to/facet/sources \
+  --compiled-facets /path/to/compiled/facets \
+  --report-out-dir /path/to/report/output \
+  --verbose
+```
+
+2. Run source code diff using environment variables:
+
+```bash
+export SOURCE_DIFF_DIR=/path/to/source_diff.log
+export FACET_SOURCE_PATH=/path/to/facet/sources
+export COMPILED_FACETS_PATH=/path/to/compiled/facets
+export REPORT_OUT_DIR=/path/to/report/output
+
+./bytecode-diff -s --verbose
+```
+
+3. Run source code diff with r/w to remote s3 bucket:
+
+```bash
+export AWS_ACCESS_KEY_ID=<your-access-key-id>
+export AWS_SECRET_ACCESS_KEY=<your-secret-access-key>
+export SOURCE_DIFF_DIR=s3://bucket/path
+./bytecode-diff -s --verbose
+```
+
+## Notes
+
+- If a `.env` file is present in the same directory as the script, it will be loaded automatically.
+- When running source code diff, all required paths must be provided either via flags or environment variables.
+- Use the `--verbose` flag for more detailed output during execution.

package/scripts/readme.md

@@ -0,0 +1,289 @@
+## Opinionated deployment scripting 🚀
+
+Inspired by [hardhat-deploy](https://github.com/wighawag/hardhat-deploy)
+
+This project supports two methods for deploying contracts:
+
+### Method 1: Custom Deployment Scripts
+
+For each contract being deployed, we create a script that will:
+
+1. inherit from `Deployer`
+2. implement a `versionName()` and `__deploy()` function
+
+Example contract:
+
+<details>
+<summary>Click to expand example code</summary>
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import { Deployer } from "scripts/common/Deployer.s.sol";
+import { MockERC721A } from "test/mocks/MockERC721A.sol";
+
+contract DeployMockERC721A is Deployer {
+  function versionName() public pure override returns (string memory) {
+    return "mockERC721A";
+  }
+
+  function __deploy(address deployer) public override returns (address) {
+    vm.broadcast(deployer);
+    return address(new MockERC721A());
+  }
+}
+```
+
+</details>
+
+The framework will:
+
+1. Load an existing deployment from
+   `contracts/deployments/<deploymentContext>/<chainIdAlias>/<contracts>.json`
+
+2. if `OVERRIDE_DEPLOYMENTS=1` is set or if no deployments are found, it will:
+
+- read `PRIVATE_KEY` from env (LOCAL_PRIVATE_KEY for anvil) or wait for ledger
+- invoke `__deploy()` function
+- if `SAVE_DEPLOYMENTS` is set; it will save the deployment to
+  `contracts/deployments/deploymentContext/<network>/<contract>.json`
+
+### Method 2: DeployFacet Script (For Facet Contracts)
+
+For facet contract deployments, we also support a standardized deployment process using the `DeployFacet.s.sol` script which:
+
+1. Uses deterministic CREATE2 addresses for predictable deployment outcomes
+2. Supports batch deployments for gas efficiency
+3. Provides advanced gas estimation and deployment verification
+
+- `OVERRIDE_DEPLOYMENTS=1`: It will redeploy a version of the contracts even if there's a cache in
+  deployments assigned, be very careful when using this
+- `SAVE_DEPLOYMENTS=1`: It will save a cached address of deployments to
+  `contracts/deployments/<network>/<contract>.json`
+- `DEPLOYMENT_CONTEXT=string`: It will save the addresses on a subdirectory with the given name,
+  useful for deployment contract to same network
+
+## How to write new deployment libraries and diamonds
+
+This project uses two distinct but complementary components for diamond pattern deployments:
+
+### 1. Facet Deployment Libraries
+
+Facet deployment libraries (like `DeployMembershipMetadata.s.sol`) define helper functions for diamond cuts but don't handle the actual facet contract deployment. These libraries typically provide:
+
+1. A `selectors()` function that returns an array of function selectors the facet provides
+2. A `makeCut()` function that creates a `FacetCut` struct for diamond upgrades
+3. Optional: A `deploy()` function for manual deployment (though we prefer using `DeployFacet` for this)
+
+To create a new facet deployment library:
+
+1. Create a new file `Deploy[YourFacet].s.sol` in `scripts/deployments/facets/`
+2. Implement the required functions as shown in the example below
+
+Example of a facet deployment library:
+
+<details>
+<summary>Click to expand example code</summary>
+
+```solidity
+import { IDiamond } from "@towns-protocol/diamond/src/Diamond.sol";
+import { IMembershipMetadata } from "src/spaces/facets/membership/metadata/IMembershipMetadata.sol";
+import { LibDeploy } from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+library DeployMembershipMetadata {
+  // Return all function selectors this facet provides
+  function selectors() internal pure returns (bytes4[] memory res) {
+    res = new bytes4[](2);
+    res[0] = IMembershipMetadata.refreshMetadata.selector;
+    res[1] = IMembershipMetadata.tokenURI.selector;
+  }
+
+  // Create a FacetCut struct for diamond upgrades
+  function makeCut(
+    address facetAddress,
+    IDiamond.FacetCutAction action
+  ) internal pure returns (IDiamond.FacetCut memory) {
+    return IDiamond.FacetCut(facetAddress, action, selectors());
+  }
+
+  // Optional direct deployment method (prefer using DeployFacet instead)
+  function deploy() internal returns (address) {
+    return LibDeploy.deployCode("MembershipMetadata.sol", "");
+  }
+}
+```
+
+</details>
+
+### 2. Diamond Deployment Scripts
+
+Diamond deployment scripts (like `DeploySpace.s.sol`) coordinate the deployment of multiple facets and their integration into a diamond. These scripts:
+
+1. Use `DeployFacet` to efficiently deploy multiple facets using CREATE2 and Multicall3
+2. Use the facet deployment libraries to prepare diamond cuts
+3. Handle the initialization and configuration of the diamond
+
+To create a new diamond deployment script:
+
+1. Create a new file `Deploy[YourDiamond].s.sol` in `scripts/deployments/diamonds/`
+2. Inherit from `DiamondHelper`, `Deployer` and implement required functions
+3. Use `DeployFacet` for batch deployments of facets
+4. Use facet deployment libraries to create diamond cuts
+
+Example pattern from `DeploySpace.s.sol`:
+
+<details>
+<summary>Click to expand example code</summary>
+
+```solidity
+contract DeploySpace is DiamondHelper, Deployer {
+  // Create a DeployFacet helper for batch deployments
+  DeployFacet private facetHelper = new DeployFacet();
+
+  function versionName() public pure override returns (string memory) {
+    return "space";
+  }
+
+  function __deploy(address deployer) internal override returns (address) {
+    // Add core facets (like DiamondCut, DiamondLoupe, etc.)
+    addImmutableCuts(deployer);
+
+    // Set up diamond initialization parameters with additional facets
+    Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);
+
+    // Deploy the diamond with all facets
+    vm.broadcast(deployer);
+    Diamond diamond = new Diamond(initDiamondCut);
+
+    return address(diamond);
+  }
+
+  function diamondInitParams(
+    address deployer
+  ) public returns (Diamond.InitParams memory) {
+    // Queue facets for batch deployment
+    facetHelper.add("MembershipToken");
+    facetHelper.add("MembershipMetadata");
+    // ... add other facets ...
+
+    // Deploy all queued facets in a single transaction
+    facetHelper.deployBatch(deployer);
+
+    // Add each facet to the diamond cut using the corresponding deployment library
+    address facet = facetHelper.getDeployedAddress("MembershipMetadata");
+    addCut(
+      DeployMembershipMetadata.makeCut(facet, IDiamond.FacetCutAction.Add)
+    );
+
+    // ... add other facets ...
+
+    // Return the diamond initialization parameters
+    return
+      Diamond.InitParams({
+        baseFacets: baseFacets(),
+        init: multiInit,
+        initData: abi.encodeCall(
+          MultiInit.multiInit,
+          (_initAddresses, _initDatas)
+        )
+      });
+  }
+}
+```
+
+</details>
+
+### Integration with makefile
+
+Once you've created your deployment components, you can use them with the makefile:
+
+```bash
+# To deploy a specific facet:
+make deploy-facet rpc=base_sepolia contract=YourFacet
+
+# To deploy a diamond:
+make deploy-base-sepolia contract=DeployYourDiamond type=diamonds
+```
+
+This approach separates facet contract deployment (using `DeployFacet` with CREATE2) from diamond integration (using facet deployment libraries), providing both efficiency and flexibility.
+
+### How to deploy locally (step-by-step)
+
+<details>
+<summary>Click to expand deployment steps</summary>
+
+```bash
+# say you want to deploy a new MockERC721A
+
+# Provision a new deployer
+-> cast wallet new
+
+# save the key in .env (LOCAL_PRIVATE_KEY=...)
+
+# Fund the deployer address (this is the first address shown when runing `anvil`)
+-> cast send ${NEW_WALLET_ADDRESS} --value 1ether -f 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --unlocked
+
+# perform a local simulation
+-> forge script script/${CONTRACT}.s.sol
+
+# perform a simulation against a network
+-> forge script script/${CONTRACT}.s.sol --rpc-url <network>
+
+# run anvil in separate terminal
+-> anvil
+
+# perform the deployment to a local network
+# Option 1: Custom deployment script
+-> make deploy-any-local contract=DeployMockERC721A type=facets
+
+# Option 2: Using the DeployFacet script (for facet contracts)
+-> make deploy-facet-local rpc=base_anvil contract=MockERC721A
+```
+
+</details>
+
+### How to deploy to a testnet or mainnet
+
+<details>
+<summary>Click to expand deployment steps</summary>
+
+```bash
+# Method 1: Using custom deployment scripts
+# To deploy a contract to Base Sepolia in the "beta" deployment context:
+-> make deploy-base-sepolia contract=DeployWalletLink type=facets context=beta
+
+# Method 2: Using the DeployFacet script
+# To deploy a facet to Base Sepolia:
+-> make deploy-facet rpc=base_sepolia contract=WalletLink context=beta
+
+# To deploy with a ledger hardware wallet to Base mainnet:
+# Method 1: Using custom deployment scripts
+-> make deploy-base contract=DeploySpaceFactory type=diamonds context=omega
+
+# Method 2: Using the DeployFacet script
+-> make deploy-facet-ledger rpc=base contract=WalletLink context=omega
+
+# To redeploy a contract to Base Sepolia in the "beta" deployment context:
+-> OVERRIDE_DEPLOYMENTS=1 make deploy-base-sepolia contract=DeployWalletLink type=facets context=beta
+```
+
+</details>
+
+### How to script (interact with deployed contracts through foundry)
+
+<details>
+<summary>Click to expand example steps</summary>
+
+```bash
+# say you want to mint from MockERC721A
+
+# deploy a local implementation of MockERC721A by calling DeployFacet
+-> make deploy-facet-local rpc=base_anvil contract=MockERC721A
+
+# next we'll call the script InteractMockERC721A
+# This will grab new and existing deployment addresses from our deployments cache and use those to interact with each other
+-> make interact-any-local rpc=base_anvil contract=InteractMockERC721A
+```
+
+</details>

package/src/diamond/readme.md

@@ -0,0 +1,50 @@
+## Guidelines for creating a facet
+
+- Use diamond storage `Layout` for storing variables `<FacetName>Storage`
+- Specify your internal business logic, and interaction with storage in `<FacetName>Base` abstract
+  contract
+- Create you initializers and your protected external calls in the `<FacetName>Facet` contract
+- Define your external and internal interface in `I<FacetName>` interface file
+  - `I<FacetName>Base` internal interface gets inherited by your `<FacetName>Base` abstract contract
+    and it usually holds structs, enums, errors and events
+  - `I<FacetName>` external interface gets inherited by your `<FacetName>Facet` contract and it
+    usually holds external functions, this interface can inherit your internal `I<FacetName>Base` to
+    have access to its data types
+
+> Minimal example
+
+```solidity
+library SampleStorage {
+  struct Layout {
+    uint256 value;
+  }
+
+  function layout() internal pure returns (Layout storage ds) {
+    bytes32 slot = keccak256("sample.storage");
+    assembly {
+      ds.slot := slot
+    }
+  }
+}
+
+interface ISampleBase {
+  event ValueSet(uint256 value);
+}
+
+inteface ISample is ISampleBase {
+  function setValue(uint256) external;
+}
+
+abstract contract SampleBase is ISampleBase {
+  function _setValue(uint256 val) internal {
+    SampleStorage.layout().value = x;
+    emit ValueSet(val);
+  }
+}
+
+contract SampleFacet is ISample, SampleBase {
+  function setValue(uint256 val) onlyOwner external {
+    _setValue(val);
+  }
+}
+```

package/src/spaces/facets/membership/MembershipFacet.sol

@@ -103,21 +103,26 @@ contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet
 
     /// @inheritdoc IMembership
     function getMembershipPrice() external view returns (uint256 totalRequired) {
-        (totalRequired, ) = _getTotalMembershipPayment(_getMembershipPrice(_totalSupply()));
+        uint256 membershipPrice = _getMembershipPrice(_totalSupply());
+        if (membershipPrice == 0) return 0;
+
+        (totalRequired, ) = _getTotalMembershipPayment(membershipPrice);
     }
 
     /// @inheritdoc IMembership
     function getMembershipRenewalPrice(
         uint256 tokenId
     ) external view returns (uint256 totalRequired) {
-        (totalRequired, ) = _getTotalMembershipPayment(
-            _getMembershipRenewalPrice(tokenId, _totalSupply())
-        );
+        uint256 renewalPrice = _getMembershipRenewalPrice(tokenId, _totalSupply());
+        if (renewalPrice == 0) return 0;
+        (totalRequired, ) = _getTotalMembershipPayment(renewalPrice);
     }
 
     /// @inheritdoc IMembership
     function getProtocolFee() external view returns (uint256 protocolFee) {
-        (, protocolFee) = _getTotalMembershipPayment(_getMembershipPrice(_totalSupply()));
+        uint256 membershipPrice = _getMembershipPrice(_totalSupply());
+        if (membershipPrice == 0) return 0;
+        (, protocolFee) = _getTotalMembershipPayment(membershipPrice);
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/

package/src/spaces/facets/membership/join/MembershipJoin.sol

@@ -499,6 +499,20 @@ abstract contract MembershipJoin is
 
         uint256 duration = _getMembershipDuration();
         uint256 basePrice = _getMembershipRenewalPrice(tokenId, _totalSupply());
+
+        // Handle free renewal
+        if (basePrice == 0) {
+            // Refund any ETH sent
+            CurrencyTransfer.transferCurrency(
+                _getMembershipCurrency(),
+                address(this),
+                payer,
+                msg.value
+            );
+            _renewSubscription(tokenId, uint64(duration));
+            return;
+        }
+
         (uint256 totalRequired, ) = _getTotalMembershipPayment(basePrice);
 
         if (totalRequired > msg.value) Membership__InvalidPayment.selector.revertWith();