use delegate cash

Author: jake-nyquist

integration/integration.test.ts

@@ -3618,5 +3618,246 @@ describe("VolBidPool", function () {
           BigNumber.from(optionTokenId)
         );
     });
+
+    it("works with property-validator encoded orders", async function () {
+      const blockNumber = await ethers.provider.getBlockNumber();
+      const block = await ethers.provider.getBlock(blockNumber);
+      const blockTimestamp = block.timestamp;
+      const expiration = Math.floor(blockTimestamp + SECS_IN_A_DAY * 5);
+
+      // Mint call option
+      const createCall = await calls
+        .connect(writer)
+        .mintWithErc721(token.address, 0, 1000, expiration);
+      const cc = await createCall.wait();
+
+      const callCreatedEvent = cc.events.find(
+        (event: any) => event?.event === "CallCreated"
+      );
+
+      const optionTokenId = callCreatedEvent.args.optionId;
+
+      const validatorFactory = await ethers.getContractFactory(
+        "PropertyValidator1"
+      );
+
+      const validator = await validatorFactory.deploy();
+
+      const volOrder = {
+        direction: OrderDirection.BUY,
+        maker: buyer.address,
+        orderExpiry: Math.floor(blockTimestamp + 40).toString(),
+        nonce: "1405",
+        size: "1",
+        optionType: OptionType.CALL,
+        maxStrikePriceMultiple: "0",
+        minOptionDuration: (SECS_IN_A_DAY * 0.5).toString(),
+        maxOptionDuration: (SECS_IN_A_DAY * 80).toString(),
+        maxPriceSignalAge: "0",
+        optionMarketAddress: calls.address,
+        impliedVolBips: "5000",
+        nftProperties: [
+          {
+            propertyValidator: validator.address,
+            propertyData: ethers.utils.defaultAbiCoder.encode(
+              [
+                "uint256",
+                "uint8",
+                "uint256",
+                "uint8",
+                "bool",
+                "uint256",
+                "uint256",
+              ],
+              [0, 0, 0, 0, false, 0, 0]
+            ),
+          },
+        ],
+        skewDecimal: "0",
+        riskFreeRateBips: "500",
+      };
+
+      const signedOrder = await signVolOrder(volOrder, buyer, protocol.address);
+
+      const { types, domain, value } = genVolOrderTypedData(
+        volOrder,
+        protocol.address
+      );
+
+      const orderHash = _TypedDataEncoder.hash(domain, types, value);
+
+      const orderValiditySignature = await admin.signMessage(
+        ethers.utils.arrayify(
+          ethers.utils.solidityKeccak256(
+            ["bytes32", "uint256"],
+            [orderHash, expiration]
+          )
+        )
+      );
+
+      const { v, r, s } = ethers.utils.splitSignature(orderValiditySignature);
+
+      const orderValidityClaim = {
+        orderHash: orderHash,
+        goodTilTimestamp: expiration,
+        v,
+        r,
+        s,
+      };
+
+      const {
+        v: v2,
+        r: r2,
+        s: s2,
+      } = ethers.utils.splitSignature(
+        await admin.signMessage(
+          ethers.utils.arrayify(
+            ethers.utils.solidityKeccak256(
+              ["uint256", "uint256", "uint256"],
+              ["900", Math.floor(blockTimestamp - 10).toString(), expiration]
+            )
+          )
+        )
+      );
+
+      const assetPriceClaim = {
+        assetPriceInWei: "900",
+        priceObservedTimestamp: Math.floor(blockTimestamp - 10).toString(),
+        goodTilTimestamp: expiration,
+        v: v2,
+        r: r2,
+        s: s2,
+      };
+
+      calls.connect(writer).setApprovalForAll(bidPool.address, true);
+      weth.connect(buyer).deposit({ value: 1000 });
+      weth.connect(buyer).approve(bidPool.address, 1000);
+      bidPool
+        .connect(writer)
+        .sellOption(
+          volOrder,
+          signedOrder,
+          assetPriceClaim,
+          orderValidityClaim,
+          BigNumber.from("14"),
+          calls.address,
+          BigNumber.from(optionTokenId)
+        );
+    });
+
+    it("works with property-validator empty validator", async function () {
+      const blockNumber = await ethers.provider.getBlockNumber();
+      const block = await ethers.provider.getBlock(blockNumber);
+      const blockTimestamp = block.timestamp;
+      const expiration = Math.floor(blockTimestamp + SECS_IN_A_DAY * 5);
+
+      // Mint call option
+      const createCall = await calls
+        .connect(writer)
+        .mintWithErc721(token.address, 0, 1000, expiration);
+      const cc = await createCall.wait();
+
+      const callCreatedEvent = cc.events.find(
+        (event: any) => event?.event === "CallCreated"
+      );
+
+      const optionTokenId = callCreatedEvent.args.optionId;
+
+      const validatorFactory = await ethers.getContractFactory(
+        "PropertyValidator1"
+      );
+
+      const validator = await validatorFactory.deploy();
+
+      const volOrder = {
+        direction: OrderDirection.BUY,
+        maker: buyer.address,
+        orderExpiry: Math.floor(blockTimestamp + 40).toString(),
+        nonce: "1405",
+        size: "1",
+        optionType: OptionType.CALL,
+        maxStrikePriceMultiple: "0",
+        minOptionDuration: (SECS_IN_A_DAY * 0.5).toString(),
+        maxOptionDuration: (SECS_IN_A_DAY * 80).toString(),
+        maxPriceSignalAge: "0",
+        optionMarketAddress: calls.address,
+        impliedVolBips: "5000",
+        nftProperties: [
+          {
+            propertyValidator: "0x0000000000000000000000000000000000000000",
+            propertyData: [],
+          },
+        ],
+        skewDecimal: "0",
+        riskFreeRateBips: "500",
+      };
+
+      const signedOrder = await signVolOrder(volOrder, buyer, protocol.address);
+
+      const { types, domain, value } = genVolOrderTypedData(
+        volOrder,
+        protocol.address
+      );
+
+      const orderHash = _TypedDataEncoder.hash(domain, types, value);
+
+      const orderValiditySignature = await admin.signMessage(
+        ethers.utils.arrayify(
+          ethers.utils.solidityKeccak256(
+            ["bytes32", "uint256"],
+            [orderHash, expiration]
+          )
+        )
+      );
+
+      const { v, r, s } = ethers.utils.splitSignature(orderValiditySignature);
+
+      const orderValidityClaim = {
+        orderHash: orderHash,
+        goodTilTimestamp: expiration,
+        v,
+        r,
+        s,
+      };
+
+      const {
+        v: v2,
+        r: r2,
+        s: s2,
+      } = ethers.utils.splitSignature(
+        await admin.signMessage(
+          ethers.utils.arrayify(
+            ethers.utils.solidityKeccak256(
+              ["uint256", "uint256", "uint256"],
+              ["900", Math.floor(blockTimestamp - 10).toString(), expiration]
+            )
+          )
+        )
+      );
+
+      const assetPriceClaim = {
+        assetPriceInWei: "900",
+        priceObservedTimestamp: Math.floor(blockTimestamp - 10).toString(),
+        goodTilTimestamp: expiration,
+        v: v2,
+        r: r2,
+        s: s2,
+      };
+
+      calls.connect(writer).setApprovalForAll(bidPool.address, true);
+      weth.connect(buyer).deposit({ value: 1000 });
+      weth.connect(buyer).approve(bidPool.address, 1000);
+      bidPool
+        .connect(writer)
+        .sellOption(
+          volOrder,
+          signedOrder,
+          assetPriceClaim,
+          orderValidityClaim,
+          BigNumber.from("14"),
+          calls.address,
+          BigNumber.from(optionTokenId)
+        );
+    });
   });
 });

src/HookBidPool.sol

@@ -49,6 +49,8 @@ import "./mixin/EIP712.sol";
 import "./interfaces/IHookProtocol.sol";
 import "./interfaces/IHookOption.sol";
 
+import "./interfaces/delegate-cash/IDelegationRegistry.sol";
+
 /// @notice HookBidPools allows users to make off-chain orders in terms of an implied volatility which
 /// can later be filled by an option seller. The price of the sell will be computed using the Black-Scholes
 /// model at bid time.
@@ -58,7 +60,7 @@ import "./interfaces/IHookOption.sol";
 ///
 /// In order for an order to be filled, it must be signed by the maker and the maker must have enough balance
 /// to provide the order proceeds and relevant fees. The maximum bid the order maker has offered is computed
-/// using the volatiliy and risk-free rate signed into the order. This information is combined with the NFT
+/// using the volatility and risk-free rate signed into the order. This information is combined with the NFT
 /// floor price provided by the off-chain oracle to compute the maximum bid price.
 /// If the amount of consideration requested by the seller + the protocol fees is less than the maximum bid,
 /// the order can then be filled. The seller will receive their requested proceeds, the protocol will receive
@@ -181,6 +183,9 @@ contract HookBidPool is EIP712, ReentrancyGuard, AccessControl {
     // 1% = 0.01, 100 bips = 1%, 10000 bps = 100% == 1
     uint256 constant BPS_TO_DECIMAL = 10e14;
 
+    /// https://github.com/delegatecash/delegation-registry
+    IDelegationRegistry constant DELEGATE_CASH_REGISTRY = IDelegationRegistry(0x00000000000076A84feF008CDAbe6409d2FE638B);
+
     /// ROLE CONSTANTS ///
 
     /// @notice the role that can pause the contract - should be held by a mulitsig
@@ -418,7 +423,9 @@ contract HookBidPool is EIP712, ReentrancyGuard, AccessControl {
         require(claim.goodTilTimestamp > block.timestamp, "Claim is expired");
     }
 
-    /// @notice validates the EIP-712 signature for the order
+    /// @notice validates the EIP-712 signature for the order. If the order maker has 
+    /// delegated rights for this contract to a different signer, then orders signed by
+    /// that signer are also be considered valid.
     ///
     /// @param hash the EIP-721 hash of the order struct
     /// @param maker the maker of the order, who should have signed the order
@@ -430,7 +437,13 @@ contract HookBidPool is EIP712, ReentrancyGuard, AccessControl {
     {
         address signer = ecrecover(hash, orderSignature.v, orderSignature.r, orderSignature.s);
         require(signer != address(0), "Order signature is invalid"); // sanity check - maker should not be 0
-        require(signer == maker, "Order signature is invalid");
+        if (signer == maker) {
+            // if the order maker signed the order, than accept the signer's signature
+            return;
+        }
+        // If the maker has delegated control of this contract to a different signer,
+        // then accept this signed order as a valid signature.
+        require(DELEGATE_CASH_REGISTRY.checkDelegateForContract(signer, maker, address(this)), "Order signature is invalid");
     }
 
     /// @dev modifies the supplied base implied volatility to account for skew.