Core Candy Machine 봇 방지 보호 모범 사례

https://yourproject.com/metadata/0.json
https://yourproject.com/metadata/1.json
https://yourproject.com/metadata/2.json

import fs from "fs";
import mime from "mime";
import { createGenericFile } from "@metaplex-foundation/umi";

const umi = // umi 인스턴스를 가져오거나 생성합니다.

// 파일 업로드 - UMI가 자동으로 예측 불가능한 트랜잭션 ID 생성
async function uploadFiles(filePaths: string[]): Promise<string[]> {
  const files = filePaths.map((filePath) => {
    const file = fs.readFileSync(filePath);
    const mimeType = mime.getType(filePath);
    return createGenericFile(file, "file", {
      tags: mimeType ? [{ name: "content-type", value: mimeType }] : [],
    });
  });

  const uploadedUris = await umi.uploader.upload(files);

  // 추적을 위해 업로드된 각 URI를 인덱스와 함께 로그
  uploadedUris.forEach((uri, index) => {
    console.log(`Uploaded file #${index} -> ${uri}`);
  });

  return uploadedUris;
}

// 중요: 반환된 모든 URI 저장 - 리빌 매핑에 필요합니다!
const uploadedUris = await uploadFiles(allFilePaths);

// 결과: 저장해야 하는 자동으로 예측 불가능한 URI
// uploadedUris[0] = "https://arweave.net/BrG44HdsEhzapvs8bEqzvkq4egwevS3fRE6kLuCyOdCd"
// uploadedUris[1] = "https://arweave.net/9jK3LpM7NqR5xY8vZ2BwC4tE6gH9sF1D3a7Q8eR2nM4K"
// uploadedUris[2] = "https://arweave.net/5tH8GpN3MqL7wV9xB2CeD4yR6kJ1sK3F8gQ7eP5nL9M2"
// ... 모든 파일에 대해 등등

// 이것들을 안전하게 저장하세요 - 재생성할 수 없습니다!
// 이 URI들은 UMI를 통한 기본 서비스(Irys/ArDrive Turbo)에서 제공됩니다
fs.writeFileSync("./uploaded-uris.json", JSON.stringify(uploadedUris, null, 2));
await securelyStoreUris(uploadedUris);

{
  "name": "Mystery Asset",
  "description": "This asset will be revealed after mint completion. Each asset is unique and will be unveiled with its true traits and rarity soon!",
  "image": "https://yourproject.com/images/mystery-box.png",
  "attributes": [
    {
      "trait_type": "Status",
      "value": "Unrevealed"
    },
    {
      "trait_type": "Collection",
      "value": "Your Project Name"
    }
  ]
}

https://yourproject.com/metadata/placeholder.json

// 캔디 머신 생성 전에 보안 매핑 생성
function generateSecureMapping(totalSupply: number): number[] {
  // 인덱스 배열 생성 [0, 1, 2, ..., totalSupply-1]
  const indices = Array.from({ length: totalSupply }, (_, i) => i);

  // 암호학적으로 안전한 섞기 사용 (Fisher-Yates)
  for (let i = indices.length - 1; i > 0; i--) {
    const j = Math.floor(crypto.getRandomValues(new Uint32Array(1))[0] / (2**32) * (i + 1));
    [indices[i], indices[j]] = [indices[j], indices[i]];
  }

  return indices;
}

// 예시: 4000개의 NFT 컬렉션
const secureMapping = generateSecureMapping(4000);
// 결과: [2847, 91, 3756, 128, 2904, 567, ...]
// 의미:
// - 민트 인덱스 0은 메타데이터 인덱스 2847로 리빌됩니다
// - 민트 인덱스 1은 메타데이터 인덱스 91로 리빌됩니다
// - 민트 인덱스 2는 메타데이터 인덱스 3756으로 리빌됩니다
// 등등.

// 이 매핑을 안전하게 저장 - 리빌 키입니다!
await storeMapping(secureMapping);

// 민트 런칭 전 검증 해시 생성
async function generateVerificationHashes(
  mapping: number[],
  metadataFiles: string[],
  uploadedUris: string[]
): Promise<{masterHash: string, metadataHashes: string[]}> {

  // 1. 각 개별 메타데이터 파일 해시
  const metadataHashes = metadataFiles.map(metadata =>
    crypto.createHash('sha256').update(metadata).digest('hex')
  );

  // 2. 업로드된 URI에서 트랜잭션 ID 추출
  const transactionIds = uploadedUris.map(uri => {
    // URI에서 트랜잭션 ID 추출 (예: https://arweave.net/[ID])
    return uri.split('/').pop();
  });

  // 3. 검증 데이터 구조 생성
  const verificationData = mapping.map((finalIndex, mintIndex) => ({
    mintIndex,
    finalIndex,
    transactionId: transactionIds[finalIndex],
    metadataUri: uploadedUris[finalIndex],
    metadataHash: metadataHashes[finalIndex],
  }));

  // 4. 전체 매핑의 마스터 해시 생성
  const masterHash = crypto
    .createHash('sha256')
    .update(JSON.stringify(verificationData))
    .digest('hex');

  return { masterHash, metadataHashes };
}

const { masterHash, metadataHashes } = await generateVerificationHashes(
  secureMapping,
  allMetadataFiles,
  uploadedUris
);

{
  "projectName": "Your Project",
  "totalSupply": 4000,
  "masterMappingHash": "a7b9c3d2e8f4g5h6i1j0k9l8m7n6o5p4q3r2s1t0u9v8w7x6y5z4",
  "metadataHashes": [
    "b1c2d3e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v1w2x3y4z5a6",
    "c2d3e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v1w2x3y4z5a6b7",
    // ... 4000개의 모든 메타데이터 해시
  ],
  "publishedAt": "2024-01-15T10:00:00Z",
  "verificationInstructions": "After reveal, verify your metadata hash matches the published hash for your revealed index"
}

// 옵션 1: 간단한 플레이스홀더 접근법
const items = Array.from({ length: 4000 }, (_, index) => ({
  name: `Mystery Asset #${index + 1}`,
  uri: "https://yourproject.com/placeholder.json"
}));

// 옵션 2: 추가 예측 불가능성을 위한 사전 무작위화된 플레이스홀더 순서
function createRandomizedPlaceholders(totalSupply: number): ConfigLine[] {
  const indices = Array.from({ length: totalSupply }, (_, i) => i);

  // 무작위 민트 순서를 위한 인덱스 섞기
  for (let i = indices.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [indices[i], indices[j]] = [indices[j], indices[i]];
  }

  return indices.map((randomIndex, position) => ({
    name: `Mystery Asset #${position + 1}`,
    uri: "https://yourproject.com/placeholder.json"
  }));
}

const randomizedItems = createRandomizedPlaceholders(4000);

// 플레이스홀더 아이템을 캔디 머신에 삽입
await addConfigLines(umi, {
  candyMachine: candyMachine.publicKey,
  index: 0,
  configLines: randomizedItems,
}).sendAndConfirm(umi);

{
  "name": "Mystery Asset",
  "description": "This asset will be revealed after mint completion. Each asset is unique and will be unveiled with its true traits and rarity soon!",
  "image": "https://yourproject.com/images/mystery-box.png",
  "attributes": [
    {
      "trait_type": "Status",
      "value": "Unrevealed"
    },
    {
      "trait_type": "Collection",
      "value": "Your Project Name"
    }
  ]
}

// pages/api/mint.ts 또는 app/api/mint/route.ts
// 내장 백엔드 - 별도의 서버가 필요 없습니다!

const guards = {
  thirdPartySigner: {
    signerKey: backendSignerWallet.publicKey,
  },
  botTax: {
    lamports: sol(0.01), // 실패한 시도에 대한 세금
    lastInstruction: true,
  },
  solPayment: {
    lamports: sol(0.1), // 민트 가격
    destination: treasuryWallet.publicKey,
  },
};

// pages/api/mint.ts (Pages Router) 또는 app/api/mint/route.ts (App Router)
import type { NextApiRequest, NextApiResponse } from 'next';

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  try {
    // 1. 사용자 검증 (속도 제한, 캡차 등)
    const { userWallet } = req.body;

    // 2. 필수 가드와 함께 민트 트랜잭션 생성.
    // 프론트엔드에서 추가 가드 인수를 제공해야 할 수 있습니다.
    const mintTransaction = await mintV1(umi, {
      candyMachine: candyMachine.publicKey,
      asset: generateSigner(umi),
      minter: createNoopSigner(userWallet),
      mintArgs: {
        thirdPartySigner: {
          signer: backendSigner,
        },
      },
    }).buildWithLatestBlockhash(umi);;

    // 3. 백엔드 서명자로 부분적으로 서명
    const signedTransaction = await backendSigner.signTransaction(mintTransaction);

    // 4. 사용자가 프론트엔드에서 서명할 트랜잭션 반환
    res.json({
      transaction: base64.encode(signedTransaction.serialize()),
      asset: mintTransaction.asset.publicKey.toString(),
    });

  } catch (error) {
    res.status(500).json({ error: 'Mint failed' });
  }
}

// 전통적인 Express 또는 서버리스 함수
app.post('/api/mint', async (req, res) => {
  try {
    // 1. 사용자 검증 (속도 제한, 캡차 등)
    const { userWallet, captchaToken } = req.body;

    // 2. 필수 가드와 함께 민트 트랜잭션 생성
    const mintTransaction = await mintV1(umi, {
      candyMachine: candyMachine.publicKey,
      asset: generateSigner(umi),
      minter: createNoopSigner(userWallet),
      mintArgs: {
        thirdPartySigner: {
          signer: backendSigner,
        },
      },
    }).buildWithLatestBlockhash(umi);

    // 3. 백엔드 서명자로 부분적으로 서명
    const signedTransaction = await backendSigner.signTransaction(mintTransaction);

    // 4. 사용자가 완료할 트랜잭션 반환
    res.json({
      transaction: base64.encode(signedTransaction.serialize()),
      asset: mintTransaction.asset.publicKey.toString(),
    });

  } catch (error) {
    res.status(500).json({ error: 'Mint failed' });
  }
});

// 리빌 후 완전한 매핑 발표
const fullMappingData = {
  projectName: "Your Project",
  totalSupply: 4000,
  revealDate: "2024-01-20T15:30:00Z",
  mapping: secureMapping.map((finalIndex, mintIndex) => ({
    mintIndex,
    finalIndex,
    transactionId: uploadedUris[finalIndex].split('/').pop(),
    metadataUri: uploadedUris[finalIndex]
  })),
  masterHash: masterHash, // 사전 런칭 검증에서
  verificationInstructions: "Use the verification function below to check your asset"
};

// IPFS, 웹사이트, 커뮤니티 채널에 발표
await publishMapping(fullMappingData);

// 사용자가 자산을 확인하기 위해 실행할 수 있는 검증 함수
function verifyAssetMapping(
  mintIndex: number,
  finalIndex: number,
  receivedMetadata: string,
  publishedHashes: string[]
): boolean {
  // 1. 받은 메타데이터 해시
  const metadataHash = crypto
    .createHash('sha256')
    .update(receivedMetadata)
    .digest('hex');

  // 2. 발표된 해시와 확인
  const expectedHash = publishedHashes[finalIndex];

  // 3. 매핑이 올바른지 확인
  return metadataHash === expectedHash;
}

// 사용자를 위한 사용 예시
const isValid = verifyAssetMapping(
  0, // 민트 인덱스
  2847, // 리빌된 최종 인덱스
  theirMetadataJson, // 받은 메타데이터
  publishedMetadataHashes // 민팅 전 발표된 해시
);

console.log(`Asset verification: ${isValid ? 'VALID' : 'INVALID'}`);

// 지갑당 속도 제한 구현
const mintAttempts = new Map<string, number>();

function checkRateLimit(wallet: string): boolean {
  const attempts = mintAttempts.get(wallet) || 0;
  return attempts < MAX_ATTEMPTS_PER_HOUR;
}

// 의심스러운 패턴 모니터링
function detectSuspiciousActivity(requests: MintRequest[]): boolean {
  // 동일한 타이밍 패턴 확인
  // 여러 지갑에서 연속적인 요청 탐지
  // 동일한 메타데이터를 가진 요청 플래그
  return false; // 탐지 로직 구현
}

// express-rate-limit으로 속도 제한 구현
import rateLimit from 'express-rate-limit';

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 5, // 각 IP를 windowMs당 5개 요청으로 제한
});

// API 라우트에 미들웨어 사용
export default limiter(handler);