collection.ts

import { Command } from "commander"
import ora from "ora"
import chalk from "chalk"
import fs from "fs"
import { SigningCosmWasmClient } from "@cosmjs/cosmwasm-stargate"
import { GasPrice } from "@cosmjs/stargate";
import path from "path"
import Web3 from "web3"
import ERC2981Abi from "./contracts/erc2981_lighthouse_edition.abi"
import IPointerAbi from "./contracts/ipointer.abi"
import PointerViewAbi from "./contracts/pointerview.abi"
import { getChainConfig } from "./lighthouse"
import { Registry } from "@cosmjs/proto-signing"
import { MsgRegisterPointer } from "./contracts/pointer"

export const command_collection = async (root: Command) => {
    root
        .command("deploy")
        .description("Deploy a collection.")
        .argument("<config>", "Path to the config file. (ERC721, CW721, CW404 or CW20)")
        .option("-c --code <code_id>", "Register already deployed CW721/CW404 contract (optional)")
        .option("-e --erc721address <erc721_address>", "Register already deployed ERC721 contract (must be ERC2981 lighthouse edition) (optional)")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction  (default: 0.1)")
        .action(async (configFile, options) => {

            let config = JSON.parse(fs.readFileSync(configFile).toString())

            let { wallet, privateKey, lighthouse, lighthouse_evm, rpc_evm, rpc_wasm } = await getChainConfig(true)
            const [firstAccount] = await wallet.getAccounts()
            var client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei")
            })

            var spinner: ora.Ora;
            var registerMsg: any;
            let codeId = options.code ? options.code : null

            if (config.collection_type === "721") {

                let chain = config.chain
                if (chain === "wasm") {
                    chain = "v1"
                } else if (chain === "evm") {
                    chain = "v2"
                } else {
                    console.log(chalk.red("Invalid chain. Availabe 'wasm' or 'evm'."))
                    return;
                }

                let token_uri = config.token_uri
                if (token_uri[token_uri.length - 1] === "/")
                    token_uri = token_uri.slice(0, -1)

                let additionalMsg: any = {}

                if (chain === "v1" && codeId === null) {
                    spinner = ora("Deploying CW721 Contract").start()
                    const contractPath = path.join(__dirname, "./contracts/cw2981_lighthouse_edition.wasm")
                    const wasm = fs.readFileSync(contractPath)
                    const uploadReceipt = await client.upload(firstAccount.address, wasm, "auto")
                    codeId = uploadReceipt.codeId

                    spinner.succeed("CW721 Contract deployed to SEI blockchain. Contract Code ID: " + chalk.green(codeId.toString()))

                    additionalMsg.cw721_code = parseInt(codeId)
                } else if (chain === "v1" && codeId !== null) {
                    additionalMsg.cw721_code = parseInt(codeId)
                }

                if (chain === "v2") {

                    spinner = ora("Deploying ERC721 Contract").start()
                    const { bytecode } = require(path.join(__dirname, "./contracts/erc2981_lighthouse_edition.json"))

                    const web3 = new Web3(rpc_evm);
                    const accountAddress = web3.eth.accounts.privateKeyToAccount("0x" + privateKey).address;
                    const contract = new web3.eth.Contract(ERC2981Abi as any);

                    if (options.erc721address) {
                        additionalMsg.erc721_address = options.erc721address
                        spinner.succeed("Using already deployed ERC721 Contract: " + chalk.green(options.erc721address))
                    } else {
                        const deployOptions = {
                            data: bytecode,
                            arguments: [
                                config.name,
                                config.symbol,
                                lighthouse_evm,
                                config.is_immutable ? true : false,
                                config.frozen ? true : false,
                                config.hidden_metadata ? config.hidden_metadata : false,
                            ]
                        };

                        const signedTxDeploy = await web3.eth.accounts.signTransaction(
                            {
                                from: accountAddress,
                                data: contract.deploy(deployOptions).encodeABI(),
                                gas: await contract.deploy(deployOptions).estimateGas({ from: accountAddress }),
                                maxPriorityFeePerGas: web3.utils.toWei('2', 'gwei'),
                                maxFeePerGas: web3.utils.toWei('100', 'gwei'),
                            },
                            privateKey
                        );

                        var receiptDeploy: any;

                        try {
                            receiptDeploy = await web3.eth.sendSignedTransaction(signedTxDeploy.rawTransaction);
                        } catch (error) {
                            console.log(chalk.red("Error deploying ERC721 contract. are you sure you have associated the wallet to EVM?"))
                            console.error(error)
                            return;
                        }

                        additionalMsg.erc721_address = receiptDeploy.contractAddress;
                        spinner.succeed("ERC721 Contract deployed to SEI blockchain. Contract Address: " + chalk.green(receiptDeploy.contractAddress));
                    }

                    spinner = ora("Updating ERC721 Contract Lighthouse details").start()

                    const contractInstance = new web3.eth.Contract(ERC2981Abi, additionalMsg.erc721_address);

                    let updateArgs = [
                        config.placeholder_token_uri ? config.placeholder_token_uri : "",
                        token_uri,
                        config.fixed_uri ? true : false,
                        config.uri_suffix ? config.uri_suffix : "",
                        config.royalty_percent ? parseFloat(config.royalty_percent) * 100 : 0,
                        config.royalty_wallet ? config.royalty_wallet : ""
                    ]

                    const data = contractInstance.methods.updateLhInfo(
                        ...updateArgs
                    ).encodeABI();

                    const signedTxUpdate = await web3.eth.accounts.signTransaction(
                        {
                            from: accountAddress,
                            to: additionalMsg.erc721_address,
                            data,
                            gas: await contractInstance.methods.updateLhInfo(...updateArgs).estimateGas({ from: accountAddress }),
                            maxPriorityFeePerGas: web3.utils.toWei('2', 'gwei'),
                            maxFeePerGas: web3.utils.toWei('100', 'gwei'),
                        },
                        privateKey
                    );

                    await web3.eth.sendSignedTransaction(signedTxUpdate.rawTransaction);
                    spinner.succeed("ERC721 Contract Lighthouse details updated");
                }

                registerMsg = {
                    register_collection: {
                        ...additionalMsg,
                        chain,
                        collection_type: config.collection_type,
                        name: config.name,
                        symbol: config.symbol,
                        supply: config.supply.toString(),
                        token_uri,
                        royalty_percent: config.royalty_percent ? parseInt(config.royalty_percent) : null,
                        royalty_wallet: config.royalty_wallet ? config.royalty_wallet : null,
                        is_immutable: config.is_immutable ? true : false,
                        fixed_uri: config.fixed_uri ? true : false,
                        start_order: config.start_order === null ? null : config.start_order.toString(),
                        uri_suffix: config.uri_suffix ? config.uri_suffix : null,
                        frozen: config.frozen ? true : false,
                        unfreeze_time: config.unfreeze_time ? new Date(config.unfreeze_time).getTime() / 1000 : null,
                        hidden_metadata: config.hidden_metadata ? config.hidden_metadata : false,
                        placeholder_token_uri: config.placeholder_token_uri ? config.placeholder_token_uri : null,
                        mint_groups: config.groups.map((group: any) => {
                            return {
                                name: group.name,
                                merkle_root: group.merkle_root ? Array.from(Buffer.from(group.merkle_root, 'hex')) : null,
                                max_mints_per_wallet: group.max_mints_per_wallet ? group.max_mints_per_wallet.toString() : "0",
                                reserved_supply: group.reserved_supply ? group.reserved_supply.toString() : "0",
                                start_time: group.start_time ? new Date(group.start_time).getTime() / 1000 : 0,
                                end_time: group.end_time ? new Date(group.end_time).getTime() / 1000 : 0,
                                payments: group.payments.map((payment: any) => {
                                    let type = payment.type.toLowerCase()
                                    let args: any[] = []
                                    if (type === "native") {
                                        args = [payment.destination]
                                    } else if (type === "cw20") {
                                        args = [payment.destination, payment.contract]
                                    } else if (type === "cw20_burn") {
                                        args = [payment.contract]
                                    }
                                    return {
                                        payment_type: type,
                                        amount: payment.amount.toString(),
                                        args
                                    }
                                }),
                                gates: []
                            }
                        })
                    }
                }

            }
            else if (config.collection_type === "404") {

                if (codeId === null) {
                    spinner = ora("Deploying CW404 Contract").start()
                    const contractPath = path.join(__dirname, "./contracts/cw404.wasm")
                    const wasm = fs.readFileSync(contractPath)
                    const uploadReceipt = await client.upload(firstAccount.address, wasm, "auto")
                    codeId = uploadReceipt.codeId

                    spinner.succeed("CW404 Contract deployed to SEI blockchain. Contract Code ID: " + chalk.green(codeId.toString()))
                }

                let token_uri = config.token_uri
                if (token_uri[token_uri.length - 1] === "/")
                    token_uri = token_uri.slice(0, -1)

                if (config.chain !== "wasm") {
                    console.log(chalk.red("CW404 collection can only be deployed to chain type 'wasm'."))
                    return;
                }

                registerMsg = {
                    register_collection: {
                        cw404_code: parseInt(codeId),
                        chain: "v1",
                        collection_type: config.collection_type,
                        name: config.name,
                        symbol: config.symbol,
                        supply: config.supply.toString(),
                        token_uri,
                        royalty_percent: config.royalty_percent ? parseInt(config.royalty_percent) : null,
                        royalty_wallet: config.royalty_wallet ? config.royalty_wallet : null,
                        is_immutable: config.is_immutable ? true : false,
                        fixed_uri: config.fixed_uri ? true : false,
                        uri_suffix: config.uri_suffix ? config.uri_suffix : null,
                        frozen: config.frozen ? true : false,
                        frozen_whitelist: config.frozen_whitelist ? config.frozen_whitelist : null,
                        unfreeze_time: config.unfreeze_time ? new Date(config.unfreeze_time).getTime() / 1000 : null,
                        hidden_metadata: false,
                        cw404_info: {
                            decimals: parseInt(config.decimals),
                            max_supply: config.max_supply.toString(),
                            max_edition: parseInt(config.max_edition),
                            tokens_per_nft: config.tokens_per_nft.toString(),
                            marketing: config.marketing ? config.marketing : null,
                        },
                        mint_groups: config.groups.map((group: any) => {
                            return {
                                name: group.name,
                                merkle_root: group.merkle_root ? Array.from(Buffer.from(group.merkle_root, 'hex')) : null,
                                max_mints_per_wallet: group.max_mints_per_wallet ? group.max_mints_per_wallet.toString() : "0",
                                reserved_supply: group.reserved_supply_in_batch ? group.reserved_supply_in_batch.toString() : "0",
                                batch_size: group.batch_size.toString(),
                                start_time: group.start_time ? new Date(group.start_time).getTime() / 1000 : 0,
                                end_time: group.end_time ? new Date(group.end_time).getTime() / 1000 : 0,
                                payments: group.payments.map((payment: any) => {
                                    let type = payment.type.toLowerCase()
                                    let args: any[] = []
                                    if (type === "native") {
                                        args = [payment.destination]
                                    } else if (type === "cw20") {
                                        args = [payment.destination, payment.contract]
                                    } else if (type === "cw20_burn") {
                                        args = [payment.contract]
                                    }
                                    return {
                                        payment_type: type,
                                        amount: payment.amount.toString(),
                                        args
                                    }
                                }),
                                gates: []
                            }
                        })
                    }
                }

            }
            else if (config.collection_type === "cw20") {

                if (codeId === null) {
                    spinner = ora("Deploying CW20 Contract").start()
                    const contractPath = path.join(__dirname, "./contracts/cw20.wasm")
                    const wasm = fs.readFileSync(contractPath)
                    const uploadReceipt = await client.upload(firstAccount.address, wasm, "auto")
                    codeId = uploadReceipt.codeId

                    spinner.succeed("CW20 Contract deployed to SEI blockchain. Contract Code ID: " + chalk.green(codeId.toString()))
                }

                const instantiateMsg = {
                    name: config.name,
                    symbol: config.symbol,
                    decimals: parseInt(config.decimals),
                    initial_balances: config.initial_balances ? config.initial_balances.map((balance: any) => {
                        return {
                            address: balance.address,
                            amount: balance.amount.toString()
                        }
                    }) : null,
                    mint: config.mint ? {
                        minter: config.mint.minter,
                        cap: config.mint.cap.toString()
                    } : null,
                    marketing: config.marketing ? config.marketing : null
                }

                spinner = ora("Instantiating CW20 Token").start()

                const instantiateReceipt = await client.instantiate(firstAccount.address, codeId, instantiateMsg, "CW20 Token", "auto", {
                    memo: "CW20 Token",
                    admin: firstAccount.address
                })

                spinner.succeed("CW20 Token instantiated")
                console.log("Transaction hash: " + chalk.green(instantiateReceipt.transactionHash))
                console.log("Contract address: " + chalk.green(instantiateReceipt.contractAddress))

                return;
            }
            else {
                console.log(chalk.red("Invalid collection type."))
                return;
            }

            spinner = ora("Registering Collection").start()

            const registerReceipt = await client.execute(firstAccount.address, lighthouse, registerMsg, "auto")

            spinner.succeed("Collection registered to Lighthouse")

            const events = registerReceipt.logs[0].events
            let collectionAddress;

            // Find the event with the type 'wasm'
            for (const event of events) {
                if (event.type === 'wasm') {
                    // Find the attribute with the key 'collection'
                    for (const attribute of event.attributes) {
                        if (attribute.key === 'collection') {
                            collectionAddress = attribute.value;
                        }
                    }
                }
            }

            console.log("Transaction hash: " + chalk.green(registerReceipt.transactionHash))
            console.log("Collection address: " + chalk.green(collectionAddress))

            if (config.collection_type === "721") {
                //pointer
                spinner = ora("Deploying Pointer").start()
                if (config.chain === "wasm") {

                    const web3 = new Web3(rpc_evm);
                    const accountAddress = web3.eth.accounts.privateKeyToAccount("0x" + privateKey).address;

                    const contractInstance = new web3.eth.Contract(IPointerAbi, "0x000000000000000000000000000000000000100b");

                    const data = contractInstance.methods.addCW721Pointer(
                        collectionAddress
                    ).encodeABI();

                    const signedTxUpdate = await web3.eth.accounts.signTransaction(
                        {
                            from: accountAddress,
                            to: "0x000000000000000000000000000000000000100b",
                            data,
                            gas: await contractInstance.methods.addCW721Pointer(collectionAddress).estimateGas({ from: accountAddress }),
                            maxPriorityFeePerGas: web3.utils.toWei('2', 'gwei'),
                            maxFeePerGas: web3.utils.toWei('100', 'gwei'),
                        },
                        privateKey
                    );

                    let receipt = await web3.eth.sendSignedTransaction(signedTxUpdate.rawTransaction);

                    const pointerViewContractInstance = new web3.eth.Contract(PointerViewAbi, "0x000000000000000000000000000000000000100A");
                    let result: any = await pointerViewContractInstance.methods.getCW721Pointer(collectionAddress).call();
                    spinner.succeed("Pointer deployed to EVM. Pointer Address: " + chalk.green(result.addr));
                    console.log("Transaction hash: " + chalk.green(receipt.transactionHash));
                } else {

                    const typeUrl = "/seiprotocol.seichain.evm.MsgRegisterPointer"
                    const registry = new Registry()
                    registry.register(typeUrl, MsgRegisterPointer);
                    const msg = {
                        typeUrl,
                        value: {
                            sender: firstAccount.address,
                            pointerType: 1, // PointerType_ERC721
                            ercAddress: collectionAddress
                        }
                    };

                    client.disconnect()
                    client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                        gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei"),
                        registry
                    })

                    const receipt = await client.signAndBroadcast(firstAccount.address, [msg], "auto")

                    let pointerAddress = "unknown"
                    for (let i = 0; i < receipt.events.length; i++) {
                        const event = receipt.events[i]
                        if (event.type === "pointer_registered" && event.attributes.length > 0) {
                            pointerAddress = event.attributes.find((attr) => attr.key === "pointer_address")?.value || "unknown"
                            break
                        }
                    }

                    spinner.succeed("Pointer deployed to CosmWasm. Pointer Address: " + chalk.green(pointerAddress))
                    console.log("Transaction hash: " + chalk.green(receipt.transactionHash))
                }
            }

        })

    root.command("update")
        .description("Update a collection.")
        .argument("<config>", "The config file.")
        .argument("<collection>", "The collection address.")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction  (default: 0.1)")
        .action(async (configFile, collectionAddress, options) => {
            let config = JSON.parse(fs.readFileSync(configFile).toString())

            let { wallet, lighthouse, rpc_evm, rpc_wasm, privateKey } = await getChainConfig(true)
            const [firstAccount] = await wallet.getAccounts()
            var client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei")
            })

            let collectionData = await client.queryContractSmart(lighthouse, { get_collection: { collection: collectionAddress } })

            var spinner: ora.Ora;

            let token_uri = config.token_uri
            if (token_uri[token_uri.length - 1] === "/")
                token_uri = token_uri.slice(0, -1)

            var updateMsg: any;

            if (config.collection_type === "721") {

                if (collectionData.chain === "v2") {

                    spinner = ora("Updating ERC721 Contract Lighthouse details").start()

                    const web3 = new Web3(rpc_evm);
                    const accountAddress = web3.eth.accounts.privateKeyToAccount("0x" + privateKey).address;

                    const contractInstance = new web3.eth.Contract(ERC2981Abi, collectionData.collection_address);

                    let updateArgs = [
                        config.placeholder_token_uri ? config.placeholder_token_uri : "",
                        token_uri,
                        config.fixed_uri ? true : false,
                        config.uri_suffix ? config.uri_suffix : "",
                        config.royalty_percent ? parseFloat(config.royalty_percent) * 100 : 0,
                        config.royalty_wallet ? config.royalty_wallet : ""
                    ]


                    const data = contractInstance.methods.updateLhInfo(
                        ...updateArgs
                    ).encodeABI();

                    const signedTxUpdate = await web3.eth.accounts.signTransaction(
                        {
                            from: accountAddress,
                            to: collectionData.collection_address,
                            data,
                            gas: await contractInstance.methods.updateLhInfo(...updateArgs).estimateGas({ from: accountAddress }),
                            maxPriorityFeePerGas: web3.utils.toWei('2', 'gwei'),
                            maxFeePerGas: web3.utils.toWei('100', 'gwei'),
                        },
                        privateKey
                    );

                    await web3.eth.sendSignedTransaction(signedTxUpdate.rawTransaction);
                    spinner.succeed("ERC721 Contract Lighthouse details updated");
                }

                updateMsg = {
                    update_collection: {
                        collection: collectionAddress,
                        supply: config.supply.toString(),
                        token_uri,
                        royalty_percent: config.royalty_percent ? parseInt(config.royalty_percent) : null,
                        royalty_wallet: config.royalty_wallet ? config.royalty_wallet : null,
                        fixed_uri: config.fixed_uri ? true : false,
                        uri_suffix: config.uri_suffix ? config.uri_suffix : null,
                        start_order: config.start_order === null ? null : config.start_order.toString(),
                        placeholder_token_uri: config.placeholder_token_uri ? config.placeholder_token_uri : null,
                        mint_groups: config.groups.map((group: any) => {
                            return {
                                name: group.name,
                                merkle_root: group.merkle_root ? Array.from(Buffer.from(group.merkle_root, 'hex')) : null,
                                max_mints_per_wallet: group.max_mints_per_wallet ? group.max_mints_per_wallet.toString() : "0",
                                reserved_supply: group.reserved_supply ? group.reserved_supply.toString() : "0",
                                start_time: group.start_time ? new Date(group.start_time).getTime() / 1000 : 0,
                                end_time: group.end_time ? new Date(group.end_time).getTime() / 1000 : 0,
                                payments: group.payments.map((payment: any) => {
                                    let type = payment.type.toLowerCase()
                                    let args: any[] = []
                                    if (type === "native") {
                                        args = [payment.destination]
                                    } else if (type === "cw20") {
                                        args = [payment.destination, payment.contract]
                                    } else if (type === "cw20_burn") {
                                        args = [payment.contract]
                                    }
                                    return {
                                        payment_type: type,
                                        amount: payment.amount.toString(),
                                        args
                                    }
                                }),
                                gates: []
                            }
                        })
                    }
                }

            } else if (config.collection_type === "404") {

                updateMsg = {
                    update_collection: {
                        collection: collectionAddress,
                        supply: config.supply.toString(),
                        token_uri,
                        royalty_percent: config.royalty_percent ? parseInt(config.royalty_percent) : null,
                        royalty_wallet: config.royalty_wallet ? config.royalty_wallet : null,
                        fixed_uri: config.fixed_uri ? true : false,
                        uri_suffix: config.uri_suffix ? config.uri_suffix : null,
                        max_edition: parseInt(config.max_edition),
                        frozen_whitelist: config.frozen_whitelist ? config.frozen_whitelist : null,
                        mint_groups: config.groups.map((group: any) => {
                            return {
                                name: group.name,
                                merkle_root: group.merkle_root ? Array.from(Buffer.from(group.merkle_root, 'hex')) : null,
                                max_mints_per_wallet: group.max_mints_per_wallet ? group.max_mints_per_wallet.toString() : "0",
                                reserved_supply: group.reserved_supply_in_batch ? group.reserved_supply_in_batch.toString() : "0",
                                batch_size: group.batch_size.toString(),
                                start_time: group.start_time ? new Date(group.start_time).getTime() / 1000 : 0,
                                end_time: group.end_time ? new Date(group.end_time).getTime() / 1000 : 0,
                                payments: group.payments.map((payment: any) => {
                                    let type = payment.type.toLowerCase()
                                    let args: any[] = []
                                    if (type === "native") {
                                        args = [payment.destination]
                                    } else if (type === "cw20") {
                                        args = [payment.destination, payment.contract]
                                    } else if (type === "cw20_burn") {
                                        args = [payment.contract]
                                    }
                                    return {
                                        payment_type: type,
                                        amount: payment.amount.toString(),
                                        args
                                    }
                                }),
                                gates: []
                            }
                        })
                    }
                }

            } else {
                console.log(chalk.red("Invalid collection type."))
                return;
            }

            spinner = ora("Updating Collection").start()
            const updateReceipt = await client.execute(firstAccount.address, lighthouse, updateMsg, "auto")

            spinner.succeed("Collection updated")
            console.log("Transaction hash: " + chalk.green(updateReceipt.transactionHash))
        })

    root
        .command("unfreeze")
        .description("Unfreeze a collection")
        .argument("<collection>")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction  (default: 0.1)")
        .action(async (collection, options) => {

            let { wallet, lighthouse, rpc_wasm } = await getChainConfig(true)
            const [firstAccount] = await wallet.getAccounts()
            var client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei")
            })

            let spinner = ora("Unfreezing collection").start()
            const Msg = {
                unfreeze_collection: { collection }
            }

            const txReceipt = await client.execute(firstAccount.address, lighthouse, Msg, "auto", "",)

            spinner.succeed("Collection unfrozen")
            console.log("Transaction hash: " + chalk.green(txReceipt.transactionHash))

        })

    root
        .command("reveal")
        .description("Reveal a collection metadata")
        .argument("<collection>")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction  (default: 0.1)")
        .action(async (collection, options) => {

            let { wallet, lighthouse, rpc_wasm } = await getChainConfig(true)
            const [firstAccount] = await wallet.getAccounts()

            const client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei")
            })

            let spinner = ora("Revealing Metadata").start()
            const Msg = {
                reveal_collection_metadata: { collection }
            }

            const txReceipt = await client.execute(firstAccount.address, lighthouse, Msg, "auto", "",)

            spinner.succeed("Metadata revealed")
            console.log("Transaction hash: " + chalk.green(txReceipt.transactionHash))

        })

    root
        .command("view")
        .description("View information about an existing NFT collection")
        .argument("<collection>")
        .action(async (collection) => {
            let spinner = ora("Fetching collection information").start()

            let { lighthouse, rpc_wasm, rpc_evm } = await getChainConfig(false)

            const client = await SigningCosmWasmClient.connect(rpc_wasm)
            client.queryContractSmart(lighthouse, { get_collection: { collection } }).then(async (lighthouseResult) => {
                let contractData: any = {};
                if (lighthouseResult.chain === "v2") {
                    const web3 = new Web3(rpc_evm);
                    const contract = new web3.eth.Contract(ERC2981Abi, collection);
                    let result = await contract.methods.info().call();
                    contractData = {
                        isImmutable: result.isImmutable,
                        frozen: result.frozen,
                        hiddenMetadata: result.hiddenMetadata,
                        placeholderTokenUri: result.placeholderTokenUri,
                        baseUri: result.baseUri,
                        fixedUri: result.fixedUri,
                        baseUriSuffix: result.baseUriSuffix,
                    }
                } else {
                    if (lighthouseResult.collection_type === "721")
                        contractData = await client.queryContractSmart(collection, { extension: { msg: { lighthouse_info: {} } } })
                    else if (lighthouseResult.collection_type === "404")
                        contractData = await client.queryContractSmart(collection, { cw404_info: {} })
                }
                spinner.succeed("Collection information fetched")

                let groups = lighthouseResult.mint_groups.map((group: any) => {
                    let _group = group;
                    _group.start_time = group.start_time ? new Date(group.start_time * 1000).toISOString() : null
                    _group.end_time = group.end_time ? new Date(group.end_time * 1000).toISOString() : null
                    _group.merkle_root = group.merkle_root ? Buffer.from(group.merkle_root).toString('hex') : null
                    return _group
                })

                lighthouseResult.mint_groups = groups
                lighthouseResult.contract_data = contractData
                console.log(JSON.stringify(lighthouseResult, null, 4))
            })
        })

    root
        .command("point")
        .description("Deploy a pointer for a collection.")
        .argument("<collection>")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction  (default: 0.1)")
        .action(async (collection, options) => {
            let { rpc_wasm, wallet, rpc_evm, privateKey } = await getChainConfig(true)

            if (collection.startsWith("sei")) {
                let spinner = ora("Deploying pointer").start()

                const web3 = new Web3(rpc_evm);
                const accountAddress = web3.eth.accounts.privateKeyToAccount("0x" + privateKey).address;

                const contractInstance = new web3.eth.Contract(IPointerAbi, "0x000000000000000000000000000000000000100b");

                const data = contractInstance.methods.addCW721Pointer(
                    collection
                ).encodeABI();

                const signedTxUpdate = await web3.eth.accounts.signTransaction(
                    {
                        from: accountAddress,
                        to: "0x000000000000000000000000000000000000100b",
                        data,
                        gas: await contractInstance.methods.addCW721Pointer(collection).estimateGas({ from: accountAddress }),
                        maxPriorityFeePerGas: web3.utils.toWei('2', 'gwei'),
                        maxFeePerGas: web3.utils.toWei('100', 'gwei'),
                    },
                    privateKey
                );

                let receipt = await web3.eth.sendSignedTransaction(signedTxUpdate.rawTransaction);

                const pointerViewContractInstance = new web3.eth.Contract(PointerViewAbi, "0x000000000000000000000000000000000000100A");
                let result: any = await pointerViewContractInstance.methods.getCW721Pointer(collection).call();
                spinner.succeed("Pointer deployed to EVM. Pointer Address: " + chalk.green(result.addr));
                console.log("Transaction hash: " + chalk.green(receipt.transactionHash));
            } else if (collection.startsWith("0x")) {
                let spinner = ora("Deploying pointer").start()

                const [firstAccount] = await wallet.getAccounts()
                var client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                    gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei")
                })

                const typeUrl = "/seiprotocol.seichain.evm.MsgRegisterPointer"
                const registry = new Registry()
                registry.register(typeUrl, MsgRegisterPointer);
                const msg = {
                    typeUrl,
                    value: {
                        sender: firstAccount.address,
                        pointerType: 1, // PointerType_ERC721
                        ercAddress: collection
                    }
                };

                client.disconnect()
                client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                    gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei"),
                    registry
                })

                const receipt = await client.signAndBroadcast(firstAccount.address, [msg], "auto")

                let pointerAddress = "unknown"
                for (let i = 0; i < receipt.events.length; i++) {
                    const event = receipt.events[i]
                    if (event.type === "pointer_registered" && event.attributes.length > 0) {
                        pointerAddress = event.attributes.find((attr) => attr.key === "pointer_address")?.value || "unknown"
                        break
                    }
                }

                spinner.succeed("Pointer deployed to CosmWasm. Pointer Address: " + chalk.green(pointerAddress))
                console.log("Transaction hash: " + chalk.green(receipt.transactionHash))
            } else {
                console.log(chalk.red("Invalid collection address"))
                return;
            }
        })




}