@zoralabs/coins 0.4.0 → 0.5.1-sdkalpha.0

package/package/wagmiGenerated.ts

@@ -146,7 +146,10 @@ export const coinABI = [
       { name: 'tradeReferrer', internalType: 'address', type: 'address' },
     ],
     name: 'buy',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+    outputs: [
+      { name: '', internalType: 'uint256', type: 'uint256' },
+      { name: '', internalType: 'uint256', type: 'uint256' },
+    ],
     stateMutability: 'payable',
   },
   {
@@ -352,7 +355,10 @@ export const coinABI = [
       { name: 'tradeReferrer', internalType: 'address', type: 'address' },
     ],
     name: 'sell',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+    outputs: [
+      { name: '', internalType: 'uint256', type: 'uint256' },
+      { name: '', internalType: 'uint256', type: 'uint256' },
+    ],
     stateMutability: 'nonpayable',
   },
   {
@@ -948,10 +954,95 @@ export const coinABI = [
   { type: 'error', inputs: [], name: 'UseRevokeOwnershipToRemoveSelf' },
 ] as const
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// IUniswapV3Pool
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export const iUniswapV3PoolABI = [
+  {
+    type: 'function',
+    inputs: [],
+    name: 'feeGrowthGlobal0X128',
+    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'feeGrowthGlobal1X128',
+    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'slot0',
+    outputs: [
+      {
+        name: 'slot0',
+        internalType: 'struct IUniswapV3Pool.Slot0',
+        type: 'tuple',
+        components: [
+          { name: 'sqrtPriceX96', internalType: 'uint160', type: 'uint160' },
+          { name: 'tick', internalType: 'int24', type: 'int24' },
+          { name: 'observationIndex', internalType: 'uint16', type: 'uint16' },
+          {
+            name: 'observationCardinality',
+            internalType: 'uint16',
+            type: 'uint16',
+          },
+          {
+            name: 'observationCardinalityNext',
+            internalType: 'uint16',
+            type: 'uint16',
+          },
+          { name: 'feeProtocol', internalType: 'uint8', type: 'uint8' },
+          { name: 'unlocked', internalType: 'bool', type: 'bool' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    inputs: [
+      { name: 'recipient', internalType: 'address', type: 'address' },
+      { name: 'zeroForOne', internalType: 'bool', type: 'bool' },
+      { name: 'amountSpecified', internalType: 'int256', type: 'int256' },
+      { name: 'sqrtPriceLimitX96', internalType: 'uint160', type: 'uint160' },
+      { name: 'data', internalType: 'bytes', type: 'bytes' },
+    ],
+    name: 'swap',
+    outputs: [
+      { name: 'amount0', internalType: 'int256', type: 'int256' },
+      { name: 'amount1', internalType: 'int256', type: 'int256' },
+    ],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'token0',
+    outputs: [{ name: '', internalType: 'address', type: 'address' }],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'token1',
+    outputs: [{ name: '', internalType: 'address', type: 'address' }],
+    stateMutability: 'nonpayable',
+  },
+] as const
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // ZoraFactoryImpl
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+/**
+ * - [__View Contract on Base Basescan__](https://basescan.org/address/0x777777751622c0d3258f214F9DF38E35BF45baF3)
+ * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x777777751622c0d3258f214F9DF38E35BF45baF3)
+ */
 export const zoraFactoryImplABI = [
   {
     type: 'constructor',
@@ -1195,3 +1286,21 @@ export const zoraFactoryImplABI = [
     name: 'UUPSUnsupportedProxiableUUID',
   },
 ] as const
+
+/**
+ * - [__View Contract on Base Basescan__](https://basescan.org/address/0x777777751622c0d3258f214F9DF38E35BF45baF3)
+ * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x777777751622c0d3258f214F9DF38E35BF45baF3)
+ */
+export const zoraFactoryImplAddress = {
+  8453: '0x777777751622c0d3258f214F9DF38E35BF45baF3',
+  84532: '0x777777751622c0d3258f214F9DF38E35BF45baF3',
+} as const
+
+/**
+ * - [__View Contract on Base Basescan__](https://basescan.org/address/0x777777751622c0d3258f214F9DF38E35BF45baF3)
+ * - [__View Contract on Base Sepolia Basescan__](https://sepolia.basescan.org/address/0x777777751622c0d3258f214F9DF38E35BF45baF3)
+ */
+export const zoraFactoryImplConfig = {
+  address: zoraFactoryImplAddress,
+  abi: zoraFactoryImplABI,
+} as const

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "0.4.0",
+  "version": "0.5.1-sdkalpha.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -25,13 +25,14 @@
     "forge-std": "https://github.com/foundry-rs/forge-std#v1.9.1",
     "prettier": "^3.0.3",
     "prettier-plugin-solidity": "^1.4.1",
+    "solady": "0.0.132",
     "tsup": "^7.2.0",
     "tsx": "^3.13.0",
     "typescript": "^5.2.2",
     "viem": "^2.21.18",
-    "@zoralabs/shared-contracts": "^0.0.1",
+    "@zoralabs/tsconfig": "^0.0.1",
     "@zoralabs/shared-scripts": "^0.0.0",
-    "@zoralabs/tsconfig": "^0.0.1"
+    "@zoralabs/shared-contracts": "^0.0.1"
   },
   "scripts": {
     "build": "pnpm run wagmi:generate && pnpm run copy-abis && pnpm run prettier:write && tsup",

package/remappings.txt

@@ -1,4 +1,5 @@
 ds-test/=node_modules/ds-test/src/
 forge-std/=node_modules/forge-std/src/
 @openzeppelin/=node_modules/@openzeppelin/
-@zoralabs/shared-contracts/=node_modules/@zoralabs/shared-contracts/src/
+@zoralabs/shared-contracts/=node_modules/@zoralabs/shared-contracts/src/
+solady/=node_modules/solady/src/ 

package/script/CoinsDeployerBase.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import "forge-std/Script.sol";
+
+import {ProxyDeployerScript, DeterministicContractConfig, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+import {Coin} from "../src/Coin.sol";
+import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
+
+contract CoinsDeployerBase is ProxyDeployerScript {
+    address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+
+    using stdJson for string;
+
+    struct CoinsDeployment {
+        // Factory
+        address zoraFactory;
+        address zoraFactoryImpl;
+        // Implementation
+        address coinImpl;
+        string coinVersion;
+    }
+
+    function addressesFile() internal view returns (string memory) {
+        return string.concat("./addresses/", vm.toString(block.chainid), ".json");
+    }
+
+    function saveDeployment(CoinsDeployment memory deployment) internal {
+        string memory objectKey = "config";
+
+        vm.serializeAddress(objectKey, "ZORA_FACTORY", deployment.zoraFactory);
+        vm.serializeAddress(objectKey, "ZORA_FACTORY_IMPL", deployment.zoraFactoryImpl);
+        vm.serializeString(objectKey, "COIN_VERSION", deployment.coinVersion);
+        string memory result = vm.serializeAddress(objectKey, "COIN_IMPL", deployment.coinImpl);
+
+        vm.writeJson(result, addressesFile());
+    }
+
+    function readDeployment() internal returns (CoinsDeployment memory deployment) {
+        string memory file = addressesFile();
+        if (!vm.exists(file)) {
+            return deployment;
+        }
+        string memory json = vm.readFile(file);
+
+        deployment.zoraFactory = readAddressOrDefaultToZero(json, "ZORA_FACTORY");
+        deployment.zoraFactoryImpl = readAddressOrDefaultToZero(json, "ZORA_FACTORY_IMPL");
+        deployment.coinImpl = readAddressOrDefaultToZero(json, "COIN_IMPL");
+        deployment.coinVersion = readStringOrDefaultToEmpty(json, "COIN_VERSION");
+    }
+
+    function deployCoinImpl() internal returns (Coin) {
+        return new Coin(getZoraRecipient(), PROTOCOL_REWARDS, getWeth(), getNonFungiblePositionManager(), getUniswapSwapRouter());
+    }
+
+    function deployZoraFactoryImpl(address coinImpl) internal returns (ZoraFactoryImpl) {
+        return new ZoraFactoryImpl(coinImpl);
+    }
+
+    function deployZoraDeterministic(CoinsDeployment memory deployment, DeterministicDeployerAndCaller deployer) internal {
+        // read previously saved deterministic config
+        DeterministicContractConfig memory zoraConfig = readDeterministicContractConfig("zoraFactory");
+
+        // Deploy implementation contracts
+        deployment.coinImpl = address(deployCoinImpl());
+        deployment.zoraFactoryImpl = address(deployZoraFactoryImpl(deployment.coinImpl));
+        deployment.coinVersion = IVersionedContract(deployment.coinImpl).contractVersion();
+
+        if (deployment.zoraFactoryImpl.code.length == 0) {
+            revert("Factory Impl not yet deployed. Make sure to deploy it with DeployImpl.s.sol");
+        }
+
+        // build upgrade to and call for factory, with init call
+        bytes memory upgradeToAndCall = abi.encodeWithSelector(
+            UUPSUpgradeable.upgradeToAndCall.selector,
+            deployment.zoraFactoryImpl,
+            abi.encodeWithSelector(ZoraFactoryImpl.initialize.selector, getProxyAdmin())
+        );
+
+        // sign deployment with turnkey account
+        bytes memory signature = signDeploymentWithTurnkey(zoraConfig, upgradeToAndCall, deployer);
+
+        printVerificationCommand(zoraConfig);
+
+        deployment.zoraFactory = deployer.permitSafeCreate2AndCall(
+            signature,
+            zoraConfig.salt,
+            zoraConfig.creationCode,
+            upgradeToAndCall,
+            zoraConfig.deployedAddress
+        );
+
+        // validate that the zora factory owner is the proxy admin
+        require(ZoraFactoryImpl(deployment.zoraFactory).owner() == getProxyAdmin(), "Zora factory owner is not the proxy admin");
+    }
+}

package/script/Deploy.s.sol

@@ -1,14 +1,23 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.13;
+pragma solidity ^0.8.28;
 
-import {Script, console} from "forge-std/Script.sol";
-
-contract Deploy is Script {
-    function setUp() public {}
+import {ProxyDeployerScript, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
 
+contract DeployScript is CoinsDeployerBase {
     function run() public {
+        CoinsDeployment memory deployment = readDeployment();
+
         vm.startBroadcast();
 
+        // get deployer contract
+        DeterministicDeployerAndCaller deployer = createOrGetDeployerAndCaller();
+
+        deployZoraDeterministic(deployment, deployer);
+
         vm.stopBroadcast();
+
+        // save the deployment json
+        saveDeployment(deployment);
     }
 }

package/script/GenerateDeterministicParams.s.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import "forge-std/Script.sol";
+
+import {ImmutableCreate2FactoryUtils} from "@zoralabs/shared-contracts/utils/ImmutableCreate2FactoryUtils.sol";
+import {ProxyDeployerScript, DeterministicDeployerAndCaller, DeterministicContractConfig} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {ZoraFactory} from "../src/proxy/ZoraFactory.sol";
+
+contract GenerateDeterministicParams is ProxyDeployerScript {
+    function mineForZoraAddress(DeterministicDeployerAndCaller deployer, address caller) private returns (DeterministicContractConfig memory config) {
+        // get proxy creation code
+        bytes memory initCode = deployer.proxyCreationCode(type(ZoraFactory).creationCode);
+        bytes32 initCodeHash = keccak256(initCode);
+
+        // uupsProxyDeployer is deployer
+        (bytes32 salt, address expectedAddress) = mineSalt(address(deployer), initCodeHash, "7777777", caller);
+
+        console2.log("salt");
+        console2.log(vm.toString(salt));
+
+        config.salt = salt;
+        config.deployedAddress = expectedAddress;
+        config.creationCode = initCode;
+        config.constructorArgs = deployer.proxyConstructorArgs();
+        config.contractName = "Zora";
+        config.deploymentCaller = caller;
+    }
+
+    function run() public {
+        address caller = vm.envAddress("DEPLOYER");
+
+        vm.startBroadcast();
+
+        // create a proxy deployer, which we can use to generate deterministic addresses and corresponding params
+        DeterministicDeployerAndCaller deployer = createOrGetDeployerAndCaller();
+
+        vm.stopBroadcast();
+
+        DeterministicContractConfig memory zoraConfig = mineForZoraAddress(deployer, caller);
+        saveDeterministicContractConfig(zoraConfig, "zoraFactory");
+    }
+}

package/src/Coin.sol

@@ -138,7 +138,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
-    ) public payable nonReentrant returns (uint256) {
+    ) public payable nonReentrant returns (uint256, uint256) {
         // Ensure the recipient is not the zero address
         if (recipient == address(0)) {
             revert AddressZero();
@@ -173,7 +173,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
 
         emit CoinBuy(msg.sender, recipient, tradeReferrer, amountOut, currency, tradeReward, trueOrderSize);
 
-        return amountOut;
+        return (orderSize, amountOut);
     }
 
     /// @notice Executes a sell order
@@ -188,12 +188,15 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
-    ) public nonReentrant returns (uint256) {
+    ) public nonReentrant returns (uint256, uint256) {
         // Ensure the recipient is not the zero address
         if (recipient == address(0)) {
             revert AddressZero();
         }
 
+        // Record the coin balance of this contract before the swap
+        uint256 beforeCoinBalance = balanceOf(address(this));
+
         // Transfer the coins from the seller to this contract
         transfer(address(this), orderSize);
 
@@ -214,6 +217,21 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         // Execute the swap
         uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
 
+        // Record the coin balance of this contract after the swap
+        uint256 afterCoinBalance = balanceOf(address(this));
+
+        // If the swap was partially executed:
+        if (afterCoinBalance > beforeCoinBalance) {
+            // Calculate the refund
+            uint256 coinRefund = afterCoinBalance - beforeCoinBalance;
+
+            // Update the order size
+            orderSize -= coinRefund;
+
+            // Transfer the refund back to the seller
+            _transfer(address(this), recipient, coinRefund);
+        }
+
         // If currency is WETH, convert to ETH
         if (currency == WETH) {
             IWETH(WETH).withdraw(amountOut);
@@ -225,7 +243,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         // Calculate the payout after the fee
         uint256 payoutSize = amountOut - tradeReward;
 
-        _handleSellPayout(payoutSize, recipient);
+        _handlePayout(payoutSize, recipient);
 
         _handleTradeRewards(tradeReward, tradeReferrer);
 
@@ -233,7 +251,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
 
         emit CoinSell(msg.sender, recipient, tradeReferrer, orderSize, currency, tradeReward, payoutSize);
 
-        return amountOut;
+        return (orderSize, payoutSize);
     }
 
     /// @notice Enables a user to burn their tokens
@@ -415,10 +433,10 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         }
     }
 
-    /// @dev Handles sending ETH and ERC20 payouts from sell orders to recipients
+    /// @dev Handles sending ETH and ERC20 payouts and refunds to recipients
     /// @param orderPayout The amount of currency to pay out
     /// @param recipient The address to receive the payout
-    function _handleSellPayout(uint256 orderPayout, address recipient) internal {
+    function _handlePayout(uint256 orderPayout, address recipient) internal {
         if (currency == WETH) {
             Address.sendValue(payable(recipient), orderPayout);
         } else {

package/src/ZoraFactoryImpl.sol

@@ -102,9 +102,9 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
 
                 IERC20(currency).approve(address(coin), orderSize);
 
-                coinsPurchased = coin.buy(payoutRecipient, orderSize, 0, 0, address(0));
+                (, coinsPurchased) = coin.buy(payoutRecipient, orderSize, 0, 0, address(0));
             } else {
-                coinsPurchased = coin.buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
+                (, coinsPurchased) = coin.buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
             }
         }
     }

package/src/interfaces/ICoin.sol

@@ -172,7 +172,7 @@ interface ICoin is IERC165, IERC721Receiver, IERC7572 {
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
-    ) external payable returns (uint256);
+    ) external payable returns (uint256, uint256);
 
     /// @notice Executes a sell order
     /// @param recipient The recipient of the currency
@@ -180,7 +180,13 @@ interface ICoin is IERC165, IERC721Receiver, IERC7572 {
     /// @param minAmountOut The minimum amount of currency to receive
     /// @param sqrtPriceLimitX96 The price limit for the swap
     /// @param tradeReferrer The address of the trade referrer
-    function sell(address recipient, uint256 orderSize, uint256 minAmountOut, uint160 sqrtPriceLimitX96, address tradeReferrer) external returns (uint256);
+    function sell(
+        address recipient,
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address tradeReferrer
+    ) external returns (uint256, uint256);
 
     /// @notice Enables a user to burn their tokens
     /// @param amount The amount of tokens to burn

package/src/proxy/ZoraFactory.sol

@@ -22,5 +22,11 @@ import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.s
                OURS TRULY,
 */
 contract ZoraFactory is ERC1967Proxy {
-    constructor(address _logic, bytes memory _data) ERC1967Proxy(_logic, _data) {}
+    bytes32 internal immutable name;
+
+    constructor(address _logic) ERC1967Proxy(_logic, "") {
+        // added to create unique bytecode for this contract
+        // so that it can be properly verified as its own contract.
+        name = keccak256("ZoraFactory");
+    }
 }

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 "0.4.0";
+        return "0.5.0";
     }
 }