ボット対策のベストプラクティス

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": "このアセットはミント完了後にリビールされます。各アセットは独特であり、その真の特性と希少性がまもなく公開されます！",
  "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

// Candy Machineを作成する前にセキュアマッピングを生成
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": "リビール後、メタデータハッシュがリビールされたインデックスに対して公開されたハッシュと一致することを検証してください"
}

// オプション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);

// プレースホルダーアイテムをCandy Machineに挿入
await addConfigLines(umi, {
  candyMachine: candyMachine.publicKey,
  index: 0,
  configLines: randomizedItems,
}).sendAndConfirm(umi);

{
  "name": "Mystery Asset",
  "description": "このアセットはミント完了後にリビールされます。各アセットは独特であり、その真の特性と希少性がまもなく公開されます！",
  "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 or 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) or 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: "以下の検証関数を使用してアセットを確認してください"
};

// 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);