import { Connection, Keypair, PublicKey } from "@solana/web3.js";
import { BN, Wallet } from "@coral-xyz/anchor";
import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
import { Basket, Intent, RebalanceIntent, SymmetryCore, TaskContext, KeeperMonitor } from "./src";
import { AddOrEditTokenInput, UpdateWeightsInput, MakeDirectSwapInput } from "./src";
import { EditCreatorSettings, EditManagerSettings, EditFeeSettings, EditScheduleSettings, EditAutomationSettings, EditLpSettings, EditMetadataSettings, EditDepositsSettings, EditForceRebalanceSettings, EditCustomRebalanceSettings, EditAddTokenSettings, EditUpdateWeightsSettings, EditMakeDirectSwapSettings } from "./src";
import { getRebalanceIntentPda } from "./src/instructions/pda";
import { PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT } from "./src/constants";
import { getJupTokenLedgerAndSwapInstructions } from "./src/jup";
import { getSwapPairs } from "./src/states/intents/rebalanceIntent";


let kp = Array.from(Keypair.generate().secretKey);

let jupApiKey = "";
let connection = new Connection("https://api.devnet.solana.com");

async function testStates() {
    return;
    let wallet = new Wallet(Keypair.fromSecretKey(new Uint8Array(kp)));
    console.log(wallet.publicKey.toBase58());

    let sdk = new SymmetryCore({
        connection: connection,
        network: "mainnet",
        priorityFee: 5237,
    });
    let keeperMonitor = new KeeperMonitor({
        wallet: wallet,
        connection: connection,
        network: "mainnet",
        jupiterApiKey: jupApiKey,
        maxAllowedAccounts: 40,
        simulateTransactions: false,
        priorityFee: 5237,
    });
    // keeperMonitor.run();
    // return;

    console.log("SDK created:", wallet.publicKey.toBase58());
    console.log("Total baskets: ", (await sdk.fetchAllBaskets()).length);
    console.log("Total intents: ", (await sdk.fetchAllIntents()).length);
    console.log("Total rebalance intents: ", (await sdk.fetchAllRebalanceIntents()).length);
    console.log("Total withdraw basket fees: ", (await sdk.fetchAllWithdrawBasketFees()).length);

    let basket = await sdk.fetchBasket("GrBFFvtdRL25o7gcRnV1kGvz1Qc7iscUmDp1ZvyBSyUa");
    basket = await sdk.loadBasketPrice(basket);
    // let ri =(await sdk.fetchAllRebalanceIntents())[0];
    // ri = await sdk.fetchRebalanceIntent(ri.formatted_data.pubkey);
    // console.log(ri.deposit_data);
    // console.log(ri.price_updates_data);
    // console.log(ri.auction_data);
    // console.log(ri.mint_data);
    // console.log(ri.redeem_data);
    // console.log(ri.claim_bounty_data);
    // console.log(ri);
    // console.log(basket.formatted);
    // console.log(basket.composition[0].mint.toBase58(), "amount:", basket.composition[0].amount.toString(), "price:", basket.composition[0].price?.price, "value:", basket.composition[0].value);
    // console.log(basket.composition[1].mint.toBase58(), "amount:", basket.composition[1].amount.toString(), "price:", basket.composition[1].price?.price, "value:", basket.composition[1].value);
    // console.log(basket.composition[2].mint.toBase58(), "amount:", basket.composition[2].amount.toString(), "price:", basket.composition[2].price?.price, "value:", basket.composition[2].value);
    // return;

    let tests = {

        createGlobalConfig: false,         // TESTED
        editGlobalConfig: false,           // TESTED

        createBasket: false,                // TESTED
        editPrivateBasketSettings: false,   // NOT TESTED
        addBounty: false,                   // TESTED

        editCreator: false,                 // TESTED
        editManagerSettings: false,         // TESTED
        editFeeSettings: false,             // TESTED
        editScheduleSettings: false,        // TESTED
        editAutomationSettings: false,      // TESTED
        editLpSettings: false,              // TESTED
        editMetadata: false,                // TESTED
        editDepositsSettings: false,        // TESTED
        editForceRebalanceSettings: false,  // TESTED
        editCustomRebalanceSettings: false, // TESTED
        editAddTokenDelay: false,           // NOT TESTED
        editUpdateWeightsDelay: false,      // NOT TESTED
        editMakeDirectSwapDelay: false,     // NOT TESTED
    
        addOrEditToken: false,              // TESTED
        updateWeights: false,               // NOT TESTED
        makeDirectSwap: false,              // NOT TESTED

        executeIntent: false,               // TESTED

        buyBasket: false,                   // TESTED
        depositTokens: false,               // TESTED
        lockDeposits: false,                // TESTED

        sellBasket: false,                  // TESTED

        rebalanceBasket: false,             // TESTED
        rebalanceBasketCustom: false,       // NOT TESTED

        updateTokenPrices: false,           // TESTED
        updateTokenPricesCustom: false,     // NOT TESTED

        rebalanceSwapAll: false,            // TESTED
        rebalanceSwap: false,               // TESTED

        mintBasket: false,                  // TESTED

        redeemTokens: false,                // TESTED
        claimBounty: false,                 // TESTED

        withdrawBasketFees: false,          // NOT TESTED
        claimTokenFeesFromBasket: false,    // NOT TESTED
    }

    if (tests.createBasket) {
         let createBasketTx = await sdk.createBasketTx({
            creator: wallet.publicKey.toBase58(),
            start_price: "1",
            name: "Test Basket",
            symbol: "TBC",
            metadata_uri: "https://test.com",
        });
        console.log(createBasketTx.batches[0].transactions[0]);
        return;
        let resCreateBasket = await sdk.signAndSendTxPayloadBatchSequence({
            txPayloadBatchSequence: createBasketTx,
            wallet,
        });
        console.log(resCreateBasket);
    }

    if (tests.addBounty) {
        let tx = await sdk.addBountyTx({
            keeper: wallet.publicKey.toBase58(),
            basket: basket.ownAddress.toBase58(),
            amount: 250 * 10 ** 6,
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    let task_context: TaskContext = {
        basket: basket.ownAddress.toBase58(),
        manager: wallet.publicKey.toBase58(),
    }
   
    if (tests.editCreator) {
        let creator_settings: EditCreatorSettings = {
            creator: wallet.publicKey.toBase58(),
        }
        let tx = await sdk.editCreatorTx(task_context, creator_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editManagerSettings) {
        let manager_settings: EditManagerSettings = {
            managers: [
                {
                    pubkey: wallet.publicKey.toBase58(),
                    fee_split_weight_bps: 5000,
                    authorities: {
                        managers: true, fees: true, schedule: true, automation: true, lp: true, metadata: true, deposits: true, force_rebalance: true, custom_rebalance: true, add_token: true, update_weights: true, make_direct_swap: true,
                    },
                },
                {
                    pubkey: "UserevMsvU5K9u6iW7DT9XJVyVLpmfDCEAfXixBbE7R",
                    fee_split_weight_bps: 5000,
                    authorities: {
                        managers: true, fees: true, schedule: true, automation: true, lp: true, metadata: true, deposits: true, force_rebalance: true, custom_rebalance: true, add_token: true, update_weights: true, make_direct_swap: true,
                    },
                },
            ],
            modification_delay: 0,
        };
        let tx = await sdk.editManagersTx(task_context, manager_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editFeeSettings) {
        let fee_settings: EditFeeSettings = {
            creator_deposit_fee_bps: 100,
            creator_withdraw_fee_bps: 100,
            creator_management_fee_bps: 0,
            creator_performance_fee_bps: 0,
            managers_deposit_fee_bps: 100,
            managers_withdraw_fee_bps: 100,
            managers_management_fee_bps: 0,
            managers_performance_fee_bps: 0,
            basket_deposit_fee_bps: 100,
            basket_withdraw_fee_bps: 100,
            modification_delay: 0,
        };    
        let tx = await sdk.editFeesTx({ ...task_context, activation_timestamp: Date.now() / 1000 + 10 }, fee_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editScheduleSettings) {
        let schedule_settings: EditScheduleSettings ={
            cycle_start_time: 0,
            cycle_duration: 86400,
            deposits_start: 0,
            deposits_end: 86400,
            automation_start: 0,
            automation_end: 86400,
            management_start: 0,
            management_end: 86400,
            modification_delay: 0,
        };
        let tx = await sdk.editScheduleTx(task_context, schedule_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editAutomationSettings) {
        let automation_settings: EditAutomationSettings = {
            enabled: true,
            rebalance_slippage_threshold_bps: 100,
            per_trade_rebalance_slippage_threshold_bps: 100,
            rebalance_activation_threshold_abs_bps: 100,
            rebalance_activation_threshold_rel_bps: 100,
            rebalance_activation_cooldown: 100,
            modification_delay: 0,
        };
        let tx = await sdk.editAutomationTx(task_context, automation_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editLpSettings) {
        let lp_settings: EditLpSettings = {
            enabled: true,
            lp_threshold_bps: 100,
            modification_delay: 0,
        };
        let tx = await sdk.editLpTx(task_context, lp_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editMetadata) {
        let metadata_settings: EditMetadataSettings = {
            symbol: "YSOLTEST",
            name: "Solana Test",
            uri: "https://raw.githubusercontent.com/symmetry-protocol/markets/8179d21e003459a615eb21e3113166b7576d8e5e/ysol-metadata.json",
            modification_delay: 0,
        };
        let tx = await sdk.editMetadataTx(task_context, metadata_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editDepositsSettings) {
        let deposits_settings: EditDepositsSettings = {
            enabled: true,
        };
        let tx = await sdk.editDepositsTx(task_context, deposits_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editForceRebalanceSettings) {
        let force_rebalance_settings: EditForceRebalanceSettings = {
            enabled: true,
            modification_delay: 0,
        };
        let tx = await sdk.editForceRebalanceTx(task_context, force_rebalance_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editCustomRebalanceSettings) {
        let custom_rebalance_settings: EditCustomRebalanceSettings = {
            enabled: true,
            modification_delay: 0,
        };
        let tx = await sdk.editCustomRebalanceTx(task_context, custom_rebalance_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }
    
    if (tests.editAddTokenDelay) {
        let add_token_delay: EditAddTokenSettings = {
            modification_delay: 0,
        };
        let tx = await sdk.editAddTokenDelayTx(task_context, add_token_delay);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editUpdateWeightsDelay) {
        let update_weights_settings: EditUpdateWeightsSettings = {
            modification_delay: 0,
        };
        let tx = await sdk.editUpdateWeightsDelayTx(task_context, update_weights_settings);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editMakeDirectSwapDelay) {
        let make_direct_swap_delay: EditMakeDirectSwapSettings = {
            modification_delay: 0,
        };
        let tx = await sdk.editSwapDelayTx(task_context, make_direct_swap_delay);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.addOrEditToken) {
        let add_token: AddOrEditTokenInput = {
            token_mint: "So11111111111111111111111111111111111111112",
            active: true,
            min_oracles_thresh: 1,
            min_conf_bps: 100,
            conf_thresh_bps: 200,
            conf_multiplier: 1,
            oracles: [
                {
                    oracle_type: "pyth",
                    account_lut_id: 0,
                    account_lut_index: 0,
                    account: PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT.toBase58(),
                    weight: 100,
                    is_required: true,
                    conf_thresh_bps: 100,
                    volatility_thresh_bps: 100,
                    max_slippage_bps: 100,
                    min_liquidity: 100,
                    staleness_thresh: 10000,
                    staleness_conf_rate_bps: 100,
                    token_decimals: 9,
                    twap_seconds_ago: 100,
                    twap_secondary_seconds_ago: 100,
                },
            ],
        };
        let tx = await sdk.addOrEditTokenTx(task_context, add_token);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.updateWeights) {
        let update_weights: UpdateWeightsInput = {
            token_weights: [
                {
                    mint: "So11111111111111111111111111111111111111112",
                    weight_bps: 100,
                },
            ],
            token_mints_hash: [
                0, 0, 0, 0,
            ],
        };
        let tx = await sdk.updateWeightsTx(task_context, update_weights);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.makeDirectSwap) {
        let make_direct_swap: MakeDirectSwapInput = {
            from_token_mint: "So11111111111111111111111111111111111111112",
            to_token_mint: "So11111111111111111111111111111111111111112",
            amount_from: 100,
            amount_to: 100,
        };
        let tx = await sdk.makeDirectSwapTx(task_context, make_direct_swap);
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.buyBasket) {
        let tx = await sdk.buyBasketTx({
            buyer: wallet.publicKey.toBase58(),
            basket_mint: basket.mint.toBase58(),
            contributions: [
                // {mint: "So11111111111111111111111111111111111111112", amount: 1000000000},
                {mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", amount: 2000000},
            ],
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.sellBasket) {
        let tx = await sdk.sellBasketTx({
            seller: wallet.publicKey.toBase58(),
            basket_mint: basket.mint.toBase58(),
            withdraw_amount: 2 * 10 ** 6,
            keep_tokens: ["USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT"],
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.rebalanceBasket) {
        let tx = await sdk.rebalanceBasketTx({
            keeper: wallet.publicKey.toBase58(),
            basket_mint: "9j28U9fKfPbau7jLGw8zKT1SZouyEaRizBT9DFXpYHQ9",
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.updateTokenPrices) {
        let rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
        let tx = await sdk.updateTokenPricesTx({
            keeper: wallet.publicKey.toBase58(),
            basket: basket.ownAddress.toBase58(),
            rebalance_intent: rebalanceIntent.toBase58(),
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.rebalanceSwapAll) {
        let rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
        let state = await sdk.fetchRebalanceIntent(rebalanceIntent.toBase58());
        let pairs = getSwapPairs(state.chain_data, basket);
        console.log(pairs);
        for (let pair of pairs) try {
            let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses , quoteResponse} = await getJupTokenLedgerAndSwapInstructions({
                keeper: wallet.publicKey,
                basketMintIn: basket.mint,
                basketMintOut: basket.mint,
                basketAmountIn: pair.inAmount,
                basketAmountOut: pair.outAmount,
                swapMode: "ioc",
                apiKey: jupApiKey,
                maxJupAccounts: 45,
            });
            console.log(quoteResponse);
            let tx = await sdk.flashSwapTx({
                keeper: wallet.publicKey.toBase58(),
                basket: basket.ownAddress.toBase58(),
                rebalance_intent: rebalanceIntent.toBase58(),
                mint_in: pair.inMint,
                mint_out: pair.outMint,
                amount_in: pair.inAmount,
                amount_out: pair.outAmount,
                mode: 2,
                jup_token_ledger_ix: tokenLedgerInstruction,
                jup_swap_ix: swapInstruction,
                jup_address_lookup_table_addresses: addressLookupTableAddresses,
            });
            let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
            console.log(res);
        } catch { continue; }
    }

    if (tests.rebalanceSwap) {
        let rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
        let tx = await sdk.flashSwapTx({
            keeper: wallet.publicKey.toBase58(),
            basket: basket.ownAddress.toBase58(),
            rebalance_intent: rebalanceIntent.toBase58(),
            mint_in: "USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT",
            mint_out: "So11111111111111111111111111111111111111112",
            amount_in: 100 * 10 ** 6,
            amount_out: 1 * 10 ** 9,
            mode: 2,
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.mintBasket) {
        let rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
        let tx = await sdk.mintTx({
            keeper: wallet.publicKey.toBase58(),
            rebalance_intent: rebalanceIntent.toBase58(),
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
        return;
    }

    if (tests.redeemTokens) {
        let rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
        let state = await sdk.fetchRebalanceIntent(rebalanceIntent.toBase58());
        let endTimestamp = state.formatted_data.auctions[2].end_time ?? 0;
        let now = Date.now() / 1000;
        console.log(now, endTimestamp, endTimestamp - now);
        let tx = await sdk.redeemTokensTx({
            keeper: wallet.publicKey.toBase58(),
            rebalance_intent: rebalanceIntent.toBase58(),
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.claimBounty) {
        let rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
        let tx = await sdk.claimBountyTx({
            keeper: wallet.publicKey.toBase58(),
            rebalance_intent: rebalanceIntent.toBase58(),
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.withdrawBasketFees) {
        let tx = await sdk.withdrawBasketFeesTx({
            claimer: wallet.publicKey.toBase58(),
            basket: basket.ownAddress.toBase58(),
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.claimTokenFeesFromBasket) {
        let tx = await sdk.claimTokenFeesFromBasketTx({
            claimer: wallet.publicKey.toBase58(),
            withdrawBasketFees: new PublicKey("").toBase58(),
        });
        let res = await sdk.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet});
        console.log(res);
    }

    if (tests.editGlobalConfig) {
        let editGlobalConfigTx = await sdk.editGlobalConfigTx({
            signer: wallet.publicKey,
            config: {
                admin: new PublicKey("DEVePdJBmogeJkAmaWRpdV7KaynaQJHt9zowCisSQkAf"),
                owners: [
                    new PublicKey("UserevMsvU5K9u6iW7DT9XJVyVLpmfDCEAfXixBbE7R"),
                    new PublicKey("Bm7uwxU8sTKhNhrsa5YWAQWmVTDBNMjgmYmAb4o1uDhq"),
                    new PublicKey("DEVePdJBmogeJkAmaWRpdV7KaynaQJHt9zowCisSQkAf")
                ],

                totalNumberOfBaskets: new BN(0),

                allowInteractions: 1,
                allowCreation: 1,
                allowManagement: 1,
                allowAutomation: 1,
                allowDeposits: 1,
                allowWithdraws: 1,

                maxDepositFeeBps: 1000,
                maxWithdrawFeeBps: 1000,
                maxManagementFeeBps: 2000,
                maxPerformanceFeeBps: 2000,

                symmetryFeeCollector: new PublicKey("UserevMsvU5K9u6iW7DT9XJVyVLpmfDCEAfXixBbE7R"),
                symmetryDepositFeeBps: 10,
                symmetryDepositFeeShareBps: 50,
                symmetryWithdrawFeeBps: 50,
                symmetryWithdrawFeeShareBps: 50,
                symmetryManagementFeeBps: 50,
                symmetryManagementFeeShareBps: 50,
                symmetryPerformanceFeeBps: 50,
                symmetryPerformanceFeeShareBps: 50,
                symmetryTradeFeeBps: 50,
                symmetryLimitOrderFeeBps: 50,
                symmetryFeesExtraData: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,],

                bountyMint: new PublicKey("So11111111111111111111111111111111111111112"),
                minBountyForBasketAutomation: new BN(200 * 50 * 10 ** 3),
                bountyBondAmount: new BN(5 * 50 * 10 ** 3),
                bountyPerTask: {
                    minBounty: new BN(1 * 50 * 10 ** 3),
                    maxBounty: new BN(2 * 50 * 10 ** 3),
                    minBountyUntil: new BN(1),
                    maxBountyAfter: new BN(101),
                },
                bountyPerPriceUpdateTaskDivisor: new BN(5),
                minRemainingValue: {high: new BN(0), low: new BN("1844674407370955161")},
                minMintRatio: {high: new BN(0), low:  new BN("18444899399302180660")},
            
                aprBpsPerYear: 3334,
                rebalanceIntentLifetime: new BN(10 * 60),
                rebalanceAuction1Timeframe: new BN(100),
                rebalanceAuction2Timeframe: new BN(50),
                rebalanceAuction3Timeframe: new BN(25),
            
                priceUpdateDelayAfterCreation: new BN(16),
                priceUpdateLifetime: new BN(60),
                priceUpdateReexecutionDelay: new BN(30),
            
                extraData: [
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                    new BN(0), new BN(0), new BN(0), new BN(0),
                ]
            }
            ,
        });
        let resEditGlobalConfigTx = await sdk.signAndSendTxPayloadBatchSequence({
            txPayloadBatchSequence: editGlobalConfigTx,
            wallet,
        });
        console.log(resEditGlobalConfigTx);
        return;
    }
}

testStates();