NiftyApes security record

`withdrawOfferSignature()` is vulnerable to front-running. If a seller submits a transaction calling `withdrawOfferSignature()` to the mempool on an undesirable existing offer, a savvy witnesser could see this and buy the offer prior to the cancellation. This can result in sellers being forced to finance NFTs on Offers that they intend to keep or are no longer desirable due to market conditions.

Payouts to the seller in `_makePayment()` are done through a call to `_conditionalSendValue()`, which refunds the buyer if the seller cannot receive ETH payments. In this scenario, `_makePayments()` considers the principal and interest payments fulfilled regardless of whether the seller received any compensation. A buyer could exploit this situation and continuously send payments (which will be sent back to them) until they have completed the payment plan and essentially receive the NFT cost-free.

In order to validate the proper deployment and initialization of the contracts, it is a good practice to emit events. Also, any important state transitions can be logged, which is beneficial for monitoring the contract, and also tracking eventual bugs or hacks. Below we present a non-exhaustive list of events that could be emitted to improve application management: 1. Contract address changes: * `SellerFinancing`: * `updateRoyaltiesEngineContractAddress()` * `updateDelegateRegistryContractAddress()` * `updateSeaportContractAddress()` * `updateWethContractAddress()` * `MarketplaceIntegration`: * `updateSellerFinancingContractAddress()` * `updateMarketplaceFeeRecipient()` 1. Pausing or unpausing of features: * `SellerFinancing` and `MarketplaceIntegration`: * `pause()` * `unpause()` * `pauseSanctions()` * `unpauseSanctions()` 1. Changes to the fee structure: * `MarketPlaceIntegration`: * `updateMarketplaceFeeBps()`

In `buyWithFinancing()`, if `msg.value` exceeds `offer.downPaymentAmount()`, the refund is issued to the `buyer` rather than the `msg.sender`. According to the NiftyApes team, this is done so that buyers receive their refund for purchases made through the `MarketplaceIntegration` contract, which collects a fee before making a call to `SellerFinancing.buyWithFinancing()`. This use case works because the `MarketplaceIntegration` contract acts as an intermediary contract between the user and `SellerFinancing`, and passes along the full `msg.value`. Users interacting directly with the `SellerFinancing` contract under a different paradigm should be aware that excessive payments are sent directly to the `buyer`. For example, if a different user makes an excess payment on behalf of the `buyer`, the excess funds are sent to the `buyer` rather than user.

This implementation casts all timestamps to `uint32`, which will support UNIX timestamps up until January 19, 2038 at 3:14:07 UTC. After that, this protocol will no longer support these timestamps.

Ticket transfers are still possible after a loan has defaulted. Buyer tickets for defaulted loans hold no value as their NFT's seized at any time.

Division before multiplication may result in a loss of precision when the operations are carried over integer numbers. `SellerFinancing.calculateMinimumPayment()`has a multiplication done after division when calculating `periodInterest`.

If an offer's signature gets used once or has been previously canceled, the seller will be unable to make the same offer again, even if it is intentional. The impact is low since they can make a minor change (e.g. increase `expiration` by a single second) and have it be different.