# プロジェクトディレクトリ作成
mkdir nft-multichain-deploy
cd nft-multichain-deploy

# Python仮想環境作成（推奨）
python -m venv venv
source venv/bin/activate  # Windows: venv\\Scripts\\activate

# 必要なライブラリインストール
pip install -r requirements.txt

web3>=6.15.0
eth-account>=0.10.0
Pillow>=10.0.0
aiohttp>=3.9.0

export PRIVATE_KEY="your_private_key_here"

export MNEMONIC="your twelve word mnemonic phrase here"
export WALLET_INDEX=0

# プロジェクト基本情報
export NFT_NAME="Layer2 NFT Collection"
export NFT_SYMBOL="L2NFT"
export NFT_DESCRIPTION="A multichain NFT collection deployed across Layer2 networks"
export NFT_MAX_SUPPLY=10000
export NFT_ROYALTY_BASIS_POINTS=750  # 7.5%

# デプロイ対象チェーン
export TARGET_CHAINS="arbitrum,polygon,optimism"

# IPFS設定（オプション）
export PINATA_API_KEY="your_pinata_api_key"
export PINATA_SECRET_KEY="your_pinata_secret_key"

# config.py - NFT設定管理システム
import os
from dataclasses import dataclass
from typing import Dict, List, Optional
from enum import Enum

class NFTStandard(Enum):
    """NFT標準規格"""
    ERC721 = "ERC721"
    ERC1155 = "ERC1155"

@dataclass
class ChainConfig:
    """チェーン設定"""
    name: str
    chain_id: int
    rpc_url: str
    explorer_url: str
    native_token: str
    gas_multiplier: float  # ガス価格調整用
    confirmation_blocks: int  # 確認ブロック数

@dataclass
class ContractConfig:
    """コントラクト設定"""
    name: str
    symbol: str
    description: str
    image_base_uri: str
    external_link: str
    seller_fee_basis_points: int  # ロイヤリティ
    fee_recipient: str
    max_supply: Optional[int] = None

def load_config():
    """設定をロード"""
    
    # サポートチェーン定義
    chains = {
        "ethereum": ChainConfig(
            name="Ethereum Mainnet",
            chain_id=1,
            rpc_url=os.getenv('ETHEREUM_RPC_URL', 'https://eth.llamarpc.com'),
            explorer_url="https://etherscan.io",
            native_token="ETH",
            gas_multiplier=1.2,
            confirmation_blocks=5
        ),
        "arbitrum": ChainConfig(
            name="Arbitrum One",
            chain_id=42161,
            rpc_url=os.getenv('ARBITRUM_RPC_URL', 'https://arb1.arbitrum.io/rpc'),
            explorer_url="https://arbiscan.io",
            native_token="ETH",
            gas_multiplier=1.1,
            confirmation_blocks=1
        ),
        "polygon": ChainConfig(
            name="Polygon Mainnet",
            chain_id=137,
            rpc_url=os.getenv('POLYGON_RPC_URL', 'https://polygon-rpc.com'),
            explorer_url="https://polygonscan.com",
            native_token="MATIC",
            gas_multiplier=1.3,
            confirmation_blocks=10
        ),
        "optimism": ChainConfig(
            name="Optimism Mainnet",
            chain_id=10,
            rpc_url=os.getenv('OPTIMISM_RPC_URL', 'https://mainnet.optimism.io'),
            explorer_url="https://optimistic.etherscan.io",
            native_token="ETH",
            gas_multiplier=1.1,
            confirmation_blocks=1
        ),
        "base": ChainConfig(
            name="Base Mainnet",
            chain_id=8453,
            rpc_url=os.getenv('BASE_RPC_URL', 'https://mainnet.base.org'),
            explorer_url="https://basescan.org",
            native_token="ETH",
            gas_multiplier=1.1,
            confirmation_blocks=1
        ),
        # テストネット
        "sepolia": ChainConfig(
            name="Ethereum Sepolia",
            chain_id=11155111,
            rpc_url=os.getenv('SEPOLIA_RPC_URL', 'https://rpc.sepolia.org'),
            explorer_url="https://sepolia.etherscan.io",
            native_token="SepoliaETH",
            gas_multiplier=1.1,
            confirmation_blocks=2
        )
    }
    
    # コントラクト設定
    contract_config = ContractConfig(
        name=os.getenv('NFT_NAME', 'Layer2 NFT Collection'),
        symbol=os.getenv('NFT_SYMBOL', 'L2NFT'),
        description=os.getenv('NFT_DESCRIPTION', 'A multichain NFT collection'),
        image_base_uri=os.getenv('NFT_IMAGE_BASE_URI', 'https://api.example.com/metadata/'),
        external_link=os.getenv('NFT_EXTERNAL_LINK', 'https://example.com'),
        seller_fee_basis_points=int(os.getenv('NFT_ROYALTY_BASIS_POINTS', '750')),
        fee_recipient=os.getenv('NFT_FEE_RECIPIENT', ''),
        max_supply=int(os.getenv('NFT_MAX_SUPPLY', '10000')) if os.getenv('NFT_MAX_SUPPLY') else None
    )
    
    return {
        'chains': chains,
        'contract_config': contract_config,
        'target_chains': os.getenv('TARGET_CHAINS', 'arbitrum,polygon,optimism').split(','),
        'nft_standard': NFTStandard(os.getenv('NFT_STANDARD', 'ERC721')),
        'verify_contracts': os.getenv('VERIFY_CONTRACTS', 'true').lower() == 'true'
    }

# contract_deployer.py - NFTデプロイエンジン
import asyncio
from typing import Dict, NamedTuple
from decimal import Decimal
from datetime import datetime
from web3 import Web3
from web3.middleware import geth_poa_middleware
from eth_account import Account

class DeploymentResult(NamedTuple):
    """デプロイ結果"""
    chain_name: str
    contract_address: str
    transaction_hash: str
    gas_used: int
    deployment_cost: Decimal
    block_number: int
    timestamp: datetime

class ContractDeployer:
    """NFTコントラクトデプロイエンジン"""
    
    def __init__(self, config):
        self.config = config
        self.web3_instances = {}
        self.account = None
        self.deployment_results = []
        
    def initialize(self):
        """初期化処理"""
        try:
            print("🚀 NFTデプロイエンジン初期化中...")
            
            # ウォレット設定
            if not self._setup_wallet():
                return False
            
            # Web3インスタンス初期化
            target_chains = self.config['target_chains']
            
            for chain_name in target_chains:
                chain_config = self.config['chains'].get(chain_name)
                if not chain_config:
                    print(f"❌ 未対応チェーン: {chain_name}")
                    return False
                
                try:
                    web3 = Web3(Web3.HTTPProvider(chain_config.rpc_url))
                    
                    # Layer2の場合はミドルウェア追加
                    if chain_config.chain_id in [137, 42161, 10, 8453]:
                        web3.middleware_onion.inject(geth_poa_middleware, layer=0)
                    
                    if web3.is_connected():
                        self.web3_instances[chain_name] = web3
                        print(f"✅ {chain_config.name} 接続成功")
                    else:
                        print(f"❌ {chain_config.name} 接続失敗")
                        return False
                        
                except Exception as e:
                    print(f"❌ {chain_config.name} 初期化エラー: {e}")
                    return False
            
            print(f"✅ デプロイエンジン初期化完了 ({len(self.web3_instances)} チェーン)")
            return True
            
        except Exception as e:
            print(f"❌ 初期化エラー: {e}")
            return False
    
    def _setup_wallet(self):
        """ウォレット設定"""
        try:
            private_key = os.getenv('PRIVATE_KEY')
            mnemonic = os.getenv('MNEMONIC')
            
            if private_key:
                self.account = Account.from_key(private_key)
                print(f"✅ ウォレット設定完了: {self.account.address}")
                return True
            elif mnemonic:
                Account.enable_unaudited_hdwallet_features()
                wallet_index = int(os.getenv('WALLET_INDEX', '0'))
                self.account = Account.from_mnemonic(
                    mnemonic,
                    account_path=f"m/44'/60'/0'/0/{wallet_index}"
                )
                print(f"✅ ウォレット設定完了: {self.account.address}")
                return True
            else:
                print("❌ PRIVATE_KEY または MNEMONIC が設定されていません")
                return False
                
        except Exception as e:
            print(f"❌ ウォレット設定エラー: {e}")
            return False
    
    def get_contract_bytecode(self):
        """ERC721コントラクトバイトコードとABI"""
        # 実際の実装では、solidityでコンパイルしたバイトコードを使用
        # ここでは簡易版のABIとバイトコードを使用
        
        abi = [
            {
                "inputs": [
                    {"name": "name", "type": "string"},
                    {"name": "symbol", "type": "string"},
                    {"name": "baseTokenURI", "type": "string"},
                    {"name": "owner", "type": "address"}
                ],
                "stateMutability": "nonpayable",
                "type": "constructor"
            },
            {
                "inputs": [],
                "name": "name",
                "outputs": [{"name": "", "type": "string"}],
                "stateMutability": "view",
                "type": "function"
            },
            {
                "inputs": [],
                "name": "symbol", 
                "outputs": [{"name": "", "type": "string"}],
                "stateMutability": "view",
                "type": "function"
            },
            {
                "inputs": [
                    {"name": "to", "type": "address"},
                    {"name": "tokenId", "type": "uint256"}
                ],
                "name": "mint",
                "outputs": [],
                "stateMutability": "nonpayable",
                "type": "function"
            }
        ]
        
        # プレースホルダーバイトコード（実際の実装では実際のコンパイル結果を使用）
        bytecode = "0x608060405234801561001057600080fd5b50..."
        
        return bytecode, abi
    
    async def estimate_deployment_gas(self, chain_name, constructor_args):
        """デプロイガス見積もり"""
        try:
            web3 = self.web3_instances.get(chain_name)
            chain_config = self.config['chains'][chain_name]
            
            # コントラクトバイトコード取得
            bytecode, abi = self.get_contract_bytecode()
            
            # コントラクト作成
            contract = web3.eth.contract(abi=abi, bytecode=bytecode)
            
            # ガス見積もり
            gas_estimate = contract.constructor(*constructor_args).estimate_gas({
                'from': self.account.address
            })
            
            # ガス価格取得
            gas_price = web3.eth.gas_price
            gas_price_adjusted = int(gas_price * chain_config.gas_multiplier)
            
            # コスト計算
            estimated_cost = gas_estimate * gas_price_adjusted
            estimated_cost_ether = web3.from_wei(estimated_cost, 'ether')
            
            print(f"💰 {chain_config.name} ガス見積もり: {gas_estimate:,} gas @ {web3.from_wei(gas_price_adjusted, 'gwei'):.2f} Gwei = {estimated_cost_ether:.6f} {chain_config.native_token}")
            
            return {
                'gas_estimate': gas_estimate,
                'gas_price': gas_price_adjusted,
                'estimated_cost': estimated_cost,
                'estimated_cost_ether': float(estimated_cost_ether),
                'native_token': chain_config.native_token
            }
            
        except Exception as e:
            print(f"❌ {chain_name} ガス見積もりエラー: {e}")
            raise
    
    async def deploy_contract(self, chain_name):
        """単一チェーンにコントラクトをデプロイ"""
        try:
            web3 = self.web3_instances[chain_name]
            chain_config = self.config['chains'][chain_name]
            contract_config = self.config['contract_config']
            
            print(f"🚀 {chain_config.name} デプロイ開始...")
            
            # コンストラクタ引数準備
            base_uri = contract_config.image_base_uri
            if not base_uri.endswith('/'):
                base_uri += '/'
            
            constructor_args = [
                contract_config.name,
                contract_config.symbol,
                base_uri,
                contract_config.fee_recipient or self.account.address
            ]
            
            # ガス見積もり
            gas_info = await self.estimate_deployment_gas(chain_name, constructor_args)
            
            # コントラクトバイトコード取得
            bytecode, abi = self.get_contract_bytecode()
            
            # コントラクト作成
            contract = web3.eth.contract(abi=abi, bytecode=bytecode)
            
            # トランザクション構築
            constructor = contract.constructor(*constructor_args)
            
            gas_limit = int(gas_info['gas_estimate'] * 1.2)  # 20%バッファ
            
            transaction = constructor.build_transaction({
                'from': self.account.address,
                'gas': gas_limit,
                'gasPrice': gas_info['gas_price'],
                'nonce': web3.eth.get_transaction_count(self.account.address),
                'chainId': chain_config.chain_id
            })
            
            # トランザクション署名
            signed_txn = self.account.sign_transaction(transaction)
            
            # トランザクション送信
            print(f"📡 {chain_config.name} トランザクション送信中...")
            tx_hash = web3.eth.send_raw_transaction(signed_txn.rawTransaction)
            
            # トランザクション確認待機
            print(f"⏳ {chain_config.name} トランザクション確認待機: {tx_hash.hex()}")
            tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
            
            if tx_receipt.status == 1:
                # 成功
                deployed_contract_address = tx_receipt.contractAddress
                
                gas_used = tx_receipt.gasUsed
                effective_gas_price = tx_receipt.effectiveGasPrice
                deployment_cost = Decimal(str(gas_used * effective_gas_price))
                deployment_cost_ether = web3.from_wei(deployment_cost, 'ether')
                
                result = DeploymentResult(
                    chain_name=chain_name,
                    contract_address=deployed_contract_address,
                    transaction_hash=tx_hash.hex(),
                    gas_used=gas_used,
                    deployment_cost=Decimal(str(deployment_cost_ether)),
                    block_number=tx_receipt.blockNumber,
                    timestamp=datetime.now()
                )
                
                print(f"✅ {chain_config.name} デプロイ成功!")
                print(f"   📍 コントラクトアドレス: {deployed_contract_address}")
                print(f"   💰 デプロイコスト: {deployment_cost_ether:.6f} {chain_config.native_token}")
                print(f"   🔗 Explorer: {chain_config.explorer_url}/address/{deployed_contract_address}")
                
                self.deployment_results.append(result)
                return result
                
            else:
                raise Exception(f"トランザクション失敗: {tx_hash.hex()}")
                
        except Exception as e:
            print(f"❌ {chain_name} デプロイ失敗: {e}")
            raise
    
    async def deploy_to_multiple_chains(self):
        """複数チェーンに並行デプロイ"""
        try:
            target_chains = self.config['target_chains']
            
            print(f"🌐 マルチチェーンデプロイ開始: {len(target_chains)} チェーン")
            
            # 並行デプロイ（バッチサイズ制限）
            batch_size = 3  # 同時デプロイ数制限
            all_results = []
            
            for i in range(0, len(target_chains), batch_size):
                batch = target_chains[i:i + batch_size]
                print(f"📦 バッチ {i//batch_size + 1}: {batch}")
                
                tasks = [self.deploy_contract(chain_name) for chain_name in batch]
                batch_results = await asyncio.gather(*tasks, return_exceptions=True)
                
                for chain_name, result in zip(batch, batch_results):
                    if isinstance(result, Exception):
                        print(f"❌ {chain_name} デプロイエラー: {result}")
                    else:
                        all_results.append(result)
                
                # 次のバッチまで少し待機
                if i + batch_size < len(target_chains):
                    print("⏳ 30秒待機中...")
                    await asyncio.sleep(30)
            
            print(f"🎉 マルチチェーンデプロイ完了: {len(all_results)}/{len(target_chains)} 成功")
            return all_results
            
        except Exception as e:
            print(f"❌ マルチチェーンデプロイエラー: {e}")
            raise
    
    def print_deployment_summary(self, results):
        """デプロイ結果サマリー表示"""
        print(f"""
🎉 NFTマルチチェーンデプロイ完了! 🎉
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 デプロイ情報
   NFT名: {self.config['contract_config'].name}
   シンボル: {self.config['contract_config'].symbol}
   標準: {self.config['nft_standard'].value}
   デプロイヤー: {self.account.address}

🌐 デプロイ結果 ({len(results)} チェーン)""")
        
        total_cost = Decimal('0')
        
        for result in results:
            chain_config = self.config['chains'][result.chain_name]
            print(f"""
   🔗 {chain_config.name}
      📍 アドレス: {result.contract_address}
      💰 コスト: {result.deployment_cost:.6f} {chain_config.native_token}
      ⛽ ガス使用: {result.gas_used:,}
      🌐 Explorer: {chain_config.explorer_url}/address/{result.contract_address}""")
            
            total_cost += result.deployment_cost
        
        print(f"""
💰 総デプロイコスト: 約 {total_cost:.6f} ETH相当

🚀 次のステップ:
   1. メタデータのIPFS準備
   2. ミント機能のテスト
   3. OpenSeaでの確認
   4. マーケティング開始

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚡ NFTマルチチェーンデプロイツール by pontanuki.com
""")

# metadata_manager.py - NFTメタデータ管理システム
import json
import hashlib
from typing import Dict, List
from datetime import datetime
from PIL import Image, ImageDraw, ImageFont
import io

class MetadataManager:
    """NFTメタデータ管理システム"""
    
    def __init__(self, config):
        self.config = config
        self.generated_metadata = {}
        
    def generate_token_metadata(self, token_id, chain_name="ethereum", custom_attributes=None):
        """個別トークンのメタデータ生成"""
        try:
            contract_config = self.config['contract_config']
            
            # 基本メタデータ
            metadata = {
                "name": f"{contract_config.name} #{token_id}",
                "description": f"Token #{token_id} from {contract_config.name} collection",
                "image": f"https://api.example.com/images/{token_id}.png",
                "external_url": contract_config.external_link,
                "attributes": []
            }
            
            # 属性（トレイト）設定
            attributes = [
                {
                    "trait_type": "Token ID",
                    "value": token_id,
                    "display_type": "number"
                },
                {
                    "trait_type": "Network",
                    "value": chain_name.title()
                },
                {
                    "trait_type": "Minted Date",
                    "value": datetime.now().strftime("%Y-%m-%d"),
                    "display_type": "date"
                }
            ]
            
            # レアリティ属性の動的生成
            rarity_attributes = self._generate_rarity_attributes(token_id)
            attributes.extend(rarity_attributes)
            
            # カスタム属性追加
            if custom_attributes:
                attributes.extend(custom_attributes)
            
            metadata["attributes"] = attributes
            
            # OpenSea互換性フィールド
            metadata.update({
                "background_color": "000000",
                "seller_fee_basis_points": contract_config.seller_fee_basis_points,
                "fee_recipient": contract_config.fee_recipient
            })
            
            print(f"✅ Token #{token_id} メタデータ生成完了")
            self.generated_metadata[token_id] = metadata
            
            return metadata
            
        except Exception as e:
            print(f"❌ Token #{token_id} メタデータ生成エラー: {e}")
            raise
    
    def _generate_rarity_attributes(self, token_id):
        """レアリティ属性の動的生成"""
        import random
        random.seed(token_id)  # トークンIDをシードとして使用
        
        attributes = []
        
        # レアリティレベル決定
        rarity_roll = random.randint(1, 100)
        if rarity_roll <= 1:
            rarity = "Legendary"
            rarity_score = 100
        elif rarity_roll <= 5:
            rarity = "Epic"
            rarity_score = 75
        elif rarity_roll <= 15:
            rarity = "Rare"
            rarity_score = 50
        elif rarity_roll <= 40:
            rarity = "Uncommon"
            rarity_score = 25
        else:
            rarity = "Common"
            rarity_score = 10
        
        attributes.extend([
            {
                "trait_type": "Rarity",
                "value": rarity
            },
            {
                "trait_type": "Rarity Score",
                "value": rarity_score,
                "display_type": "boost_number"
            }
        ])
        
        # 色属性
        colors = ["Red", "Blue", "Green", "Yellow", "Purple", "Orange", "Pink", "Cyan"]
        background_colors = ["Light", "Dark", "Gradient", "Solid"]
        
        attributes.extend([
            {
                "trait_type": "Primary Color",
                "value": random.choice(colors)
            },
            {
                "trait_type": "Background",
                "value": random.choice(background_colors)
            }
        ])
        
        # 数値属性（ゲーム性）
        attributes.extend([
            {
                "trait_type": "Power",
                "value": random.randint(1, 100),
                "display_type": "number"
            },
            {
                "trait_type": "Speed",
                "value": random.randint(1, 100),
                "display_type": "number"
            },
            {
                "trait_type": "Luck",
                "value": random.randint(1, 100),
                "display_type": "boost_percentage"
            }
        ])
        
        return attributes
    
    def generate_placeholder_image(self, token_id, width=512, height=512):
        """プレースホルダー画像生成"""
        try:
            # 新しい画像を作成
            img = Image.new('RGB', (width, height), color='#f0f0f0')
            draw = ImageDraw.Draw(img)
            
            # トークンIDに基づく色生成
            import random
            random.seed(token_id)
            
            r = random.randint(50, 200)
            g = random.randint(50, 200)
            b = random.randint(50, 200)
            color = (r, g, b)
            
            # 背景グラデーション
            for y in range(height):
                gradient_color = (
                    int(r * (1 - y / height) + 255 * (y / height)),
                    int(g * (1 - y / height) + 255 * (y / height)),
                    int(b * (1 - y / height) + 255 * (y / height))
                )
                draw.line([(0, y), (width, y)], fill=gradient_color)
            
            # 中央に円を描画
            circle_size = min(width, height) // 3
            circle_x = (width - circle_size) // 2
            circle_y = (height - circle_size) // 2
            draw.ellipse([circle_x, circle_y, circle_x + circle_size, circle_y + circle_size], 
                        fill=color, outline='#333333', width=3)
            
            # テキスト描画
            text = f"#{token_id}"
            try:
                font = ImageFont.truetype("arial.ttf", 24)
            except:
                font = ImageFont.load_default()
            
            text_bbox = draw.textbbox((0, 0), text, font=font)
            text_width = text_bbox[2] - text_bbox[0]
            text_height = text_bbox[3] - text_bbox[1]
            text_x = (width - text_width) // 2
            text_y = (height - text_height) // 2
            
            draw.text((text_x, text_y), text, fill='#333333', font=font)
            
            # バイトデータに変換
            img_byte_arr = io.BytesIO()
            img.save(img_byte_arr, format='PNG')
            img_byte_arr.seek(0)
            
            print(f"✅ Token #{token_id} プレースホルダー画像生成完了")
            return img_byte_arr.getvalue()
            
        except Exception as e:
            print(f"❌ Token #{token_id} 画像生成エラー: {e}")
            raise
    
    def generate_batch_metadata(self, token_count, start_token_id=1):
        """バッチでメタデータ生成"""
        try:
            print(f"🔄 バッチメタデータ生成開始: {token_count} トークン")
            
            batch_metadata = {}
            
            for i in range(token_count):
                token_id = start_token_id + i
                metadata = self.generate_token_metadata(token_id)
                batch_metadata[token_id] = metadata
            
            print(f"✅ バッチメタデータ生成完了: {len(batch_metadata)} トークン")
            return batch_metadata
            
        except Exception as e:
            print(f"❌ バッチメタデータ生成エラー: {e}")
            raise
    
    def save_metadata_files(self, metadata_batch, include_images=True):
        """メタデータファイル保存"""
        try:
            from pathlib import Path
            
            print(f"📦 メタデータファイル保存開始: {len(metadata_batch)} トークン")
            
            # ディレクトリ作成
            metadata_dir = Path("metadata")
            images_dir = metadata_dir / "images"
            json_dir = metadata_dir / "json"
            
            metadata_dir.mkdir(exist_ok=True)
            images_dir.mkdir(exist_ok=True)
            json_dir.mkdir(exist_ok=True)
            
            # 各トークンのファイル保存
            for token_id, metadata in metadata_batch.items():
                # JSONメタデータ保存
                json_filename = f"{token_id}.json"
                json_path = json_dir / json_filename
                
                with open(json_path, 'w', encoding='utf-8') as f:
                    json.dump(metadata, f, indent=2, ensure_ascii=False)
                
                # プレースホルダー画像生成・保存
                if include_images:
                    image_filename = f"{token_id}.png"
                    image_path = images_dir / image_filename
                    
                    image_data = self.generate_placeholder_image(token_id)
                    
                    with open(image_path, 'wb') as f:
                        f.write(image_data)
            
            print(f"✅ メタデータファイル保存完了:")
            print(f"   📁 保存先: {metadata_dir}")
            print(f"   📊 メタデータ: {len(list(json_dir.glob('*.json')))} ファイル")
            print(f"   🖼️ 画像: {len(list(images_dir.glob('*.png')))} ファイル")
            
            return {
                'metadata_dir': str(metadata_dir),
                'json_count': len(list(json_dir.glob('*.json'))),
                'image_count': len(list(images_dir.glob('*.png')))
            }
            
        except Exception as e:
            print(f"❌ メタデータファイル保存エラー: {e}")
            raise

# main.py - NFTマルチチェーンデプロイシステム
import asyncio
import argparse
from config import load_config
from contract_deployer import ContractDeployer
from metadata_manager import MetadataManager

class NFTMultiChainDeployer:
    """NFTマルチチェーンデプロイシステム"""
    
    def __init__(self):
        self.config = load_config()
        self.contract_deployer = ContractDeployer(self.config)
        self.metadata_manager = MetadataManager(self.config)
        
    async def deploy_contracts(self):
        """コントラクトデプロイ実行"""
        try:
            print("🚀 NFTマルチチェーンデプロイ開始")
            
            # 初期化
            if not self.contract_deployer.initialize():
                print("❌ デプロイエンジン初期化失敗")
                return False
            
            # マルチチェーンデプロイ実行
            results = await self.contract_deployer.deploy_to_multiple_chains()
            
            if results:
                # 結果表示
                self.contract_deployer.print_deployment_summary(results)
                
                # 結果保存
                self.save_deployment_results(results)
                
                return True
            else:
                print("❌ 全チェーンでのデプロイに失敗")
                return False
                
        except Exception as e:
            print(f"❌ デプロイエラー: {e}")
            return False
    
    def generate_metadata(self, token_count=100):
        """メタデータ生成・保存"""
        try:
            print(f"📦 メタデータ生成開始: {token_count} トークン")
            
            # バッチメタデータ生成
            metadata_batch = self.metadata_manager.generate_batch_metadata(token_count)
            
            # ファイル保存
            save_result = self.metadata_manager.save_metadata_files(metadata_batch)
            
            print("✅ メタデータ生成完了")
            return save_result
            
        except Exception as e:
            print(f"❌ メタデータ生成エラー: {e}")
            return False
    
    def save_deployment_results(self, results):
        """デプロイ結果保存"""
        try:
            import json
            from pathlib import Path
            from datetime import datetime
            
            results_dir = Path("deployments")
            results_dir.mkdir(exist_ok=True)
            
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = results_dir / f"deployment_{timestamp}.json"
            
            deployment_data = {
                'deployment_info': {
                    'timestamp': datetime.now().isoformat(),
                    'deployer_address': self.contract_deployer.account.address,
                    'nft_standard': self.config['nft_standard'].value,
                    'contract_config': {
                        'name': self.config['contract_config'].name,
                        'symbol': self.config['contract_config'].symbol,
                        'description': self.config['contract_config'].description
                    }
                },
                'deployments': []
            }
            
            for result in results:
                deployment_info = {
                    'chain_name': result.chain_name,
                    'contract_address': result.contract_address,
                    'transaction_hash': result.transaction_hash,
                    'gas_used': result.gas_used,
                    'deployment_cost': str(result.deployment_cost),
                    'block_number': result.block_number,
                    'timestamp': result.timestamp.isoformat(),
                    'explorer_url': f"{self.config['chains'][result.chain_name].explorer_url}/address/{result.contract_address}"
                }
                deployment_data['deployments'].append(deployment_info)
            
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(deployment_data, f, indent=2, ensure_ascii=False)
            
            print(f"💾 デプロイ結果保存: {filename}")
            
        except Exception as e:
            print(f"⚠️ 結果保存エラー: {e}")

def print_banner():
    """システムバナー表示"""
    print("""
╔══════════════════════════════════════════════════════════════╗
║            🎨 NFTマルチチェーンデプロイシステム 🎨            ║  
║                                                              ║
║    Python一発で複数ブロックチェーンにNFTコレクションを       ║
║    同時展開！メタデータ生成からIPFS統合まで完全自動化        ║
╚══════════════════════════════════════════════════════════════╝
""")

async def main():
    """メイン実行関数"""
    parser = argparse.ArgumentParser(description="NFTマルチチェーンデプロイシステム")
    
    parser.add_argument('--deploy', action='store_true', help='コントラクトデプロイ実行')
    parser.add_argument('--metadata', type=int, help='メタデータ生成（トークン数指定）')
    parser.add_argument('--estimate', action='store_true', help='デプロイコスト見積もり')
    
    args = parser.parse_args()
    
    print_banner()
    
    deployer = NFTMultiChainDeployer()
    
    try:
        if args.deploy:
            # コントラクトデプロイ
            success = await deployer.deploy_contracts()
            if not success:
                exit(1)
                
        elif args.metadata:
            # メタデータ生成
            deployer.generate_metadata(args.metadata)
            
        elif args.estimate:
            # コスト見積もり
            deployer.contract_deployer.estimate_total_deployment_cost()
            
        else:
            # ヘルプ表示
            parser.print_help()
            
    except KeyboardInterrupt:
        print("\n👋 ユーザーによる停止")
    except Exception as e:
        print(f"❌ システムエラー: {e}")

if __name__ == "__main__":
    asyncio.run(main())

# 1. デプロイコスト見積もり
python main.py --estimate

# 2. メタデータ生成（100トークン）
python main.py --metadata 100

# 3. コントラクトデプロイ実行
python main.py --deploy

🎨 NFTマルチチェーンデプロイシステム 🎨

🚀 NFTデプロイエンジン初期化中...
✅ ウォレット設定完了: 0x1234...5678
✅ Arbitrum One 接続成功
✅ Polygon Mainnet 接続成功
✅ Optimism Mainnet 接続成功
✅ デプロイエンジン初期化完了 (3 チェーン)

🌐 マルチチェーンデプロイ開始: 3 チェーン
📦 バッチ 1: ['arbitrum', 'polygon', 'optimism']

🚀 Arbitrum One デプロイ開始...
💰 Arbitrum One ガス見積もり: 2,841,234 gas @ 0.12 Gwei = 0.000341 ETH
📡 Arbitrum One トランザクション送信中...
⏳ Arbitrum One トランザクション確認待機: 0xabcd...
✅ Arbitrum One デプロイ成功!
   📍 コントラクトアドレス: 0x9876...4321
   💰 デプロイコスト: 0.000341 ETH
   🔗 Explorer: https://arbiscan.io/address/0x9876...4321

[他のチェーンでも同様にデプロイ実行...]

🎉 NFTマルチチェーンデプロイ完了! 🎉
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 デプロイ情報
   NFT名: Layer2 NFT Collection
   シンボル: L2NFT
   標準: ERC721
   デプロイヤー: 0x1234...5678

🌐 デプロイ結果 (3 チェーン)

   🔗 Arbitrum One
      📍 アドレス: 0x9876...4321
      💰 コスト: 0.000341 ETH
      ⛽ ガス使用: 2,841,234
      🌐 Explorer: https://arbiscan.io/address/0x9876...4321

   🔗 Polygon Mainnet
      📍 アドレス: 0x5432...8765
      💰 コスト: 0.145000 MATIC
      ⛽ ガス使用: 2,900,000
      🌐 Explorer: https://polygonscan.com/address/0x5432...8765

   🔗 Optimism Mainnet
      📍 アドレス: 0x1357...9024
      💰 コスト: 0.000298 ETH
      ⛽ ガス使用: 2,780,000
      🌐 Explorer: https://optimistic.etherscan.io/address/0x1357...9024

💰 総デプロイコスト: 約 0.000639 ETH相当

🚀 次のステップ:
   1. メタデータのIPFS準備
   2. ミント機能のテスト
   3. OpenSeaでの確認
   4. マーケティング開始

def generate_opensea_metadata(self, token_id, chain_name):
    """OpenSea最適化メタデータ"""
    metadata = self.generate_token_metadata(token_id, chain_name)
    
    # OpenSea固有フィールド追加
    metadata.update({
        "animation_url": None,  # MP4/GIFアニメーション（オプション）
        "youtube_url": None,    # YouTube動画（オプション）
        "background_color": "000000",  # 背景色（16進数）
        "image_data": None,     # SVGデータ（オプション）
        "external_url": f"https://yourproject.com/token/{token_id}",
        
        # コレクション情報
        "collection": {
            "name": self.config['contract_config'].name,
            "family": "Layer2 NFT Collection",
            "description": self.config['contract_config'].description,
            "image": "https://yourproject.com/collection-image.png",
            "banner": "https://yourproject.com/banner-image.png",
            "featured": "https://yourproject.com/featured-image.png",
            "categories": ["art", "collectibles", "utility"],
            "website": self.config['contract_config'].external_link,
            "discord": "https://discord.gg/yourproject",
            "twitter": "https://twitter.com/yourproject"
        }
    })
    
    return metadata

async def upload_to_ipfs_pinata(self, content, filename):
    """Pinata経由でIPFSにアップロード"""
    try:
        import aiohttp
        
        pinata_api_key = os.getenv('PINATA_API_KEY')
        pinata_secret_key = os.getenv('PINATA_SECRET_KEY')
        
        if not pinata_api_key or not pinata_secret_key:
            print("⚠️ Pinata API設定なし、IPFSアップロードをスキップ")
            return None
        
        url = "https://api.pinata.cloud/pinning/pinFileToIPFS"
        
        headers = {
            'pinata_api_key': pinata_api_key,
            'pinata_secret_api_key': pinata_secret_key
        }
        
        data = aiohttp.FormData()
        data.add_field('file', content, filename=filename)
        
        # メタデータ
        pinata_metadata = {
            "name": filename,
            "keyvalues": {
                "project": "nft-multichain-deploy",
                "type": "image" if filename.endswith('.png') else "metadata",
                "timestamp": datetime.now().isoformat()
            }
        }
        data.add_field('pinataMetadata', json.dumps(pinata_metadata))
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, headers=headers, data=data) as response:
                if response.status == 200:
                    result = await response.json()
                    ipfs_hash = result['IpfsHash']
                    ipfs_url = f"https://ipfs.io/ipfs/{ipfs_hash}"
                    
                    print(f"✅ IPFS アップロード成功: {filename} → {ipfs_hash}")
                    return ipfs_url
                else:
                    print(f"❌ IPFS アップロード失敗: {response.status}")
                    return None
                    
    except Exception as e:
        print(f"❌ IPFS アップロードエラー: {e}")
        return None

def analyze_rarity_distribution(self, metadata_batch):
    """レアリティ分布分析"""
    try:
        trait_counts = {}
        rarity_counts = {}
        
        for token_id, metadata in metadata_batch.items():
            attributes = metadata.get('attributes', [])
            
            for attr in attributes:
                trait_type = attr.get('trait_type')
                value = attr.get('value')
                
                if trait_type and value is not None:
                    if trait_type not in trait_counts:
                        trait_counts[trait_type] = {}
                    
                    if value not in trait_counts[trait_type]:
                        trait_counts[trait_type][value] = 0
                    
                    trait_counts[trait_type][value] += 1
                    
                    # レアリティ特別処理
                    if trait_type == "Rarity":
                        if value not in rarity_counts:
                            rarity_counts[value] = 0
                        rarity_counts[value] += 1
        
        # パーセンテージ計算
        total_tokens = len(metadata_batch)
        rarity_distribution = {}
        
        for rarity, count in rarity_counts.items():
            percentage = (count / total_tokens) * 100
            rarity_distribution[rarity] = {
                'count': count,
                'percentage': round(percentage, 2)
            }
        
        print("✅ レアリティ分布分析完了")
        print("📊 レアリティ分布:")
        for rarity, data in rarity_distribution.items():
            print(f"   {rarity}: {data['count']} 個 ({data['percentage']}%)")
        
        return {
            'rarity_distribution': rarity_distribution,
            'trait_counts': trait_counts,
            'total_tokens': total_tokens
        }
        
    except Exception as e:
        print(f"❌ レアリティ分布分析エラー: {e}")
        return {}

# 収益計算例
def calculate_mint_revenue():
    total_supply = 10000
    mint_price_eth = 0.05  # 0.05 ETH per NFT
    
    # フェーズ別価格設定
    phases = {
        'early_bird': {'count': 1000, 'price': 0.03},
        'whitelist': {'count': 3000, 'price': 0.04},
        'public': {'count': 6000, 'price': 0.05}
    }
    
    total_revenue = 0
    for phase, config in phases.items():
        phase_revenue = config['count'] * config['price']
        total_revenue += phase_revenue
        print(f"{phase}: {config['count']} NFTs × {config['price']} ETH = {phase_revenue} ETH")
    
    print(f"予想総収益: {total_revenue} ETH (約 ${total_revenue * 2000} USD)")
    
    # マルチチェーン分散効果
    chain_multiplier = 1.5  # 複数チェーンでのリーチ拡大効果
    optimized_revenue = total_revenue * chain_multiplier
    print(f"マルチチェーン最適化後: {optimized_revenue} ETH")
    
    return optimized_revenue

def create_marketing_plan():
    chain_strategies = {
        'ethereum': {
            'target': 'High-value collectors',
            'platforms': ['OpenSea', 'Foundation', 'SuperRare'],
            'marketing': ['Blue-chip partnerships', 'Celebrity endorsements'],
            'price_range': '0.1-1.0 ETH'
        },
        'arbitrum': {
            'target': 'DeFi users seeking utility',
            'platforms': ['Stratos', 'tofuNFT'],
            'marketing': ['DeFi protocol integrations', 'Yield farming'],
            'price_range': '0.01-0.1 ETH'
        },
        'polygon': {
            'target': 'Gaming and mass adoption',
            'platforms': ['OpenSea Polygon', 'Aavegotchi Baazaar'],
            'marketing': ['Gaming partnerships', 'Mobile apps'],
            'price_range': '1-50 MATIC'
        },
        'optimism': {
            'target': 'Eco-conscious users',
            'platforms': ['Quix', 'OptiMarket'],
            'marketing': ['Sustainability focus', 'Carbon credits'],
            'price_range': '0.005-0.05 ETH'
        }
    }
    
    return chain_strategies

# セキュリティチェックリスト
security_checklist = {
    'access_control': 'Owner権限の適切な管理',
    'reentrancy': 'リエントランシー攻撃の対策',
    'overflow_protection': 'オーバーフロー保護',
    'pause_mechanism': '緊急停止機能の実装',
    'upgrade_proxy': 'アップグレード可能性の検討',
    'audit': '外部監査の実施（推奨）'
}

def phased_launch_plan():
    phases = {
        'phase_1_testnet': {
            'duration': '1-2 weeks',
            'goal': 'Technical validation',
            'chains': ['sepolia', 'arbitrum_sepolia'],
            'activities': ['Contract testing', 'Metadata validation', 'Gas optimization']
        },
        'phase_2_layer2': {
            'duration': '2-4 weeks',
            'goal': 'Community building',
            'chains': ['arbitrum', 'polygon', 'optimism'],
            'activities': ['Limited mint', 'Community feedback', 'Platform listing']
        },
        'phase_3_mainnet': {
            'duration': 'Ongoing',
            'goal': 'Full launch',
            'chains': ['ethereum'] + ['arbitrum', 'polygon', 'optimism'],
            'activities': ['Public mint', 'Marketing campaign', 'Partnership expansion']
        }
    }
    
    return phases

# 1. ガス不足エラー
def handle_gas_issues():
    """ガス関連問題の対処"""
    solutions = {
        'out_of_gas': 'ガス制限を20-50%増加',
        'gas_price_too_low': 'ガス価格を現在の1.2-1.5倍に設定',
        'nonce_too_low': 'ペンディングトランザクションの確認',
        'replacement_underpriced': 'ガス価格を10%以上増加して再送信'
    }
    return solutions

# 2. メタデータ同期問題
async def refresh_metadata_opensea(contract_address, token_id):
    """OpenSeaメタデータ強制更新"""
    refresh_url = f"https://api.opensea.io/api/v1/asset/{contract_address}/{token_id}/?force_update=true"
    
    async with aiohttp.ClientSession() as session:
        async with session.get(refresh_url) as response:
            if response.status == 200:
                print(f"✅ Token #{token_id} メタデータ更新要求成功")
            else:
                print(f"⚠️ Token #{token_id} メタデータ更新要求失敗")

# 3. コントラクト検証失敗
def verify_contract_manual():
    """手動コントラクト検証手順"""
    steps = [
        "1. Explorer（Etherscan等）にアクセス",
        "2. Contract → Verify and Publish を選択",
        "3. Compiler Version と Optimization 設定を確認",
        "4. コントラクトソースコードを貼り付け",
        "5. Constructor Arguments を16進数で入力",
        "6. 検証実行"
    ]
    return steps