utils.ts

import { Command } from "commander"
import ora from "ora"
import inquirer from "inquirer"
import fs from "fs"
import { SigningCosmWasmClient } from "@cosmjs/cosmwasm-stargate"
import { GasPrice } from "@cosmjs/stargate";
import PromisePool from '@supercharge/promise-pool';
import * as ethUtil from "ethereumjs-util";
import axios from "axios"
import { getChainConfig } from "./lighthouse"
import chalk from "chalk"
import Web3 from "web3"
import ERC2981Abi from "./contracts/erc2981_lighthouse_edition.abi"

export const command_utils = async (root: Command) => {
    root
        .command("associate-evm")
        .description("Associate cosmwasm wallet to evm (seiv2)")
        .action(async () => {
            let { privateKey, rpc_evm } = await getChainConfig(true)

            let spinner = ora("Associating wallet to EVM").start()

            const privateKeyBuffer = Buffer.from(privateKey, "hex");
            const emptyData = Buffer.alloc(32);
            const signature = ethUtil.ecsign(emptyData, privateKeyBuffer);
            const { r, s, v } = signature;
            const compactV = Number(v) - 27;
            let signed = {
                r: ethUtil.bufferToHex(r),
                s: ethUtil.bufferToHex(s),
                v: `${compactV}`,
            };

            await axios.post(rpc_evm, {
                id: 1,
                jsonrpc: "2.0",
                method: "sei_associate",
                params: [{
                    ...signed,
                }]
            }, {
                headers: {
                    'accept': 'application/json',
                    'content-type': 'application/json'
                }
            })

            spinner.succeed("Wallet associated to EVM")
        })

    root
        .command("snapshot")
        .description("Snapshot holders of a collection")
        .argument("<collection>")
        .option('-s --supply <supply>', 'Supply of the collection')
        .option('-so --start-token-id <token_id>', 'Start token ID of the collection')
        .option('-e, --exclude-contracts', 'Exclude contract addresses')
        .option('-o, --output <file>', 'Output file name')
        .option('-c, --count', 'Output how many tokens each holder owns')
        .option('-d, --duplicate', 'Output duplicate holders', false)
        .option('-st, --show-token-id', 'Show token ID', false)
        .action(async (collection, options) => {
            let spinner = ora("Fetching holders").start();
            let { wallet, rpc_wasm } = await getChainConfig()
            var client = await SigningCosmWasmClient.connectWithSigner(rpc_wasm, wallet, {
                gasPrice: GasPrice.fromString(options.gasPrice ? options.gasPrice + "usei" : "0.1usei")
            })

            let numTokens;
            let startTokenId = 1;

            if (options.supply !== "auto") {
                numTokens = parseInt(options.supply);
                if (options.startTokenId) {
                    options.startTokenId = parseInt(options.startTokenId);
                }
            } else {
                let numTokensResult = await client.queryContractSmart(collection, {
                    num_tokens: {}
                });
                numTokens = parseInt(numTokensResult.count);
            }

            try {
                if (!options.startTokenId) {
                    await client.queryContractSmart(collection, {
                        owner_of: { token_id: '0' }
                    });
                    startTokenId = 0; // token ID 0 exists, start from 0
                }
            } catch (error) {
                // assuming an error means Token ID 0 does not exist
            }

            const { results, errors } = await PromisePool
                .withConcurrency(10)
                .for([...Array(numTokens).keys()].map(i => String(i + startTokenId)))
                .process(async token_id => {
                    try {
                        let result = await client.queryContractSmart(collection, {
                            owner_of: { token_id }
                        });
                        return result.owner;
                    } catch (error) {
                        console.error(`Error fetching owner for token ${token_id}:`, error);
                        return false;
                    }
                });

            let owners = results.filter(o => o !== false);
            if (options.excludeContracts) {
                owners = owners.filter(o => o.length <= 42);
            }

            spinner.succeed("Holders fetched");

            let outputData = '';
            if (options.count) {
                const ownerCounts = owners.reduce((acc, owner) => {
                    acc[owner] = (acc[owner] || 0) + 1;
                    return acc;
                }, {});
                outputData = Object.entries(ownerCounts).map(([owner, count]) => `${owner}: ${count}`).join('\n');
            } else if (!options.duplicate) {
                owners = owners.filter((o, i, arr) => arr.indexOf(o) === i);
                outputData = owners.join('\n');
            } else {
                if (options.showTokenId) {
                    owners = owners.map((o, i) => `${o} - ${i + startTokenId}`);
                }
                outputData = owners.join('\n');
            }

            let outputFileName = options.output;

            if (!outputFileName) {
                const answers = await inquirer.prompt([{
                    type: 'input',
                    name: 'file',
                    message: 'Enter file name to save snapshot to',
                    default: "owners.txt"
                }])
                outputFileName = answers.file
            }
            fs.writeFileSync(outputFileName, outputData)
            console.log(`Snapshot saved to ${outputFileName}`);
        });

    root
        .command("ownerof")
        .description("Get the owner of an NFT(s)")
        .argument("<collection>", "Collection address")
        .argument("<token_ids>", "Token ID(s) separated by commas")
        .action(async (collection, token_ids) => {

            let spinner = ora("Fetching owner information").start()

            let { rpc_wasm } = await getChainConfig()

            const client = await SigningCosmWasmClient.connect(rpc_wasm)

            let owners = []

            for (let token_id of token_ids.split(",")) {

                let result = await client.queryContractSmart(collection, {
                    owner_of: {
                        token_id
                    }
                })

                owners.push(result.owner)
            }

            spinner.succeed("Owners fetched")
            console.log(owners.join("\n"))

            //ask to save to file
            const answers = await inquirer.prompt([{
                type: 'confirm',
                name: 'save',
                message: 'Save owners to a file?',
                default: false
            }])

            if (answers.save) {
                const answers = await inquirer.prompt([{
                    type: 'input',
                    name: 'file',
                    message: 'Enter file name',
                    default: "owners.txt"
                }])
                fs.writeFileSync(answers.file, owners.join("\n"))
            }

        })

    root
        .command("minterof")
        .description("Get the minter of token(s)")
        .argument("<collection>", "Collection address")
        .argument("<token_ids>", "Token ID(s) separated by commas")
        .action(async (collection, token_ids) => {

            let spinner = ora("Fetching Minter information").start()

            let { lighthouse, rpc_wasm } = await getChainConfig()

            const client = await SigningCosmWasmClient.connect(rpc_wasm)

            let minters = []

            for (let token_id of token_ids.split(",")) {

                let result = await client.queryContractSmart(lighthouse, {
                    get_minter_of: {
                        collection,
                        token_id
                    }
                })

                minters.push({ token_id, minter: result })
            }

            spinner.succeed("Minters fetched")
            console.log(minters.map((minter: any) => minter.token_id + " " + minter.minter).join("\n"))

            //ask to save to file
            const answers = await inquirer.prompt([{
                type: 'confirm',
                name: 'save',
                message: 'Save minters to a file?',
                default: false
            }])

            if (answers.save) {
                const answers = await inquirer.prompt([{
                    type: 'input',
                    name: 'file',
                    message: 'Enter file name',
                    default: "minters.txt"
                }])
                fs.writeFileSync(answers.file, minters.map((minter: any) => minter.token_id + " " + minter.minter).join("\n"))
            }

        })

    root
        .command("mintersof")
        .description("Get all minters of a collection")
        .argument("<collection>", "Collection address")
        .option("--delay <delay>", "Delay between requests (default: 100ms)")
        .action(async (collection, options) => {

            let spinner = ora("Fetching Minter information").start()

            let { lighthouse, rpc_wasm } = await getChainConfig()

            const client = await SigningCosmWasmClient.connect(rpc_wasm)
            let collectionData = await client.queryContractSmart(lighthouse, { get_collection: { collection } })

            let minters = []

            for (let i = 0; i < collectionData.supply; i++) {

                try {
                    let result = await client.queryContractSmart(lighthouse, {
                        get_minter_of: {
                            collection,
                            token_id: (i + collectionData.start_order).toString()
                        }
                    })

                    minters.push({ token_id: (i + collectionData.start_order).toString(), minter: result })
                    await new Promise(r => setTimeout(r, options.delay ? options.delay : 100));
                } catch (error) {
                    console.error(`Error fetching minter for token ${i + collectionData.start_order}:`, error);
                }
            }

            spinner.succeed("Minters fetched")
            console.log(minters.map((minter: any) => minter.token_id + " " + minter.minter).join("\n"))

            //ask to save to file
            const answers = await inquirer.prompt([{
                type: 'confirm',
                name: 'save',
                message: 'Save minters to a file?',
                default: false
            }])

            if (answers.save) {
                const answers = await inquirer.prompt([{
                    type: 'input',
                    name: 'file',
                    message: 'Enter file name',
                    default: "minters.txt"
                }])
                fs.writeFileSync(answers.file, minters.map((minter: any) => minter.token_id + " " + minter.minter).join("\n"))
            }

        })


    root
        .command("view-nft")
        .description("View NFT information")
        .argument("<collection>", "Collection address")
        .argument("<token_id>", "Token ID")
        .action(async (collection, token_id) => {

            let spinner = ora("Fetching NFT information").start()

            let { rpc_wasm } = await getChainConfig()

            const client = await SigningCosmWasmClient.connect(rpc_wasm)

            let result = await client.queryContractSmart(collection, {
                nft_info: {
                    token_id
                }
            })

            spinner.succeed("NFT fetched")
            console.log(result)

        })

    root
        .command("transfer-nft")
        .description("Transfer NFT")
        .arguments("<collection> <token_id> <to>")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction  (default: 0.1)")
        .action(async (collection, tokenId, to, options) => {

            let {wallet, rpc_wasm } = await getChainConfig()

            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("Transferring NFT").start()
            const transferMsg = {
                transfer_nft: {
                    recipient: to,
                    token_id: tokenId
                }
            }

            const txReceipt = await client.execute(firstAccount.address, collection, transferMsg, "auto", "",)

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

        })

        root
        .command("transfer-evm-nft")
        .description("Transfer NFT")
        .arguments("<collection> <token_id> <to>")
        .action(async (collection, tokenId, to) => {

            let {privateKey, rpc_evm } = await getChainConfig()

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

            const data = contractInstance.methods.transferFrom(accountAddress, to, tokenId).encodeABI();

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

            let spinner = ora("Transferring NFT").start()
            const receipt =await web3.eth.sendSignedTransaction(signedTxUpdate.rawTransaction);

            spinner.succeed("NFT transferred")
            console.log("Transaction hash: " + chalk.green(receipt.transactionHash))


        })

        root
        .command("mint")
        .description("Mint new NFTs from an existing NFT collection. Only free minting is supported.")
        .argument("<collection>")
        .argument("<group_name>", "Mint from a specific group")
        .argument("<amount>", "Amount of NFTs to mint")
        .option("-g --gas-price <gas_price>", "Gas price to use for transaction (default: 0.1)")
        .action(async (collection, groupName, amount, answers) => {

            if (groupName) {
                console.log("Minting from group: " + groupName)
            } else {
                console.log(chalk.red("You must specify a group to mint from"))
                return
            }

            let {wallet, lighthouse, rpc_wasm } = await getChainConfig()

            const [firstAccount] = await wallet.getAccounts()

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

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

            let group: any = null

            for (let g of collectionConfig.mint_groups) {
                if (g.name === groupName) {
                    group = g
                    break;
                }
            }

            if (group === null) {
                console.log(chalk.red("Group not found"))
                return
            }

            let merkleProof: any = null
            let hashedAddress: any = null

            if (group.merkle_root !== "" && group.merkle_root !== null) {
                //ask for proof
                let proof = await inquirer.prompt([
                    {
                        type: "input",
                        name: "proof",
                        message: "Enter Merkle proof for group " + groupName + " separated by commas"
                    }
                ])

                let proofArray = proof.proof.split(",")

                merkleProof = proofArray.map((p: string) => Array.from(Buffer.from(p, 'hex')))
            }


            let spinner = ora("Minting NFT").start()
            const mintMsg = {
                mint: {
                    collection,
                    group: groupName,
                    merkle_proof: merkleProof,
                    amount: amount
                }
            }

            interface Coin {
                denom: string;
                amount: string;
            }

            let mintReceipt = await client.execute(firstAccount.address, lighthouse, mintMsg, "auto", "", []);
            

            spinner.succeed("NFT minted")
            console.log("Transaction hash: " + chalk.green(mintReceipt.transactionHash))

            const events = mintReceipt.logs[0].events
            let tokenIds;

            // 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 === 'token_ids') {
                            tokenIds = attribute.value;
                        }
                    }
                }
            }

            console.log("Token IDs: " + chalk.green(tokenIds))
        })
}