This NFT payment smart contract security checklist helps developers review how a contract receives funds, authorizes wallets, distributes proceeds, and handles failure before a production deployment. Use it during initial development, contract upgrades, new-chain launches, payment-token additions, and recurring wallet security reviews.
Overview
An NFT checkout may look simple to a buyer: connect a crypto wallet, select an NFT, approve a payment, and receive an asset. Behind that flow, the payment contract may validate prices, accept native currency or ERC-20 tokens, call an NFT contract, calculate royalties, record recipients, and expose withdrawal functions. Each interaction creates a separate review area.
The main security question is not only whether a transaction succeeds. It is whether the contract can enforce the intended payment rules under unusual conditions: a payment token behaves differently than expected, a recipient is changed, a callback re-enters the contract, a signature is replayed, or an NFT transfer fails after funds have moved.
Use this checklist alongside code review, automated testing, and an independent audit where the value or operational risk justifies one. A contract audit cannot replace careful key management, deployment controls, transaction monitoring, or a secure crypto wallet setup for the team operating the system.
What to track
1. Payment assets and pricing rules
- List every accepted asset, including native currency and each ERC-20 token address, and verify the address separately for every supported network.
- Define whether prices are fixed, signed off-chain, oracle-based, or supplied by a trusted operator. Check units, decimals, rounding, and maximum acceptable values.
- Prevent accidental acceptance of an unsupported token. A generic token transfer may send assets to the contract without creating a valid order or refund path.
- Specify whether payment is made before or after NFT transfer, and document what happens when either leg fails.
2. Recipients, proceeds, and withdrawal controls
Confirm that seller, treasury, royalty, and marketplace recipients are assigned deliberately. A recipient should not be replaceable by an arbitrary caller, and administrative changes should be restricted, visible, and subject to an appropriate approval process.
Review whether the contract uses a pull-payment model, where each recipient withdraws an accounted balance, or a push-payment model, where the contract sends funds during a sale. Pull payments can isolate a failing recipient, but they still require accurate accounting and protected withdrawal functions. Check for double withdrawals, stale balances, zero-address recipients, and unexpected native-currency transfers.
3. Token approvals and NFT transfers
For ERC-721 and ERC-1155 transactions, verify collection addresses, token identifiers, quantities, and ownership or approval status. The contract should not assume that every token contract behaves identically. Test safe-transfer callbacks and failure cases, including a seller revoking approval, a token being transferred before execution, or a collection implementing nonstandard behavior.
For ERC-20 payments, review allowance handling and balance checks. Avoid relying on an approval succeeding without checking the result. If the design supports permits or signed approvals, validate the token's expected permit interface, domain data, nonce, deadline, chain identifier, and spender. Do not treat a signature as a substitute for checking the actual payment received.
4. Signatures, permits, and replay resistance
Every off-chain authorization should bind the signature to the intended contract, chain, user, order, payment asset, amount, recipient, and expiry. Include a nonce or another one-time-use mechanism where the same authorization must not be submitted twice. Test signatures on wrong-chain deployments, after an order is cancelled, and after a nonce has already been consumed.
Keep signing domains and encoded data consistent with the client application. A wallet integration that displays one order while signing another is a serious transaction-integrity problem, even when the Solidity validation is correct.
5. Reentrancy and external calls
Mark every external call, including NFT transfers, token transfers, royalty callbacks, and recipient payments. Update internal state before making calls where the design permits, and apply a reentrancy guard when a function can be entered again before completion. A guard is not a complete solution: review state transitions, cross-function interactions, and callback behavior as a whole.
Test contracts that deliberately call back into payment, refund, withdrawal, or cancellation functions. Also test tokens and recipients that revert, consume unusual amounts of gas, or return data in an unexpected format.
6. Royalties, refunds, and order cancellation
Write the royalty formula in plain language before reviewing its implementation. Check basis-point limits, rounding direction, maximum recipient count, duplicate recipients, and whether the total allocation can exceed the sale amount. If royalties are optional or collection-specific, make that behavior explicit rather than assuming a universal rule.
Refund paths deserve the same scrutiny as successful sales. Define who can request a refund, whether an order can be refunded once only, how partial fulfillment is handled, and what happens when the original payer is a contract wallet. Test cancellation, expiry, underpayment, overpayment, failed NFT delivery, and refund attempts after proceeds have been withdrawn.
7. Pause, upgrade, and emergency authority
Document every privileged role and the exact actions it can perform. A pause function should have a defined scope and an operational procedure, not merely exist in the code. Test whether pausing blocks purchases, withdrawals, refunds, administrative changes, or only selected functions.
For upgradeable contracts, record the proxy pattern, implementation authority, initialization state, storage layout expectations, and upgrade approval process. Protect deployer and admin wallets with appropriate controls, keep keys separate from everyday NFT transactions, and verify the deployed bytecode and configuration before enabling sales.
8. Events, accounting, and unexpected tokens
Emit events for orders, payments, refunds, cancellations, recipient changes, withdrawals, pauses, and upgrades. Include enough identifiers for an indexer or reconciliation system to connect an event with the buyer, seller, NFT, asset, amount, and order state.
Decide how the contract handles assets sent directly to it, unsupported tokens, accidental native currency, and tokens received outside the normal checkout flow. An explicit recovery process should be restricted, logged, and designed so that recovery cannot compromise legitimate customer balances.
| Review area | Evidence to retain | Failure test |
|---|---|---|
| Payment validation | Accepted assets, units, limits, and price source | Wrong token, wrong amount, stale or expired order |
| Wallet authorization | Role list, signer policy, nonce design | Replay, wrong chain, unauthorized recipient change |
| Fund movement | Accounting model and withdrawal rules | Reentrancy, failed recipient, repeated withdrawal |
| NFT delivery | Collection and approval assumptions | Revoked approval, failed callback, already-transferred token |
| Emergency controls | Pause, upgrade, and recovery procedures | Paused purchase, admin compromise scenario, unsafe upgrade |
Cadence and checkpoints
Run a focused review before each production deployment, then use a lighter operational review monthly or quarterly. The timing should match the contract's change rate, transaction volume, administrative exposure, and value held. A review is also warranted after a payment-token addition, new-chain deployment, wallet provider change, library upgrade, audit remediation, or security advisory affecting a dependency.
Use a staged test workflow:
- Unit tests: Cover pricing, fees, royalties, signatures, nonces, refunds, cancellations, permissions, and rounding.
- Adversarial tests: Exercise reentrancy, malformed tokens, reverting recipients, callback behavior, direct transfers, and boundary values.
- Integration tests: Run the complete NFT checkout with the intended wallet integration, token contracts, indexer, and payment API or backend.
- Deployment rehearsal: Verify constructor or initializer values, roles, supported assets, pause status, upgrade authority, and event decoding on the target network.
- Release review: Compare deployed addresses and configuration with the approved release record. Record unresolved findings and their owners before opening sales.
Teams building broader Web3 payments can pair this review with a crypto wallet security audit checklist and a NFT checkout integration and gas-cost checklist.
How to interpret changes
A change in failed transactions does not automatically prove a contract vulnerability. Separate user experience issues, such as a wrong network or rejected wallet, from contract-level failures. Compare failures by function, asset, collection, wallet type, chain, and contract version.
Investigate sudden changes in withdrawal volume, unsupported-token balances, refund attempts, signature failures, paused functions, and privileged transactions. A new pattern may indicate a client bug, an integration mismatch, a configuration error, or an attempted exploit. Preserve transaction hashes, decoded input, event logs, block context, and the relevant contract version before changing code.
When a finding is fixed, add a regression test that would have failed under the old behavior. Re-run the full payment and withdrawal suite rather than testing only the changed function. For operational visibility, a crypto payment monitoring checklist can help connect on-chain events with application alerts and reconciliation.
When to revisit
Revisit this checklist on a monthly or quarterly schedule, and immediately after any material change. At minimum, trigger a new review when you upgrade Solidity or contract libraries, add a payment token or NFT collection, deploy to another network, modify signature logic, change royalty or refund rules, rotate administrative wallets, alter proxy authority, or respond to a security advisory.
Before each release, assign an owner to every checklist item and label it pass, blocked, or requires remediation. Confirm that test results, deployment addresses, role assignments, audit responses, and emergency contacts are stored with the release record. After launch, compare the recorded design with actual transactions and investigate unexplained deviations.
Finally, do not approve a payment contract solely because it passed a previous audit. Recheck the code, configuration, dependencies, wallet permissions, and target-chain assumptions for the current deployment. That recurring discipline is what turns a one-time NFT payment review into a practical security process.