add eip 1271 support to v4 (#98)

* add eip 1271 support to v4
* fix: comment out ropsten tests until migrated to goerli. adds contract wallet classifier tests

Co-authored-by: John Johnson <johnrjj@gmail.com>

Author: arilotter

README.md

@@ -30,7 +30,7 @@ or npm:
 
 `npm install @traderxyz/nft-swap-sdk`
 
-You can check out an example project [here](https://nft-swapping-demo.vercel.app/) 
+You can check out an example project [here](https://nft-swapping-demo.vercel.app/)
 or check out the example repo [here](https://github.com/HaidarEzio/NFTswap/tree/example-project)
 
 ## Configuration

src/sdk/v4/NftSwapV4.ts

@@ -23,6 +23,7 @@ import type {
 import { UnexpectedAssetTypeError } from '../error';
 import {
   approveAsset,
+  checkIfContractWallet,
   DEFAULT_APP_ID,
   generateErc1155Order,
   generateErc721Order,
@@ -34,6 +35,7 @@ import {
 import type {
   AddressesForChainV4,
   ApprovalOverrides,
+  AvailableSignatureTypesV4,
   ERC721OrderStruct,
   FillOrderOverrides,
   NftOrderV4,
@@ -97,8 +99,6 @@ export const SupportedChainsForV4OrderbookStatusMonitoring = [
 export interface INftSwapV4 extends BaseNftSwap {
   signOrder: (
     order: NftOrderV4,
-    signerAddress: string,
-    signer: Signer,
     signingOptions?: Partial<SigningOptionsV4>
   ) => Promise<SignedNftOrderV4>;
   buildNftAndErc20Order: (
@@ -601,32 +601,85 @@ class NftSwapV4 implements INftSwapV4 {
    * Once signed, the order becomes fillable (as long as the order is valid)
    * 0x orders require a signature to fill.
    * @param order A 0x v4 order
+   * @param signingOptions Options for signing
    * @returns A signed 0x v4 order
    */
-  signOrder = async (order: NftOrderV4): Promise<SignedNftOrderV4> => {
+  signOrder = async (
+    order: NftOrderV4,
+    signingOptions?: Partial<SigningOptionsV4>
+  ): Promise<SignedNftOrderV4> => {
     if (!this.signer) {
-      throw new Error('Signed not defined');
+      throw new Error('Signer not defined');
     }
 
-    const rawSignature = await signOrderWithEoaWallet(
-      order,
-      this.signer as unknown as TypedDataSigner,
-      this.chainId,
-      this.exchangeProxy.address
-    );
+    let method: AvailableSignatureTypesV4 = 'eoa';
+    // If we have any specific signature type overrides, prefer those
+    if (signingOptions?.signatureType === 'eip1271') {
+      method = 'eip1271';
+    } else if (signingOptions?.signatureType === 'eoa') {
+      method = 'eoa';
+    } else {
+      // Try to detect...
+      if (signingOptions?.autodetectSignatureType === false) {
+        method = 'eoa';
+      } else {
+        // If we made it here, consumer has no preferred signing method,
+        // let's try feature detection to automagically pick a signature type
+        // By default we fallback to EOA signing if we can't figure it out.
 
-    const ecSignature = parseRawSignature(rawSignature);
+        // Let's try to determine if the signer is a contract wallet or not.
+        // If it is, we'll try EIP-1271, otherwise we'll do a normal sign
+        const signerAddress = await this.signer.getAddress();
 
-    const signedOrder = {
-      ...order,
-      signature: {
-        signatureType: 2,
-        r: ecSignature.r,
-        s: ecSignature.s,
-        v: ecSignature.v,
-      },
-    };
-    return signedOrder;
+        const isContractWallet = await checkIfContractWallet(
+          this.provider,
+          signerAddress
+        );
+        if (isContractWallet) {
+          method = 'eip1271';
+        } else {
+          method = 'eoa';
+        }
+      }
+    }
+    switch (method) {
+      case 'eoa': {
+        const rawSignature = await signOrderWithEoaWallet(
+          order,
+          this.signer as unknown as TypedDataSigner,
+          this.chainId,
+          this.exchangeProxy.address
+        );
+
+        const ecSignature = parseRawSignature(rawSignature);
+
+        const signedOrder = {
+          ...order,
+          signature: {
+            signatureType: 2,
+            r: ecSignature.r,
+            s: ecSignature.s,
+            v: ecSignature.v,
+          },
+        };
+        return signedOrder;
+      }
+      case 'eip1271': {
+        await this.preSignOrder(order);
+        const preSignedOrder = {
+          ...order,
+          signature: {
+            signatureType: 4,
+            r: '0',
+            s: '0',
+            v: 0,
+          },
+        };
+        return preSignedOrder;
+      }
+      default:
+        throw new Error(`Unknown signature method chosen: ${method}`);
+    }
   };
 
   /**
@@ -862,6 +915,69 @@ class NftSwapV4 implements INftSwapV4 {
     console.log('unsupported order', signedOrder);
     throw new Error('unsupport signedOrder type');
   };
+  /**
+   * Pre-signs and submits an order
+   * @param signedOrder An unsigned 0x v4 order
+   * @param fillOrderOverrides Optional configuration on possible ways to fill the order
+   * @param transactionOverrides Ethers transaction overrides (e.g. gas price)
+   * @returns
+   */
+  preSignOrder = async (
+    order: NftOrderV4,
+    fillOrderOverrides?: Partial<FillOrderOverrides>,
+    transactionOverrides?: Partial<PayableOverrides>
+  ) => {
+    // Only Sell orders can be filled with ETH
+    const canOrderTypeBeFilledWithNativeToken =
+      order.direction === TradeDirection.SellNFT;
+    // Is ERC20 being traded the native token
+    const isNativeToken = this.isErc20NativeToken(order);
+    const needsEthAttached =
+      isNativeToken && canOrderTypeBeFilledWithNativeToken;
+    if (needsEthAttached) {
+      console.log(
+        "can't pre-sign orders that need to be filled with ETH",
+        order
+      );
+      throw new Error("can't pre-sign orders that need to be filled with ETH");
+    }
+    // do fill
+    if ('erc1155Token' in order) {
+      // If maker is selling an NFT, taker wants to 'buy' nft
+      if (
+        order.direction === TradeDirection.BuyNFT &&
+        order.erc1155TokenProperties.length > 0 &&
+        fillOrderOverrides?.tokenIdToSellForCollectionOrder === undefined
+      ) {
+        // property based order, let's make sure they've specifically provided a tokenIdToSellForCollectionOrder
+        throw new Error(
+          'Collection order missing NFT tokenId to fill with. Specify in fillOrderOverrides.tokenIdToSellForCollectionOrder'
+        );
+      }
+
+      return this.exchangeProxy.preSignERC1155Order(order, {
+        ...transactionOverrides,
+      });
+    } else if ('erc721Token' in order) {
+      // If maker is selling an NFT, taker wants to 'buy' nft
+      if (
+        order.direction === TradeDirection.BuyNFT &&
+        order.erc721TokenProperties.length > 0 &&
+        fillOrderOverrides?.tokenIdToSellForCollectionOrder === undefined
+      ) {
+        // property based order, let's make sure they've specifically provided a tokenIdToSellForCollectionOrder
+        throw new Error(
+          'Collection order missing NFT tokenId to fill with. Specify in fillOrderOverrides.tokenIdToSellForCollectionOrder'
+        );
+      }
+      // Otherwise, taker is selling the nft (and buying an ERC20)
+      return this.exchangeProxy.preSignERC721Order(order, {
+        ...transactionOverrides,
+      });
+    }
+    console.log('unsupported order', order);
+    throw new Error('unsupport signedOrder type');
+  };
 
   /**
    * Posts a 0x order to the Trader.xyz NFT open orderbook

src/sdk/v4/pure.ts

@@ -1,7 +1,7 @@
 import { Signer, TypedDataSigner } from '@ethersproject/abstract-signer';
 import { BigNumber } from '@ethersproject/bignumber';
 import { hexDataLength, hexDataSlice } from '@ethersproject/bytes';
-import type { BaseProvider } from '@ethersproject/providers';
+import type { BaseProvider, Provider } from '@ethersproject/providers';
 import type { ContractTransaction } from '@ethersproject/contracts';
 import getUnixTime from 'date-fns/getUnixTime';
 import { v4 } from 'uuid';
@@ -100,6 +100,93 @@ export const signOrderWithEoaWallet = async (
   throw new Error(`Unknown order type`);
 };
 
+export const preSignOrder = async (
+  order: NftOrderV4,
+  signer: TypedDataSigner,
+  chainId: number,
+  exchangeContractAddress: string
+) => {
+  if ((order as ERC1155OrderStruct).erc1155Token) {
+    const domain = {
+      chainId: chainId,
+      verifyingContract: exchangeContractAddress,
+      name: 'ZeroEx',
+      version: '1.0.0',
+    };
+    const types = {
+      [ERC1155ORDER_STRUCT_NAME]: ERC1155ORDER_STRUCT_ABI,
+      Fee: FEE_ABI,
+      Property: PROPERTY_ABI,
+    };
+    const value = order;
+
+    const rawSignatureFromEoaWallet = await signer._signTypedData(
+      domain,
+      types,
+      value
+    );
+
+    return rawSignatureFromEoaWallet;
+  }
+
+  if ((order as ERC721OrderStruct).erc721Token) {
+    const domain = {
+      chainId: chainId,
+      verifyingContract: exchangeContractAddress,
+      name: 'ZeroEx',
+      version: '1.0.0',
+    };
+    const types = {
+      [ERC721ORDER_STRUCT_NAME]: ERC721ORDER_STRUCT_ABI,
+      Fee: FEE_ABI,
+      Property: PROPERTY_ABI,
+    };
+    const value = order;
+
+    const rawSignatureFromEoaWallet = await signer._signTypedData(
+      domain,
+      types,
+      value
+    );
+
+    return rawSignatureFromEoaWallet;
+  }
+
+  warning(!order, 'Unknown order type');
+  throw new Error(`Unknown order type`);
+};
+
+export const checkIfContractWallet = async (
+  provider: Provider,
+  walletAddress: string
+): Promise<boolean> => {
+  let isContractWallet: boolean = false;
+  if (provider.getCode) {
+    let walletCode = await provider.getCode(walletAddress);
+    // Wallet Code returns '0x' if no contract address is associated with
+    // Note: Lazy loaded contract wallets will show 0x initially, so we fall back to feature detection
+    if (walletCode && walletCode !== '0x') {
+      isContractWallet = true;
+    }
+  }
+  let isSequence = !!(provider as any)._isSequenceProvider;
+  if (isSequence) {
+    isContractWallet = true;
+  }
+  // Walletconnect hides the real provider in the provider (yo dawg)
+  let providerToUse = (provider as any).provider;
+  if (providerToUse?.isWalletConnect) {
+    const isSequenceViaWalletConnect = !!(
+      (providerToUse as any).connector?._peerMeta?.description === 'Sequence'
+    );
+    if (isSequenceViaWalletConnect) {
+      isContractWallet = true;
+    }
+  }
+
+  return isContractWallet;
+};
+
 /**
  *
  * @param walletAddress Owner of the asset

src/sdk/v4/types.ts

@@ -167,14 +167,14 @@ export type ECSignature = {
 };
 
 export type SignatureStruct = {
-  signatureType: number; // 2 for EIP-712
+  signatureType: number; // 2 for EIP-712, 4 for PRESIGNED
   v: number;
   r: string;
   s: string;
 };
 
 export type SignatureStructSerialized = {
-  signatureType: number; // 2 for EIP-712
+  signatureType: number; // 2 for EIP-712, 4 for PRESIGNED
   v: number;
   r: string;
   s: string;
@@ -207,7 +207,7 @@ export interface BuildOrderAdditionalConfig {
   nonce: BigNumberish;
 }
 
-export type AvailableSignatureTypesV4 = 'eoa'; // No EIP-1271 / preSign yet (soon though)
+export type AvailableSignatureTypesV4 = 'eoa' | 'eip1271';
 
 export interface SigningOptionsV4 {
   signatureType: AvailableSignatureTypesV4; // | 'autodetect' ? and remove autodetectSignatureType maybe?

test/v3/swap.test.ts

@@ -47,7 +47,7 @@ const MAKER_ASSET: SwappableAsset = {
 };
 
 describe('NFTSwap', () => {
-  it('swaps 0.1 DAI and 0.1 USDC correctly', async () => {
+  xit('swaps 0.1 DAI and 0.1 USDC correctly', async () => {
     // NOTE(johnrjj) - Assumes USDC and DAI are already approved w/ the ExchangeProxy
 
     const gasPrice = (await PROVIDER.getGasPrice()).mul(2);

test/v4/erc1155-test-swap.test.ts

@@ -20,12 +20,14 @@ const RPC_TESTNET =
 
 const MAKER_WALLET = new ethers.Wallet(MAKER_PRIVATE_KEY);
 
-const PROVIDER = new ethers.providers.StaticJsonRpcProvider(RPC_TESTNET);
+const ROPSTEN_CHAIN_ID = 3;
+const PROVIDER = new ethers.providers.StaticJsonRpcProvider(
+  RPC_TESTNET,
+  ROPSTEN_CHAIN_ID
+);
 
 const MAKER_SIGNER = MAKER_WALLET.connect(PROVIDER);
 
-const ROPSTEN_CHAIN_ID = 3;
-
 const nftSwapperMaker = new NftSwapV4(
   MAKER_SIGNER as any,
   MAKER_SIGNER,
@@ -88,7 +90,7 @@ describe('NFTSwapV4', () => {
     expect(signedOrderErc1155.erc20TokenAmount).toBe(ERC20_ASSET.amount);
     expect(signedOrderErc1155.direction.toString()).toBe('0');
 
-    await nftSwapperMaker.postOrder(signedOrder, '3');
+    // await nftSwapperMaker.postOrder(signedOrder, '3');
     // Uncomment to fill
     // const fillTx = await nftSwapperMaker.fillSignedOrder(signedOrder);
     // const txReceipt = await fillTx.wait();

test/v4/erc721-test-swap-mumbai.test.ts

@@ -101,10 +101,11 @@ describe('NFTSwapV4', () => {
     // })
 
     // const maybeOrder = maybeOrders.orders[0];
+    // const maybeOrder = { order: signedOrderErc1155 }
 
-    // expect(maybeOrder.order.nonce).toEqual(signedOrder.nonce.toString(10))
+    // // expect(maybeOrder.order.nonce).toEqual(signedOrder.nonce.toString(10))
 
-    // expect(maybeOrder.order.signature.signatureType.toString()).toEqual('2');
+    // // expect(maybeOrder.order.signature.signatureType.toString()).toEqual('2');
 
     // const fillTx = await nftSwapperMaker.fillSignedOrder(maybeOrder.order);
 
@@ -115,6 +116,6 @@ describe('NFTSwapV4', () => {
 
     // expect(txReceipt.transactionHash).toBeTruthy();
 
-    // console.log(`Swapped on Polygon Mumbai (txHAsh: ${txReceipt.transactionIndex})`);
+    // console.log(`Swapped on Polygon Mumbai (txHash: ${txReceipt.transactionHash})`);
   });
 });