@zoralabs/coins 1.1.2 → 2.0.0

package/dist/wagmiGenerated.d.ts

@@ -1764,7 +1764,7 @@ export declare const coinABI: readonly [{
     readonly inputs: readonly [];
     readonly name: "UseRevokeOwnershipToRemoveSelf";
 }];
-export declare const coinV4ABI: readonly [{
+export declare const contentCoinABI: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
         readonly name: "protocolRewardRecipient_";
@@ -5762,6 +5762,12 @@ export declare const zoraFactoryImplABI: readonly [{
         readonly type: "string";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "acceptOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -6152,6 +6158,16 @@ export declare const zoraFactoryImplABI: readonly [{
         readonly type: "address";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "pendingOwner";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -6419,6 +6435,21 @@ export declare const zoraFactoryImplABI: readonly [{
         readonly indexed: false;
     }];
     readonly name: "Initialized";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "newOwner";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly name: "OwnershipTransferStarted";
 }, {
     readonly type: "event";
     readonly anonymous: false;

package/dist/wagmiGenerated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wagmiGenerated.d.ts","sourceRoot":"","sources":["../package/wagmiGenerated.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FjB,CAAA;AAMV,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFjC,CAAA;AAMV,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuiCV,CAAA;AAMV,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwjCZ,CAAA;AAMV,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAioCjB,CAAA;AAMV,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyfd,CAAA;AAMV,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBzB,CAAA;AAMV,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkIpB,CAAA;AAMV,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBtB,CAAA;AAMV,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyjBrB,CAAA"}
+{"version":3,"file":"wagmiGenerated.d.ts","sourceRoot":"","sources":["../package/wagmiGenerated.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FjB,CAAA;AAMV,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFjC,CAAA;AAMV,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuiCV,CAAA;AAMV,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwjCjB,CAAA;AAMV,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAioCjB,CAAA;AAMV,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyfd,CAAA;AAMV,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBzB,CAAA;AAMV,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkIpB,CAAA;AAMV,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBtB,CAAA;AAMV,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0lBrB,CAAA"}

package/package/wagmiGenerated.ts

@@ -1256,10 +1256,10 @@ export const coinABI = [
 ] as const
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// CoinV4
+// ContentCoin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export const coinV4ABI = [
+export const contentCoinABI = [
   {
     type: 'constructor',
     inputs: [
@@ -4229,6 +4229,13 @@ export const zoraFactoryImplABI = [
     outputs: [{ name: '', internalType: 'string', type: 'string' }],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'acceptOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
   {
     type: 'function',
     inputs: [
@@ -4418,6 +4425,13 @@ export const zoraFactoryImplABI = [
     outputs: [{ name: '', internalType: 'address', type: 'address' }],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'pendingOwner',
+    outputs: [{ name: '', internalType: 'address', type: 'address' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -4659,6 +4673,25 @@ export const zoraFactoryImplABI = [
     ],
     name: 'Initialized',
   },
+  {
+    type: 'event',
+    anonymous: false,
+    inputs: [
+      {
+        name: 'previousOwner',
+        internalType: 'address',
+        type: 'address',
+        indexed: true,
+      },
+      {
+        name: 'newOwner',
+        internalType: 'address',
+        type: 'address',
+        indexed: true,
+      },
+    ],
+    name: 'OwnershipTransferStarted',
+  },
   {
     type: 'event',
     anonymous: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/script/TestBackingCoinSwap.s.sol

@@ -8,7 +8,7 @@ import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {MarketConstants} from "../src/libs/MarketConstants.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
-import {CoinV4} from "../src/CoinV4.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
 import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";

package/script/TestV4Swap.s.sol

@@ -8,7 +8,7 @@ import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {MarketConstants} from "../src/libs/MarketConstants.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
-import {CoinV4} from "../src/CoinV4.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
 import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";

package/src/{CoinV4.sol → BaseCoinV4.sol}

@@ -20,7 +20,12 @@ import {CoinConstants} from "./libs/CoinConstants.sol";
 import {IUpgradeableV4Hook} from "./interfaces/IUpgradeableV4Hook.sol";
 import {CoinCommon} from "./libs/CoinCommon.sol";
 
-contract CoinV4 is BaseCoin, ICoinV4 {
+/**
+ * @title BaseCoinV4
+ * @notice Abstract base contract for Uniswap V4 integrated coins
+ * @dev Provides shared V4 functionality for both content coins and creator coins
+ */
+abstract contract BaseCoinV4 is BaseCoin, ICoinV4 {
     /// @notice The Uniswap v4 pool manager singleton contract reference.
     IPoolManager public immutable poolManager;
 
@@ -30,8 +35,8 @@ contract CoinV4 is BaseCoin, ICoinV4 {
     /// @notice The configuration for the pool.
     PoolConfiguration internal poolConfiguration;
 
-    /// @notice The constructor for the static CoinV4 contract deployment shared across all Coins.
-    /// @dev All arguments are required and cannot be set to teh 0 address.
+    /// @notice The constructor for the static BaseCoinV4 contract deployment shared across all Coins.
+    /// @dev All arguments are required and cannot be set to the 0 address.
     /// @param protocolRewardRecipient_ The address of the protocol reward recipient
     /// @param protocolRewards_ The address of the protocol rewards contract
     /// @param poolManager_ The address of the pool manager
@@ -86,19 +91,6 @@ contract CoinV4 is BaseCoin, ICoinV4 {
         poolManager.initialize(poolKey, sqrtPriceX96);
     }
 
-    /// @dev The initial mint and distribution of the coin supply.
-    ///      Overrides the BaseCoin._handleInitialDistribution to transfer the market supply to the hook.
-    function _handleInitialDistribution() internal virtual override {
-        // Mint the total supply to the coin contract
-        _mint(address(this), CoinConstants.MAX_TOTAL_SUPPLY);
-
-        // Distribute the creator launch reward to the payout recipient
-        _transfer(address(this), payoutRecipient, CoinConstants.CREATOR_LAUNCH_REWARD);
-
-        // Transfer the market supply to the hook for liquidity
-        _transfer(address(this), address(poolKey.hooks), balanceOf(address(this)));
-    }
-
     /// @inheritdoc ICoinV4
     function hooks() external view returns (IHooks) {
         return poolKey.hooks;

package/src/ContentCoin.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BaseCoinV4} from "./BaseCoinV4.sol";
+import {CoinConstants} from "./libs/CoinConstants.sol";
+
+/**
+ * @title ContentCoin
+ * @notice Content coin implementation that uses creator coins as backing currency
+ * @dev Inherits from BaseCoinV4 and implements content-specific distribution logic
+ */
+contract ContentCoin is BaseCoinV4 {
+    /// @notice The constructor for the static ContentCoin contract deployment shared across all content coins.
+    /// @dev All arguments are required and cannot be set to the 0 address.
+    /// @param protocolRewardRecipient_ The address of the protocol reward recipient
+    /// @param protocolRewards_ The address of the protocol rewards contract
+    /// @param poolManager_ The address of the pool manager
+    /// @param airlock_ The address of the Airlock contract, ownership is used for a protocol fee split.
+    constructor(
+        address protocolRewardRecipient_,
+        address protocolRewards_,
+        IPoolManager poolManager_,
+        address airlock_
+    ) BaseCoinV4(protocolRewardRecipient_, protocolRewards_, poolManager_, airlock_) {}
+
+    /// @dev The initial mint and distribution of the coin supply.
+    ///      Implements content coin specific distribution: 990M to liquidity pool, 10M to creator.
+    function _handleInitialDistribution() internal virtual override {
+        // Mint the total supply to the coin contract
+        _mint(address(this), CoinConstants.MAX_TOTAL_SUPPLY);
+
+        // Distribute the creator launch reward to the payout recipient
+        _transfer(address(this), payoutRecipient, CoinConstants.CREATOR_LAUNCH_REWARD);
+
+        // Transfer the market supply to the hook for liquidity
+        _transfer(address(this), address(poolKey.hooks), balanceOf(address(this)));
+    }
+}

package/src/CreatorCoin.sol

@@ -9,9 +9,11 @@ pragma solidity ^0.8.28;
 
 import {ICreatorCoin} from "./interfaces/ICreatorCoin.sol";
 import {CreatorCoinConstants} from "./libs/CreatorCoinConstants.sol";
-import {IHooks, PoolConfiguration, PoolKey, IPoolManager, ICoinV4, CoinV4} from "./CoinV4.sol";
+import {IHooks, PoolConfiguration, PoolKey, ICoinV4} from "./interfaces/ICoinV4.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BaseCoinV4} from "./BaseCoinV4.sol";
 
-contract CreatorCoin is ICreatorCoin, CoinV4 {
+contract CreatorCoin is ICreatorCoin, BaseCoinV4 {
     uint256 public vestingStartTime;
     uint256 public vestingEndTime;
     uint256 public totalClaimed;
@@ -21,7 +23,7 @@ contract CreatorCoin is ICreatorCoin, CoinV4 {
         address _protocolRewards,
         IPoolManager _poolManager,
         address _airlock
-    ) CoinV4(_protocolRewardRecipient, _protocolRewards, _poolManager, _airlock) initializer {}
+    ) BaseCoinV4(_protocolRewardRecipient, _protocolRewards, _poolManager, _airlock) initializer {}
 
     function initialize(
         address payoutRecipient_,
@@ -34,7 +36,7 @@ contract CreatorCoin is ICreatorCoin, CoinV4 {
         PoolKey memory poolKey_,
         uint160 sqrtPriceX96,
         PoolConfiguration memory poolConfiguration_
-    ) public override(CoinV4, ICoinV4) {
+    ) public override(BaseCoinV4, ICoinV4) {
         require(currency_ == CreatorCoinConstants.CURRENCY, InvalidCurrency());
 
         super.initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_, currency_, poolKey_, sqrtPriceX96, poolConfiguration_);
@@ -44,7 +46,7 @@ contract CreatorCoin is ICreatorCoin, CoinV4 {
     }
 
     /// @dev The initial mint and distribution of the coin supply.
-    ///      Overrides the CoinV4._handleInitialDistribution to transfer the market supply to the hook.
+    ///      Implements creator coin specific distribution: 500M to liquidity pool, 500M vested to creator.
     function _handleInitialDistribution() internal override {
         _mint(address(this), CreatorCoinConstants.TOTAL_SUPPLY);
 

package/src/ZoraFactoryImpl.sol

@@ -8,7 +8,7 @@
 pragma solidity ^0.8.23;
 
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
-import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Ownable2StepUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
@@ -21,7 +21,7 @@ import {IZoraFactory} from "./interfaces/IZoraFactory.sol";
 import {IHasAfterCoinDeploy} from "./hooks/deployment/BaseCoinDeployHook.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {Coin} from "./Coin.sol";
-import {CoinV4} from "./CoinV4.sol";
+import {ContentCoin} from "./ContentCoin.sol";
 import {ICoin, PoolKeyStruct} from "./interfaces/ICoin.sol";
 import {ICoinV3} from "./interfaces/ICoinV3.sol";
 import {ICoinV4} from "./interfaces/ICoinV4.sol";
@@ -45,7 +45,7 @@ contract ZoraFactoryImpl is
     IZoraFactory,
     UUPSUpgradeable,
     ReentrancyGuardUpgradeable,
-    OwnableUpgradeable,
+    Ownable2StepUpgradeable,
     IHasContractName,
     ContractVersionBase,
     DeployedCoinVersionLookup

package/src/deployment/CoinsDeployerBase.sol

@@ -10,7 +10,7 @@ import {Coin} from "../Coin.sol";
 import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
 import {BuySupplyWithSwapRouterHook} from "../hooks/deployment/BuySupplyWithSwapRouterHook.sol";
 import {IZoraFactory} from "../interfaces/IZoraFactory.sol";
-import {CoinV4} from "../CoinV4.sol";
+import {ContentCoin} from "../ContentCoin.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {ZoraFactory} from "../proxy/ZoraFactory.sol";
@@ -114,9 +114,9 @@ contract CoinsDeployerBase is ProxyDeployerScript {
             });
     }
 
-    function deployCoinV4Impl(address zoraV4CoinHook) internal returns (CoinV4) {
+    function deployCoinV4Impl(address zoraV4CoinHook) internal returns (ContentCoin) {
         return
-            new CoinV4({
+            new ContentCoin({
                 protocolRewardRecipient_: getZoraRecipient(),
                 protocolRewards_: PROTOCOL_REWARDS,
                 poolManager_: IPoolManager(getUniswapV4PoolManager()),

package/src/hooks/BaseZoraV4CoinHook.sol

@@ -119,7 +119,7 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
     }
 
     /// @inheritdoc IZoraV4CoinHook
-    function getPoolCoinByHash(bytes23 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory) {
+    function getPoolCoinByHash(bytes32 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory) {
         return poolCoins[poolKeyHash];
     }
 
@@ -372,4 +372,6 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
 
         newPoolKey = V4Liquidity.lockAndMigrate(poolManager, poolKey, poolCoin.positions, poolCoin.coin, newHook, additionalData);
     }
+
+    receive() external payable onlyPoolManager {}
 }

package/src/interfaces/IZoraV4CoinHook.sol

@@ -117,7 +117,7 @@ interface IZoraV4CoinHook is IUpgradeableV4Hook {
     /// @notice Returns the pool coin for a given pool key hash.
     /// @param poolKeyHash The hash of the pool key for indexing.
     /// @return poolCoin The pool coin confirmation data.
-    function getPoolCoinByHash(bytes23 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory);
+    function getPoolCoinByHash(bytes32 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory);
 
     /// @notice Returns the pool coin for a given pool key.
     /// @param key The pool key.

package/src/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "1.1.2";
+        return "2.0.0";
     }
 }

package/test/CoinUniV4.t.sol

@@ -63,7 +63,7 @@ contract CoinUniV4Test is BaseTest {
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        feeState = FeeEstimatorHook(address(contentCoinHook)).getFeeState();
+        feeState = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState();
 
         vm.revertToState(snapshot);
     }
@@ -80,8 +80,8 @@ contract CoinUniV4Test is BaseTest {
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        delta = FeeEstimatorHook(address(contentCoinHook)).getFeeState().lastDelta;
-        swapParams = FeeEstimatorHook(address(contentCoinHook)).getFeeState().lastSwapParams;
+        delta = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastDelta;
+        swapParams = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastSwapParams;
 
         sqrtPriceX96 = PoolStateReader.getSqrtPriceX96(coinV4.getPoolKey(), poolManager);
 
@@ -90,7 +90,7 @@ contract CoinUniV4Test is BaseTest {
 
     function test_setupZeroAddressForPoolManager() public {
         vm.expectRevert(ICoin.AddressZero.selector);
-        new CoinV4({
+        new ContentCoin({
             protocolRewardRecipient_: address(0x1234),
             protocolRewards_: address(0x1234),
             poolManager_: IPoolManager(address(0)),
@@ -100,7 +100,7 @@ contract CoinUniV4Test is BaseTest {
 
     // function test_setupZeroAddressForHooks() public {
     //     vm.expectRevert(ICoin.AddressZero.selector);
-    //     new CoinV4({
+    //     new ContentCoin({
     //         protocolRewardRecipient_: address(0x1234),
     //         protocolRewards_: address(0x1234),
     //         poolManager_: IPoolManager(address(0x1234)),
@@ -293,6 +293,62 @@ contract CoinUniV4Test is BaseTest {
         assertApproxEqAbs(mockERC20A.balanceOf(coinV4.protocolRewardRecipient()), totalRewards.protocol, 10, "protocol reward currency");
     }
 
+    function test_distributesMarketRewardsInEth() public {
+        uint64 amountIn = 0.1 ether;
+
+        // Use address(0) as currency to price the coin in ETH
+        address currency = address(0);
+        bytes32 salt = keccak256(abi.encodePacked("eth-rewards-test"));
+        _deployV4Coin(currency, address(0), salt);
+
+        address trader = makeAddr("trader");
+
+        // Give trader ETH
+        vm.deal(trader, amountIn);
+
+        // Record initial ETH balance of payout recipient
+        uint256 initialPayoutBalance = coinV4.payoutRecipient().balance;
+
+        // Swap ETH for coin
+        _swapSomeCurrencyForCoin(coinV4, currency, amountIn, trader);
+
+        // Verify that rewards were paid out in ETH
+        assertGt(coinV4.payoutRecipient().balance, initialPayoutBalance, "backing reward should be paid in ETH");
+    }
+
+    function test_canSwapEthForCoin(uint128 amountIn) public {
+        vm.assume(amountIn > 0.00001 ether);
+        vm.assume(amountIn < 1 ether);
+
+        // Use address(0) as currency to price the coin in ETH
+        address currency = address(0);
+        bytes32 salt = keccak256(abi.encodePacked("eth-coin-test"));
+        _deployV4Coin(currency, address(0), salt);
+
+        address trader = makeAddr("trader");
+
+        // Give trader ETH
+        vm.deal(trader, amountIn);
+
+        uint256 initialEthBalance = trader.balance;
+
+        // Swap ETH for coin
+        _swapSomeCurrencyForCoin(coinV4, currency, amountIn, trader);
+
+        // Verify the swap worked
+        assertEq(trader.balance, initialEthBalance - amountIn, "trader should have spent ETH");
+        assertGt(coinV4.balanceOf(trader), 0, "trader should have received coin");
+
+        // Now swap some coin back for ETH
+        uint128 coinBalance = uint128(coinV4.balanceOf(trader));
+
+        _swapSomeCoinForCurrency(coinV4, currency, coinBalance, trader);
+
+        // Verify the reverse swap worked
+        assertEq(coinV4.balanceOf(trader), 0, "trader should have no coins left");
+        assertGt(trader.balance, 0, "trader should have received ETH back");
+    }
+
     function test_swap_emitsCoinMarketRewardsV4(uint64 amountIn) public {
         vm.assume(amountIn > 0.00001 ether);
         address currency = address(mockERC20A);

package/test/Factory.t.sol

@@ -29,6 +29,47 @@ contract FactoryTest is BaseTest {
         assertEq(ZoraFactoryImpl(address(factory)).owner(), initialOwner);
     }
 
+    function test_ownable2Step() public {
+        // old current impl
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
+
+        // 1st ensure owner slot is set at expected address
+
+        bytes32 ownableSlot = hex"9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300";
+        bytes32 ownable2StepSlot = hex"237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00";
+
+        address ownerAddress = address(uint160(uint256(vm.load(address(factory), ownableSlot))));
+        assertEq(ownerAddress, users.factoryOwner);
+
+        assertEq(ZoraFactoryImpl(address(factory)).pendingOwner(), address(0));
+
+        address newFactoryImpl = address(
+            new ZoraFactoryImpl(address(coinV3Impl), address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook))
+        );
+
+        // Upgrade to current / new impl
+        vm.prank(users.factoryOwner);
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(newFactoryImpl, "");
+
+        // 2nd ensure owner is read from correct slot
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
+
+        address newOwner = makeAddr("newOwner");
+
+        // 3rd ensure pending owner is set correctly
+        vm.prank(users.factoryOwner);
+        ZoraFactoryImpl(address(factory)).transferOwnership(newOwner);
+        assertEq(ZoraFactoryImpl(address(factory)).pendingOwner(), newOwner);
+
+        address ownerAddress2Step = address(uint160(uint256(vm.load(address(factory), ownable2StepSlot))));
+        assertEq(ownerAddress2Step, newOwner);
+
+        // 4th ensure owner is set correctly
+        vm.prank(newOwner);
+        ZoraFactoryImpl(address(factory)).acceptOwnership();
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), newOwner);
+    }
+
     function test_deploy_no_eth() public {
         address[] memory owners = new address[](1);
         owners[0] = users.creator;

package/test/Upgrades.t.sol

@@ -21,7 +21,7 @@ import {HooksDeployment} from "../src/libs/HooksDeployment.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
-import {CoinV4} from "../src/CoinV4.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
@@ -225,22 +225,22 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
     }
 
     function test_canUpgradeBrokenContentCoinAndSwap() public {
-        vm.createSelectFork("base", 31835069);
+        vm.createSelectFork("base", 32613149);
 
         address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+        address contentCoin = 0xB9799C839818bF50240CE683363D00c43a2E23b8;
 
         address creatorCoin = ICoinV4(contentCoin).currency();
 
-        address existingHook = 0xd3D133469ADC85e01A4887404D8AC12d630e9040;
-
-        uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
+        uint256 amountIn = 0.000111 ether;
 
         bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
+        address existingHook = address(ICoinV4(contentCoin).hooks());
+
         address[] memory baseImpls = new address[](1);
         baseImpls[0] = existingHook;
 
@@ -248,7 +248,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
         vm.prank(MultiOwnable(contentCoin).owners()[0]);
-        CoinV4(contentCoin).migrateLiquidity(address(newHook), "");
+        ContentCoin(contentCoin).migrateLiquidity(address(newHook), "");
 
         // do some swaps to test out
         _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
@@ -305,7 +305,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         uint160 beforePrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
 
         vm.prank(MultiOwnable(address(creatorCoin)).owners()[0]);
-        CoinV4(address(creatorCoin)).migrateLiquidity(address(newHook), "");
+        ContentCoin(address(creatorCoin)).migrateLiquidity(address(newHook), "");
 
         // get liquidity of original positions after migration
         uint128[] memory liquidityOfPositionsAfterMigration = getLiquidityForPositions(beforeKey, beforePositions);