处理 NFT 预售 — 链下白名单

https://etherscan.io/address/0x8575B2Dbbd7608A1629aDAA952abA74Bcc53d22A#code

mapping(address => uint8) _allowList;

function setAllowList(
address[] calldata addresses,
uint8 numAllowedToMint
) external onlyOwner {
  for (uint256 i = 0; i < addresses.length; i++) {
    _allowList[addresses[i]] = numAllowedToMint;
  }
}

import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
...
// declare bytes32 variables to store each root (a hash)
bytes32 public genesisMerkleRoot;
bytes32 public authorsMerkleRoot;
bytes32 public presaleMerkleRoot;
...
// separate functions to set the roots of each individual Merkle Tree
function setGenesisMerkleRoot(bytes32 _root) external onlyOwner {
 genesisMerkleRoot = _root;
}
function setAuthorsMerkleRoot(bytes32 _root) external onlyOwner {
  authorsMerkleRoot = _root;
}
function setPresaleMerkleRoot(bytes32 _root) external onlyOwner {
  presaleMerkleRoot = _root;
}
...
// create merkle leaves from supplied data
function _generateGenesisMerkleLeaf(
  address _account,
  uint256 _tokenId
)  internal  pure  returns (bytes32) {
 return keccak256(abi.encodePacked(_tokenId, _account));
}
function _generateAuthorsMerkleLeaf(
  address _account,
  uint256 _tokenCount
)  internal  pure  returns (bytes32) {
  return keccak256(abi.encodePacked(_account, _tokenCount));
}
function _generatePresaleMerkleLeaf(
  address _account,
  uint256 _max
)  internal  pure  returns (bytes32) {
  return keccak256(abi.encodePacked(_max, _account));
}
...
// function to verify that the given leaf belongs to a given tree using its root for comparison
function _verifyMerkleLeaf(
  bytes32 _leafNode,
  bytes32 _merkleRoot,
  bytes32[] memory _proof ) internal view returns (bool) {
  return MerkleProof.verify(_proof, _merkleRoot, _leafNode);
}

require(
  _verifyMerkleLeaf(
     _generateGenesisMerkleLeaf(
        msg.sender,
        _tokenIds[i]),
     genesisMerkleRoot,
     _proofs[i]
), "Invalid proof, you don't own that Token ID");

struct Coupon {
  bytes32 r;
  bytes32 s;
  uint8 v;
 }

enum CouponType {
  Genesis,
  Author,
  Presale
}

enum SalePhase {
  Locked,
  PreSale,
  PublicSale
}

 /// Mint during presale
 /// @dev mints by addresses validated using verified coupons signed by an admin signer
 /// @notice mints tokens with randomized token IDs to addresses eligible for presale
 /// @param count number of tokens to mint in transaction
 /// @param coupon coupon signed by an admin coupon
 function mintPresale(uint256 count, Coupon memory coupon)
  external
  payable
  ensureAvailabilityFor(count)
  validateEthPayment(count)
 {
    require(
      phase == SalePhase.PreSale,
      'Presale event is not active'
    ); // 1

    require(
      count + addressToMints[msg.sender]._numberOfMintsByAddress <=
      MAX_PRESALE_MINTS_PER_ADDRESS,
      'Exceeds number of presale mints allowed'
    ); // 2
    bytes32 digest = keccak256(
      abi.encode(CouponType.Presale, msg.sender)
    ); // 3

    require(
      _isVerifiedCoupon(digest, coupon),
     'Invalid coupon'
    ); // 4
...
}

bytes32 digest = keccak256(
 abi.encode(
  2,
  0x8575B2Dbbd7608A1629aDAA952abA74Bcc53d22A
 )
);

 /// @dev check that the coupon sent was signed by the admin signer
 function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
  internal
  view
  returns (bool)
 {
  address signer = ecrecover(digest, coupon.v, coupon.r, coupon.s);
  require(signer != address(0), 'ECDSA: invalid signature');
  return signer == _adminSigner;
 }

{
  "0x1813183E1A2a5a...a868A4e1b7610c0": {
    "coupon": {
         "r": "0x77b675bb4808.....674c42bde11618a",
         "s": "0x17baa76756fed.....4b0b9f4a380b8a9",
         "v": 27
    }
}

mintPresale(
  qty: number,
  priceInEth: number,
  coupon: ICoupon
) {
  const mintPriceBn = utils.parseEther(priceInEth.toString());
  return this.contract.mintPresale(qty, coupon, {
    value: mintPriceBn.mul(qty),
    gasLimit: GAS_LIMIT_PER * qty
  });
}

const {
  keccak256,
  toBuffer,
  ecsign,
  bufferToHex,
} = require("ethereumjs-utils");
const { ethers } = require('ethers');
...
// create an object to match the contracts struct
const CouponTypeEnum = {
  Genesis: 0,
  Author: 1,
  Presale: 2,
};
let coupons = {};
for (let i = 0; i < presaleAddresses.length; i++) {
  const userAddress = ethers.utils.getAddress(presaleAddresses[i]);
  const hashBuffer = generateHashBuffer(
    ["uint256", "address"],
    [CouponTypeEnum["Presale"], userAddress]
  );
  const coupon = createCoupon(hashBuffer, signerPvtKey);

  coupons[userAddress] = {
    coupon: serializeCoupon(coupon)
  };
}
// HELPER FUNCTIONS
function createCoupon(hash, signerPvtKey) {
   return ecsign(hash, signerPvtKey);
}
function generateHashBuffer(typesArray, valueArray) {
   return keccak256(
     toBuffer(ethers.utils.defaultAbiCoder.encode(typesArray,
     valueArray))
   );
}
function serializeCoupon(coupon) {
   return {
     r: bufferToHex(coupon.r),
     s: bufferToHex(coupon.s),
     v: coupon.v,
   };
}

// [solidity] recreating the digest in the contract
bytes32 digest = keccak256(
  abi.encode(CouponType.Presale, msg.sender)
);

// [javascript] Creating the digest for the coupon off-chain
const hashBuffer = generateHashBuffer(
   ["uint256", "address"],
   [CouponTypeEnum["Presale"], userAddress]
);

function generateHashBuffer(typesArray, valueArray) {
   return keccak256(
     toBuffer(ethers.utils.defaultAbiCoder.encode(typesArray,
     valueArray))
   );
}

function createCoupon(hash, signerPvtKey) {
   return ecsign(hash, signerPvtKey);
}

const signerPvtKeyString = process.env.ADMIN_SIGNER_PRIVATE_KEY || "";

const signerPvtKey = Buffer.from(signerPvtKeyString, "hex");

const { privateToAddress } = require("ethereumjs-utils");
const { ethers } = require("ethers");
const crypto = require("crypto");

const pvtKey = crypto.randomBytes(32);
const pvtKeyString = pvtKey.toString("hex");
const signerAddress = ethers.utils.getAddress(
privateToAddress(pvtKey).toString("hex"));

console.log({ signerAddress, pvtKeyString });

// [solidity] function signature
function claimAuthorTokens(
  uint256 count,
  uint256 allotted,
  Coupon memory coupon
) public ensureAvailabilityFor(count) {
  require(claimActive, 'Claim event is not active');
  bytes32 digest = keccak256(
    abi.encode(
      CouponType.Author, allotted, msg.sender
    )
  );
  require(_isVerifiedCoupon(digest, coupon), 'Invalid coupon');
  ...
}
// [javascript] Creating the Author Coupons

for (const [address, qty] of Object.entries(authorAddressList)) {
  const hashBuffer = generateHashBuffer(
    [
      "uint256",
      "uint256",
      "address"
    ],
    [
      CouponTypeEnum["Author"],
      qty,
      ethers.utils.getAddress(address)
    ]
  );
  const coupon = createCoupon(hashBuffer, signerPvtKey);
  coupons[ethers.utils.getAddress(address)] = {
     qty,
     coupon: serializeCoupon(coupon)
  };
}

require(
 count + addressToMints[msg.sender]._numberOfAuthorMintsByAddress <=
 allotted,'Exceeds number of earned Tokens'
);

function claimReservedTokensByIds(
  address owner_,
  uint256[] calldata idxsToClaim,
  uint256[] calldata idsOfOwner,
  Coupon memory coupon
) external {
  require(claimActive, 'Claim event is not active');
  bytes32 digest = keccak256(
    abi.encode(CouponType.Genesis, idsOfOwner, owner_)
  );
  ...
}

   ...
  require(_isVerifiedCoupon(digest, coupon), 'Invalid coupon');
  for (uint256 i; i < idxsToClaim.length; i++) {
     uint256 tokenId = idsOfOwner[idxsToClaim[i]];
     _claimReservedToken(owner_, tokenId);
  }
}

const hashBuffer = generateHashBuffer(
  [
    "uint256",
    "uint256[]",
    "address"
  ],
  [
    CouponTypeEnum["Genesis"],
    idsArray,
    ethers.utils.getAddress(address)
  ]
);
const coupon = createCoupon(hashBuffer, signerPvtKey);

{
  "genesisId": 1,
  "openseaTokenId": "23436743935348681979378854387323145555258469867980315876480069342051002482689"
}

function burnOpenseaToken(
   userAddress: string,
   openseaId: string,
   newCollectionId: number,
   coupon: Object
) {

  const openseaIdBN = ethers.BigNumber.from(openseaId);
  const data = utils.defaultAbiCoder.encode(
     ["uint256", "tuple(bytes32 r, bytes32 s, uint8 v)"],
     [newCollectionId, coupon]
  );
  const callData = {
    from: utils.getAddress(userAddress),
    to: utils.getAddress(this.humansContractAddress),
    id: openseaIdBN,
    data,
  };
  // call the opensea contracts safeTransferFrom fn
  return this.contract.safeTransferFrom(
    callData.from,
    callData.to,
    callData.id,
    1,
    callData.data
  );
}

safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)

const data = utils.defaultAbiCoder.encode(
     ["uint256", "tuple(bytes32 r, bytes32 s, uint8 v)"],
     [newCollectionId, coupon]
  );

function onERC1155Received(
  address,
  address from,
  uint256 id,
  uint256,
  bytes memory data
) public virtual override returns (bytes4) {
  require(
    msg.sender == _openseaSharedContractAddress,
    'Sender not approved'
  );
  (uint256 genesisId, Coupon memory coupon) = abi.decode(
    data(uint256, Coupon)
  );
  ...
}

bytes32 digest = keccak256(
  abi.encode(CouponType.Genesis, genesisId, id)
);

describe('presale minting', async function () {
  it('should be active', async function () {
    await expect(await humansOfNft.phase()).to.equal(1);
  });
  // presaleAddresses are populated using ethers.getSigners();
  presaleAddresses.forEach(async function (account) {
    it('should allow a whitelisted wallet to mint during presale',
      async function () {
        console.log(`${account} is minting presale`);
        let presaleIndex = this.accounts.findIndex(
        (signer: SignerWithAddress) => {
          return ( signer.address === account);
        });
        const tokenCount = Math.ceil(Math.random() * 3);
        const mintPriceInWei = await humansOfNft.mintPrice();
        const mintAmountInEther = parseFloat(
          ethers.utils.formatEther(mintPriceInWei.toString())
        ) * tokenCount;
        const hash = generateHashBuffer(
           ['uint256', 'address',[CouponTypeEnum['Presale'],
           this.accounts[presaleIndex].address]
        );
        const coupon = createCoupon(hash, this.signerPvtKey);
        expect(await humansOfNft.connect(
           this.accounts[presaleIndex]).mintPresale(
             tokenCount, coupon, {
               value: ethers.utils.parseEther(
               mintAmountInEther.toString())
             })
           ).to.emit(humansOfNft, 'Transfer');
        });
    });
})