ERC-721: setApprovalForAll

mkdir erc721-approval-example
cd erc721-approval-example

npm init -y
npm pkg set type="module"
npm install ethers solc tsx
npm install --save-dev hardhat typescript @types/node
mkdir contracts scripts

import { defineConfig } from "hardhat/config";

export default defineConfig({
  solidity: {
    version: "0.8.20",
  },
});

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract DemoNFT {
    string public name = "Demo NFT";
    string public symbol = "DNFT";
    uint256 public nextTokenId = 1;

    mapping(uint256 => address) private owners;
    mapping(address => uint256) private balances;
    mapping(address => mapping(address => bool)) private operatorApprovals;

    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function mint(address to) external returns (uint256 tokenId) {
        require(to != address(0), "mint to zero address");

        tokenId = nextTokenId;
        nextTokenId += 1;

        owners[tokenId] = to;
        balances[to] += 1;

        emit Transfer(address(0), to, tokenId);
    }

    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = owners[tokenId];
        require(owner != address(0), "token does not exist");

        return owner;
    }

    function balanceOf(address owner) external view returns (uint256) {
        require(owner != address(0), "balance query for zero address");

        return balances[owner];
    }

    function setApprovalForAll(address operator, bool approved) external {
        require(operator != msg.sender, "approve to caller");

        operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return operatorApprovals[owner][operator];
    }

    function transferFrom(address from, address to, uint256 tokenId) external {
        require(to != address(0), "transfer to zero address");
        require(ownerOf(tokenId) == from, "from is not owner");
        require(
            msg.sender == from || isApprovedForAll(from, msg.sender),
            "caller is not owner nor approved"
        );

        balances[from] -= 1;
        balances[to] += 1;
        owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }
}

import { readFileSync } from "node:fs";
import { ethers } from "ethers";
import solc from "solc";

const source = readFileSync("contracts/DemoNFT.sol", "utf8");

const input = {
  language: "Solidity",
  sources: {
    "DemoNFT.sol": {
      content: source,
    },
  },
  settings: {
    outputSelection: {
      "*": {
        "*": ["abi", "evm.bytecode.object"],
      },
    },
  },
};

const output = JSON.parse(solc.compile(JSON.stringify(input)));
const contract = output.contracts["DemoNFT.sol"].DemoNFT;

const abi = contract.abi;
const bytecode = `0x${contract.evm.bytecode.object}`;

const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");

// Первый тестовый аккаунт Hardhat. Он владеет NFT.
const owner = new ethers.Wallet(
  "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
  provider,
);

// Третий тестовый аккаунт Hardhat. В реальном приложении это мог бы быть marketplace.
const operator = new ethers.Wallet(
  "0x5de4111a56fb4c77293da43f93d18f8ee7d99d6b201a790d22d7bce5863e604a",
  provider,
);

// Второй тестовый аккаунт Hardhat. Он получит NFT.
const buyer = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8";

const factory = new ethers.ContractFactory(abi, bytecode, owner);
const nft = await factory.deploy();

await nft.waitForDeployment();

const nftAddress = await nft.getAddress();
const tokenId = await nft.nextTokenId();

const mintTx = await nft.mint(owner.address);
await mintTx.wait();

console.log("NFT address:", nftAddress);
console.log("Token ID:", tokenId.toString());
console.log("Owner before:", await nft.ownerOf(tokenId));
console.log(
  "Approved before:",
  await nft.isApprovedForAll(owner.address, operator.address),
);

const approvalTx = await nft.setApprovalForAll(operator.address, true);

console.log("Approval hash:", approvalTx.hash);

const approvalReceipt = await approvalTx.wait();

if (!approvalReceipt || approvalReceipt.status !== 1) {
  throw new Error("Транзакция setApprovalForAll() не была успешно выполнена");
}

console.log(
  "Approved after:",
  await nft.isApprovedForAll(owner.address, operator.address),
);

const nftAsOperator = new ethers.Contract(nftAddress, abi, operator);
const transferTx = await nftAsOperator.transferFrom(owner.address, buyer, tokenId);

console.log("Operator transfer hash:", transferTx.hash);

const transferReceipt = await transferTx.wait();

if (!transferReceipt || transferReceipt.status !== 1) {
  throw new Error("Транзакция transferFrom() не была успешно выполнена");
}

console.log("Transfer block:", transferReceipt.blockNumber);
console.log("Owner after:", await nft.ownerOf(tokenId));

const revokeTx = await nft.setApprovalForAll(operator.address, false);
await revokeTx.wait();

console.log(
  "Approved after revoke:",
  await nft.isApprovedForAll(owner.address, operator.address),
);

npx hardhat node

npx tsx scripts/operator-approval.ts

isApprovedForAll(owner, operator) = true
operator может transferFrom(owner, ..., любой tokenId владельца)

setApprovalForAll(marketplace, true)

transferFrom(seller, buyer, tokenId)