@opensea/seaport-js 2.0.3 → 2.0.5

package/src/contracts/test/TestERC1271Wallet.sol

@@ -0,0 +1,89 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity >=0.8.7;
+
+interface IERC20Approve {
+    function approve(address spender, uint256 amount) external returns (bool);
+}
+
+contract TestERC1271Wallet {
+    address public orderSigner;
+
+    constructor() {
+        orderSigner = msg.sender;
+    }
+
+    function approveToken(
+        address token,
+        address spender,
+        uint256 amount
+    ) external {
+        IERC20Approve(token).approve(spender, amount);
+    }
+
+    function isValidSignature(
+        bytes32 hash,
+        bytes calldata signature
+    ) external view returns (bytes4) {
+        address signer_ = recover(hash, signature);
+        if (signer_ == orderSigner) {
+            return 0x1626ba7e;
+        }
+        return 0x00000000;
+    }
+
+    function recover(
+        bytes32 hash,
+        bytes memory signature
+    ) internal pure returns (address) {
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+
+        if (signature.length == 65) {
+            // ecrecover takes the signature parameters, and the only way to get them
+            // currently is to use assembly.
+            // solhint-disable-next-line no-inline-assembly
+            assembly {
+                r := mload(add(signature, 0x20))
+                s := mload(add(signature, 0x40))
+                v := byte(0, mload(add(signature, 0x60)))
+            }
+        } else if (signature.length == 64) {
+            // ecrecover takes the signature parameters, and the only way to get them
+            // currently is to use assembly.
+            // solhint-disable-next-line no-inline-assembly
+            assembly {
+                let vs := mload(add(signature, 0x40))
+                r := mload(add(signature, 0x20))
+                s := and(
+                    vs,
+                    0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+                )
+                v := add(shr(255, vs), 27)
+            }
+        } else {
+            revert("ECDSA: invalid signature length");
+        }
+
+        // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
+        if (v < 27) {
+            v += 27;
+        }
+
+        // If the version is correct return the signer address
+        if (v != 27 && v != 28) {
+            return (address(0));
+        } else {
+            return ecrecover(hash, v, r, s);
+        }
+    }
+
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes calldata _data
+    ) public returns (bytes4) {
+        return this.onERC721Received.selector;
+    }
+}

package/src/seaport.ts

@@ -105,7 +105,7 @@ export class Seaport {
       balanceAndApprovalChecksOnOrderCreation = true,
       conduitKeyToConduit,
       seaportVersion = "1.5",
-    }: SeaportConfig = {}
+    }: SeaportConfig = {},
   ) {
     const provider =
       providerOrSigner instanceof providers.Provider
@@ -117,14 +117,14 @@ export class Seaport {
 
     if (!provider) {
       throw new Error(
-        "Either a provider or custom signer with provider must be provided"
+        "Either a provider or custom signer with provider must be provided",
       );
     }
 
     this.provider = provider;
 
     this.multicallProvider = new multicallProviders.MulticallProvider(
-      this.provider
+      this.provider,
     );
 
     this.contract = new Contract(
@@ -133,13 +133,13 @@ export class Seaport {
           ? CROSS_CHAIN_SEAPORT_V1_5_ADDRESS
           : CROSS_CHAIN_SEAPORT_V1_4_ADDRESS),
       SeaportABIv14,
-      this.multicallProvider
+      this.multicallProvider,
     ) as SeaportContract;
 
     this.domainRegistry = new Contract(
       overrides?.domainRegistryAddress ?? DOMAIN_REGISTRY_ADDRESS,
       DomainRegistryABI,
-      this.multicallProvider
+      this.multicallProvider,
     ) as DomainRegistryContract;
 
     this.config = {
@@ -186,16 +186,16 @@ export class Seaport {
   public async createOrder(
     input: CreateOrderInput,
     accountAddress?: string,
-    exactApproval?: boolean
+    exactApproval?: boolean,
   ): Promise<OrderUseCase<CreateOrderAction>> {
     const signer = this._getSigner(accountAddress);
-    const offerer = await signer.getAddress();
+    const offerer = accountAddress ?? (await signer.getAddress());
 
     const { orderComponents, approvalActions } = await this._formatOrder(
       signer,
       offerer,
       Boolean(exactApproval),
-      input
+      input,
     );
 
     const createOrderAction = {
@@ -235,7 +235,7 @@ export class Seaport {
   public async createBulkOrders(
     createOrderInput: CreateOrderInput[],
     accountAddress?: string,
-    exactApproval?: boolean
+    exactApproval?: boolean,
   ): Promise<OrderUseCase<CreateBulkOrdersAction>> {
     const signer = this._getSigner(accountAddress);
     const offerer = await signer.getAddress();
@@ -250,7 +250,7 @@ export class Seaport {
         signer,
         offerer,
         Boolean(exactApproval),
-        input
+        input,
       );
 
       allOrderComponents.push(orderComponents);
@@ -296,6 +296,7 @@ export class Seaport {
     {
       conduitKey = this.defaultConduitKey,
       zone = ethers.constants.AddressZero,
+      zoneHash = ethers.constants.HashZero,
       startTime = Math.floor(Date.now() / 1000).toString(),
       endTime = MAX_INT.toString(),
       offer,
@@ -306,7 +307,7 @@ export class Seaport {
       fees,
       domain,
       salt,
-    }: CreateOrderInput
+    }: CreateOrderInput,
   ) {
     const offerItems = offer.map(mapInputItemToOfferItem);
     const considerationItems = [
@@ -324,12 +325,12 @@ export class Seaport {
       })
     ) {
       throw new Error(
-        "All currency tokens in the order must be the same token when applying fees"
+        "All currency tokens in the order must be the same token when applying fees",
       );
     }
 
     const currencies = [...offerItems, ...considerationItems].filter(
-      isCurrencyItem
+      isCurrencyItem,
     );
 
     const totalCurrencyAmount = totalItemsAmount(currencies);
@@ -350,7 +351,7 @@ export class Seaport {
               token: currencies[0].token,
               baseAmount: totalCurrencyAmount.startAmount,
               baseEndAmount: totalCurrencyAmount.endAmount,
-            })
+            }),
           ) ?? []
         : []),
     ];
@@ -363,7 +364,7 @@ export class Seaport {
     const orderComponents: OrderComponents = {
       offerer,
       zone,
-      zoneHash: ethers.constants.HashZero,
+      zoneHash,
       startTime,
       endTime,
       orderType,
@@ -397,7 +398,7 @@ export class Seaport {
       const approvals = getApprovalActions(
         insufficientApprovals,
         exactApproval,
-        signer
+        signer,
       );
       approvalActions.push(...approvals);
     }
@@ -468,8 +469,8 @@ export class Seaport {
       _TypedDataEncoder.getPayload(
         domainData,
         EIP_712_ORDER_TYPE,
-        orderComponents
-      )
+        orderComponents,
+      ),
     );
   }
 
@@ -487,7 +488,7 @@ export class Seaport {
     const chunks = tree.getDataToSign();
 
     return JSON.stringify(
-      _TypedDataEncoder.getPayload(domainData, bulkOrderType, { tree: chunks })
+      _TypedDataEncoder.getPayload(domainData, bulkOrderType, { tree: chunks }),
     );
   }
 
@@ -499,7 +500,7 @@ export class Seaport {
    */
   public async signOrder(
     orderComponents: OrderComponents,
-    accountAddress?: string
+    accountAddress?: string,
   ): Promise<string> {
     const signer = this._getSigner(accountAddress);
 
@@ -508,7 +509,7 @@ export class Seaport {
     const signature = await signer._signTypedData(
       domainData,
       EIP_712_ORDER_TYPE,
-      orderComponents
+      orderComponents,
     );
 
     // Use EIP-2098 compact signatures to save gas.
@@ -523,7 +524,7 @@ export class Seaport {
    */
   public async signBulkOrder(
     orderComponents: OrderComponents[],
-    accountAddress?: string
+    accountAddress?: string,
   ): Promise<OrderWithCounter[]> {
     const signer = this._getSigner(accountAddress);
 
@@ -536,7 +537,7 @@ export class Seaport {
     let signature = await signer._signTypedData(
       domainData,
       bulkOrderType,
-      value
+      value,
     );
 
     // Use EIP-2098 compact signatures to save gas.
@@ -561,7 +562,7 @@ export class Seaport {
   public cancelOrders(
     orders: OrderComponents[],
     accountAddress?: string,
-    domain?: string
+    domain?: string,
   ): TransactionMethods<ContractMethodReturnType<SeaportContract, "cancel">> {
     const signer = this._getSigner(accountAddress);
 
@@ -569,7 +570,7 @@ export class Seaport {
       this.contract.connect(signer),
       "cancel",
       [orders],
-      domain
+      domain,
     );
   }
 
@@ -581,7 +582,7 @@ export class Seaport {
    */
   public bulkCancelOrders(
     offerer?: string,
-    domain?: string
+    domain?: string,
   ): TransactionMethods<
     ContractMethodReturnType<SeaportContract, "incrementCounter">
   > {
@@ -591,7 +592,7 @@ export class Seaport {
       this.contract.connect(signer),
       "incrementCounter",
       [],
-      domain
+      domain,
     );
   }
 
@@ -606,7 +607,7 @@ export class Seaport {
   public validate(
     orders: Order[],
     accountAddress?: string,
-    domain?: string
+    domain?: string,
   ): TransactionMethods<ContractMethodReturnType<SeaportContract, "validate">> {
     const signer = this._getSigner(accountAddress);
 
@@ -614,7 +615,7 @@ export class Seaport {
       this.contract.connect(signer),
       "validate",
       [orders],
-      domain
+      domain,
     );
   }
 
@@ -650,13 +651,13 @@ export class Seaport {
     const orderTypeString = `${orderComponentsPartialTypeString}${considerationItemTypeString}${offerItemTypeString}`;
 
     const offerItemTypeHash = ethers.utils.keccak256(
-      ethers.utils.toUtf8Bytes(offerItemTypeString)
+      ethers.utils.toUtf8Bytes(offerItemTypeString),
     );
     const considerationItemTypeHash = ethers.utils.keccak256(
-      ethers.utils.toUtf8Bytes(considerationItemTypeString)
+      ethers.utils.toUtf8Bytes(considerationItemTypeString),
     );
     const orderTypeHash = ethers.utils.keccak256(
-      ethers.utils.toUtf8Bytes(orderTypeString)
+      ethers.utils.toUtf8Bytes(orderTypeString),
     );
 
     const offerHash = ethers.utils.keccak256(
@@ -682,11 +683,11 @@ export class Seaport {
                       .toHexString()
                       .slice(2)
                       .padStart(64, "0"),
-                  ].join("")
+                  ].join(""),
               )
               .slice(2);
           })
-          .join("")
+          .join(""),
     );
 
     const considerationHash = ethers.utils.keccak256(
@@ -701,7 +702,7 @@ export class Seaport {
                     considerationItem.itemType.toString().padStart(64, "0"),
                     considerationItem.token.slice(2).padStart(64, "0"),
                     ethers.BigNumber.from(
-                      considerationItem.identifierOrCriteria
+                      considerationItem.identifierOrCriteria,
                     )
                       .toHexString()
                       .slice(2)
@@ -715,11 +716,11 @@ export class Seaport {
                       .slice(2)
                       .padStart(64, "0"),
                     considerationItem.recipient.slice(2).padStart(64, "0"),
-                  ].join("")
+                  ].join(""),
               )
               .slice(2);
           })
-          .join("")
+          .join(""),
     );
 
     const derivedOrderHash = ethers.utils.keccak256(
@@ -749,7 +750,7 @@ export class Seaport {
             .toHexString()
             .slice(2)
             .padStart(64, "0"),
-        ].join("")
+        ].join(""),
     );
 
     return derivedOrderHash;
@@ -857,7 +858,7 @@ export class Seaport {
 
     const sanitizedOrder = validateAndSanitizeFromOrderStatus(
       order,
-      orderStatus
+      orderStatus,
     );
 
     const timeBasedItemParams = {
@@ -897,7 +898,7 @@ export class Seaport {
           tips: tipConsiderationItems,
           domain,
         },
-        exactApproval
+        exactApproval,
       );
     }
 
@@ -925,7 +926,7 @@ export class Seaport {
         recipientAddress,
         domain,
       },
-      exactApproval
+      exactApproval,
     );
   }
 
@@ -976,23 +977,23 @@ export class Seaport {
 
     const allOffererOperators = fulfillOrderDetails.map(
       ({ order }) =>
-        this.config.conduitKeyToConduit[order.parameters.conduitKey]
+        this.config.conduitKeyToConduit[order.parameters.conduitKey],
     );
 
     const fulfillerOperator = this.config.conduitKeyToConduit[conduitKey];
 
     const allOfferItems = fulfillOrderDetails.flatMap(
-      ({ order }) => order.parameters.offer
+      ({ order }) => order.parameters.offer,
     );
 
     const allConsiderationItems = fulfillOrderDetails.flatMap(
-      ({ order }) => order.parameters.consideration
+      ({ order }) => order.parameters.consideration,
     );
     const allOfferCriteria = fulfillOrderDetails.flatMap(
-      ({ offerCriteria = [] }) => offerCriteria
+      ({ offerCriteria = [] }) => offerCriteria,
     );
     const allConsiderationCriteria = fulfillOrderDetails.flatMap(
-      ({ considerationCriteria = [] }) => considerationCriteria
+      ({ considerationCriteria = [] }) => considerationCriteria,
     );
 
     const [
@@ -1009,8 +1010,8 @@ export class Seaport {
             criterias: offerCriteria,
             operator: allOffererOperators[i],
             multicallProvider: this.multicallProvider,
-          })
-        )
+          }),
+        ),
       ),
       // Get fulfiller balances and approvals of all items in the set, as offer items
       // may be received by the fulfiller for standard fulfills
@@ -1024,8 +1025,8 @@ export class Seaport {
       this.multicallProvider.getBlock("latest"),
       Promise.all(
         fulfillOrderDetails.map(({ order }) =>
-          this.getOrderStatus(this.getOrderHash(order.parameters))
-        )
+          this.getOrderStatus(this.getOrderHash(order.parameters)),
+        ),
       ),
     ]);
 
@@ -1044,7 +1045,7 @@ export class Seaport {
         extraData: orderDetails.extraData ?? "0x",
         offererBalancesAndApprovals: offerersBalancesAndApprovals[index],
         offererOperator: allOffererOperators[index],
-      })
+      }),
     );
 
     return fulfillAvailableOrders({
@@ -1096,13 +1097,13 @@ export class Seaport {
       this.contract.connect(signer),
       "matchOrders",
       [orders, fulfillments, overrides],
-      domain
+      domain,
     );
   }
 
   public setDomain(
     domain: string,
-    accountAddress?: string
+    accountAddress?: string,
   ): TransactionMethods<
     ContractMethodReturnType<DomainRegistryContract, "setDomain">
   > {
@@ -1111,7 +1112,7 @@ export class Seaport {
     return getTransactionMethods(
       this.domainRegistry.connect(signer),
       "setDomain",
-      [domain]
+      [domain],
     );
   }
 
@@ -1125,7 +1126,7 @@ export class Seaport {
 
   public async getDomains(
     tag: string,
-    shouldThrow?: boolean
+    shouldThrow?: boolean,
   ): Promise<string[]> {
     try {
       if (shouldThrow) {
@@ -1140,8 +1141,8 @@ export class Seaport {
 
       const domainArray = Promise.all(
         [...Array(totalDomains).keys()].map((i) =>
-          this.domainRegistry.getDomain(tag, i)
-        )
+          this.domainRegistry.getDomain(tag, i),
+        ),
       );
 
       return domainArray;

package/src/typechain-types/factories/src/contracts/test/TestERC1271Wallet.sol/IERC20Approve__factory.ts

@@ -0,0 +1,50 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IERC20Approve,
+  IERC20ApproveInterface,
+} from "../../../../../src/contracts/test/TestERC1271Wallet.sol/IERC20Approve";
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256",
+      },
+    ],
+    name: "approve",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+export class IERC20Approve__factory {
+  static readonly abi = _abi;
+  static createInterface(): IERC20ApproveInterface {
+    return new utils.Interface(_abi) as IERC20ApproveInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IERC20Approve {
+    return new Contract(address, _abi, signerOrProvider) as IERC20Approve;
+  }
+}