import { tryPublicKey } from '@cardinal/namespaces-components';
import { stakePoolMetadatas } from 'api/mapping';
import { useRouter } from 'next/router';
import { useEnvironmentCtx as useEnvironmentCtx$1 } from 'providers/EnvironmentProvider';
import { getStakePool, getStakeAuthorizationsForPool, getStakeEntries, getAllStakeEntries, getAllStakePools, getStakeEntriesForUser, getActiveStakeEntriesForPool } from '@cardinal/staking/dist/cjs/programs/stakePool/accounts';
import { useQuery } from 'react-query';
import { getBatchedMultipleAccounts, findAta } from '@cardinal/common';
import * as splToken from '@solana/spl-token';
import * as metaplex from '@metaplex-foundation/mpl-token-metadata';
import { findStakeEntryIdFromMint } from '@cardinal/staking/dist/cjs/programs/stakePool/utils';
import { PublicKey, Connection, Keypair } from '@solana/web3.js';
import { useWallet } from '@solana/wallet-adapter-react';
import { findRewardDistributorId, findRewardEntryId } from '@cardinal/staking/dist/cjs/programs/rewardDistributor/pda';
import { getRewardDistributor, getRewardEntries } from '@cardinal/staking/dist/cjs/programs/rewardDistributor/accounts';
import { firstParam as firstParam$1 } from 'common/utils';
import { BN, BorshAccountsCoder, utils } from '@project-serum/anchor';
import { useUTCNow as useUTCNow$1 } from 'providers/UTCNowProvider';
import { getRewardMap } from '@cardinal/staking';
import { RewardDistributorKind } from '@cardinal/staking/dist/cjs/programs/rewardDistributor';
import { STAKE_POOL_IDL, STAKE_POOL_ADDRESS } from '@cardinal/staking/dist/cjs/programs/stakePool';
import React, { useState, useMemo, useContext, useEffect } from 'react';

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function __generator(thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
}

function __spreadArray(to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
}

var useStakePoolId = function () {
    var stakePoolId = useRouter().query.stakePoolId;
    var nameMapping = stakePoolMetadatas.find(function (p) { return p.name === stakePoolId; });
    var addressMapping = stakePoolMetadatas.find(function (p) { return p.stakePoolAddress.toString() === stakePoolId; });
    var publicKey = (nameMapping === null || nameMapping === void 0 ? void 0 : nameMapping.stakePoolAddress) ||
        (addressMapping === null || addressMapping === void 0 ? void 0 : addressMapping.stakePoolAddress) ||
        tryPublicKey(stakePoolId);
    return publicKey;
};

var useStakePoolData = function () {
    var stakePoolId = useStakePoolId();
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    return useQuery(['stakePoolData', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (!stakePoolId)
                return [2 /*return*/];
            return [2 /*return*/, getStakePool(secondaryConnection, stakePoolId)];
        });
    }); });
};

var useStakeAuthorizationsForPool = function () {
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var stakePoolId = useStakePoolId();
    return useQuery(['useStakeAuthorizationsForPool', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (stakePoolId) {
                return [2 /*return*/, getStakeAuthorizationsForPool(secondaryConnection, stakePoolId)];
            }
            return [2 /*return*/];
        });
    }); }, { enabled: !!stakePoolId });
};

var useWalletId = function () {
    var wallet = useWallet();
    var query = useRouter().query;
    return tryPublicKey(query.wallet) || wallet.publicKey;
};

var useTokenList = function () {
    return useQuery(['useTokenList'], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, fetch('https://raw.githubusercontent.com/solana-labs/token-list/main/src/tokens/solana.tokenlist.json')
                        .then(function (response) { return response.json(); })
                        .then(function (data) { return data['tokens']; })];
                case 1: return [2 /*return*/, _a.sent()];
            }
        });
    }); }, {
        retry: 2,
    });
};

var allowedTokensForPool = function (tokenDatas, stakePool, stakeAuthorizations, allowFrozen) {
    return tokenDatas.filter(function (token) {
        var _a, _b, _c;
        var isAllowed = true;
        var creatorAddresses = stakePool.parsed.requiresCreators;
        var collectionAddresses = stakePool.parsed.requiresCollections;
        var requiresAuthorization = stakePool.parsed.requiresAuthorization;
        if (!allowFrozen &&
            ((_a = token.tokenAccount) === null || _a === void 0 ? void 0 : _a.account.data.parsed.info.state) === 'frozen') {
            return false;
        }
        if (stakePool.parsed.requiresCreators.length > 0 ||
            stakePool.parsed.requiresCollections.length > 0 ||
            stakePool.parsed.requiresAuthorization) {
            isAllowed = false;
            if (creatorAddresses && creatorAddresses.length > 0) {
                creatorAddresses.forEach(function (filterCreator) {
                    var _a, _b, _c, _d, _e, _f;
                    if (((_c = (_b = (_a = token === null || token === void 0 ? void 0 : token.metaplexData) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.creators) &&
                        ((_f = (_e = (_d = token === null || token === void 0 ? void 0 : token.metaplexData) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.creators).some(function (c) { return c.address === filterCreator.toString() && c.verified; })) {
                        isAllowed = true;
                    }
                });
            }
            if (collectionAddresses && collectionAddresses.length > 0 && !isAllowed) {
                collectionAddresses.forEach(function (collectionAddress) {
                    var _a, _b, _c, _d, _e, _f;
                    if (((_c = (_b = (_a = token.metaplexData) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.collection) === null || _c === void 0 ? void 0 : _c.verified) &&
                        ((_f = (_e = (_d = token.metaplexData) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.collection) === null || _f === void 0 ? void 0 : _f.key.toString()) ===
                            collectionAddress.toString()) {
                        isAllowed = true;
                    }
                });
            }
            if (requiresAuthorization &&
                ((_b = stakeAuthorizations === null || stakeAuthorizations === void 0 ? void 0 : stakeAuthorizations.map(function (s) { return s.parsed.mint.toString(); })) === null || _b === void 0 ? void 0 : _b.includes((_c = token === null || token === void 0 ? void 0 : token.tokenAccount) === null || _c === void 0 ? void 0 : _c.account.data.parsed.info.mint))) {
                isAllowed = true;
            }
        }
        return isAllowed;
    });
};
var useAllowedTokenDatas = function (showFungibleTokens) {
    var stakePoolId = useStakePoolId();
    var walletId = useWalletId();
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var tokenList = useTokenList().data;
    var stakePool = useStakePoolData().data;
    var stakeAuthorizations = useStakeAuthorizationsForPool().data;
    return useQuery(['allowedTokenDatas', stakePoolId, showFungibleTokens, tokenList === null || tokenList === void 0 ? void 0 : tokenList.length], function () { return __awaiter(void 0, void 0, void 0, function () {
        var allTokenAccounts, tokenAccounts, metaplexIds, metaplexAccountInfos, metaplexData, baseTokenDatas, allowedTokens, stakeEntryIds, stakeEntries, _a, metadata;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    if (!stakePoolId || !stakePool || !walletId)
                        return [2 /*return*/];
                    return [4 /*yield*/, secondaryConnection.getParsedTokenAccountsByOwner(walletId, {
                            programId: splToken.TOKEN_PROGRAM_ID,
                        })];
                case 1:
                    allTokenAccounts = _b.sent();
                    tokenAccounts = allTokenAccounts.value
                        .filter(function (tokenAccount) {
                        return tokenAccount.account.data.parsed.info.tokenAmount.uiAmount > 0;
                    })
                        .sort(function (a, b) { return a.pubkey.toBase58().localeCompare(b.pubkey.toBase58()); });
                    return [4 /*yield*/, Promise.all(tokenAccounts.map(function (tokenAccount) { return __awaiter(void 0, void 0, void 0, function () {
                            return __generator(this, function (_a) {
                                switch (_a.label) {
                                    case 0: return [4 /*yield*/, metaplex.MetadataProgram.findMetadataAccount(new PublicKey(tokenAccount.account.data.parsed.info.mint))];
                                    case 1: return [2 /*return*/, (_a.sent())[0]];
                                }
                            });
                        }); }))];
                case 2:
                    metaplexIds = _b.sent();
                    return [4 /*yield*/, getBatchedMultipleAccounts(secondaryConnection, metaplexIds)];
                case 3:
                    metaplexAccountInfos = _b.sent();
                    metaplexData = metaplexAccountInfos.reduce(function (acc, accountInfo, i) {
                        try {
                            acc[tokenAccounts[i].pubkey.toString()] = __assign(__assign({ pubkey: metaplexIds[i] }, accountInfo), { data: metaplex.MetadataData.deserialize(accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.data) });
                        }
                        catch (e) { }
                        return acc;
                    }, {});
                    baseTokenDatas = tokenAccounts.map(function (tokenAccount, i) { return ({
                        tokenAccount: tokenAccount,
                        metaplexData: metaplexData[tokenAccount.pubkey.toString()],
                        tokenListData: tokenList === null || tokenList === void 0 ? void 0 : tokenList.find(function (t) {
                            return t.address === (tokenAccount === null || tokenAccount === void 0 ? void 0 : tokenAccount.account.data.parsed.info.mint.toString());
                        }),
                    }); });
                    allowedTokens = allowedTokensForPool(baseTokenDatas, stakePool, stakeAuthorizations).filter(function (tokenData) { return showFungibleTokens === !!tokenData.tokenListData; });
                    return [4 /*yield*/, Promise.all(allowedTokens.map(function (allowedToken) { return __awaiter(void 0, void 0, void 0, function () {
                            var _a;
                            return __generator(this, function (_b) {
                                switch (_b.label) {
                                    case 0: return [4 /*yield*/, findStakeEntryIdFromMint(secondaryConnection, walletId, stakePoolId, new PublicKey((_a = allowedToken.tokenAccount) === null || _a === void 0 ? void 0 : _a.account.data.parsed.info.mint))];
                                    case 1: return [2 /*return*/, (_b.sent())[0]];
                                }
                            });
                        }); }))];
                case 4:
                    stakeEntryIds = _b.sent();
                    if (!(stakeEntryIds.length > 0)) return [3 /*break*/, 6];
                    return [4 /*yield*/, getStakeEntries(secondaryConnection, stakeEntryIds)];
                case 5:
                    _a = _b.sent();
                    return [3 /*break*/, 7];
                case 6:
                    _a = [];
                    _b.label = 7;
                case 7:
                    stakeEntries = _a;
                    return [4 /*yield*/, Promise.all(allowedTokens.map(function (allowedToken) { return __awaiter(void 0, void 0, void 0, function () {
                            var json;
                            var _a;
                            return __generator(this, function (_b) {
                                switch (_b.label) {
                                    case 0:
                                        _b.trys.push([0, 2, , 3]);
                                        if (!((_a = allowedToken.metaplexData) === null || _a === void 0 ? void 0 : _a.data.data.uri))
                                            return [2 /*return*/, null];
                                        return [4 /*yield*/, fetch(allowedToken.metaplexData.data.data.uri).then(function (r) { return r.json(); })];
                                    case 1:
                                        json = _b.sent();
                                        return [2 /*return*/, {
                                                pubkey: allowedToken.metaplexData.pubkey,
                                                data: json,
                                            }];
                                    case 2:
                                        _b.sent();
                                        return [2 /*return*/, null];
                                    case 3: return [2 /*return*/];
                                }
                            });
                        }); }))];
                case 8:
                    metadata = _b.sent();
                    return [2 /*return*/, allowedTokens.map(function (allowedToken, i) { return (__assign(__assign({}, allowedToken), { metadata: metadata.find(function (data) {
                                var _a;
                                return data
                                    ? data.pubkey.toBase58() ===
                                        ((_a = allowedToken.metaplexData) === null || _a === void 0 ? void 0 : _a.pubkey.toBase58())
                                    : undefined;
                            }), stakeEntryData: stakeEntries[i] })); })];
            }
        });
    }); }, {
        refetchInterval: 30000,
        enabled: !!stakePoolId && !!walletId,
    });
};

var useAllStakeEntries = function () {
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var stakePoolId = useStakePoolId();
    return useQuery(['useAllStakeEntries', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            return [2 /*return*/, getAllStakeEntries(secondaryConnection)];
        });
    }); });
};

var useAllStakePools = function () {
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var stakePoolId = useStakePoolId();
    return useQuery(['useAllStakePools', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        var allStakePoolDatas, _a, stakePoolsWithMetadata, stakePoolsWithoutMetadata;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0: return [4 /*yield*/, getAllStakePools(secondaryConnection)];
                case 1:
                    allStakePoolDatas = _b.sent();
                    _a = allStakePoolDatas.reduce(function (acc, stakePoolData) {
                        var stakePoolMetadata = stakePoolMetadatas.find(function (md) {
                            return md.stakePoolAddress.toString() === stakePoolData.pubkey.toString();
                        });
                        if (stakePoolMetadata) {
                            return [__spreadArray(__spreadArray([], acc[0], true), [{ stakePoolMetadata: stakePoolMetadata, stakePoolData: stakePoolData }], false), acc[1]];
                        }
                        return [acc[0], __spreadArray(__spreadArray([], acc[1], true), [{ stakePoolData: stakePoolData }], false)];
                    }, [[], []]), stakePoolsWithMetadata = _a[0], stakePoolsWithoutMetadata = _a[1];
                    return [2 /*return*/, {
                            stakePoolsWithMetadata: stakePoolsWithMetadata.sort(function (a, b) {
                                return a
                                    .stakePoolMetadata.name.toString()
                                    .localeCompare(b.stakePoolMetadata.name.toString());
                            }),
                            stakePoolsWithoutMetadata: stakePoolsWithoutMetadata,
                        }];
            }
        });
    }); });
};

var useRecentSignatures = function (address) {
    var environment = useEnvironmentCtx$1().environment;
    var connection = new Connection(environment.primary, {
        commitment: 'confirmed',
    });
    return useQuery(['useRecentSignatures', address === null || address === void 0 ? void 0 : address.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (!address)
                return [2 /*return*/];
            return [2 /*return*/, connection.getSignaturesForAddress(address, { limit: 10 }, 'confirmed')];
        });
    }); }, { refetchInterval: 3000 });
};

var useRewardDistributorData = function () {
    var stakePoolId = useStakePoolId();
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    return useQuery(['useRewardDistributorData', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        var rewardDistributorId;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!stakePoolId)
                        return [2 /*return*/];
                    return [4 /*yield*/, findRewardDistributorId(stakePoolId)];
                case 1:
                    rewardDistributorId = (_a.sent())[0];
                    return [4 /*yield*/, getRewardDistributor(secondaryConnection, rewardDistributorId)];
                case 2: return [2 /*return*/, _a.sent()];
            }
        });
    }); }, { enabled: !!stakePoolId });
};

var useRewardDistributorTokenAccount = function () {
    var _a, _b;
    var rewardDistibutorData = useRewardDistributorData();
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    return useQuery([
        'useRewardDistributorTokenAccount',
        (_b = (_a = rewardDistibutorData === null || rewardDistibutorData === void 0 ? void 0 : rewardDistibutorData.data) === null || _a === void 0 ? void 0 : _a.pubkey) === null || _b === void 0 ? void 0 : _b.toString(),
    ], function () { return __awaiter(void 0, void 0, void 0, function () {
        var rewardDistributorTokenAccount, rewardMint;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!rewardDistibutorData.data)
                        return [2 /*return*/];
                    return [4 /*yield*/, findAta(rewardDistibutorData.data.parsed.rewardMint, rewardDistibutorData.data.pubkey, true)];
                case 1:
                    rewardDistributorTokenAccount = _a.sent();
                    rewardMint = new splToken.Token(secondaryConnection, rewardDistibutorData.data.parsed.rewardMint, splToken.TOKEN_PROGRAM_ID, Keypair.generate() // not used
                    );
                    return [4 /*yield*/, rewardMint.getAccountInfo(rewardDistributorTokenAccount)];
                case 2: return [2 /*return*/, _a.sent()];
            }
        });
    }); }, { enabled: !!rewardDistibutorData.data });
};

var useWalletIds = function () {
    var wallet = useWallet();
    var query = useRouter().query;
    var walletIds = __spreadArray(__spreadArray([], firstParam$1(query.wallet)
        .split(',')
        .map(function (id) { return tryPublicKey(id); }), true), [
        wallet.publicKey,
    ], false);
    return walletIds.filter(function (id) { return id !== null; });
};

function getStakeEntryDatas(connection, stakePoolId, userId) {
    return __awaiter(this, void 0, void 0, function () {
        var stakeEntries, metaplexIds, metaplexAccountInfos, metaplexData, metadata;
        var _this = this;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, getStakeEntriesForUser(connection, userId)];
                case 1:
                    stakeEntries = (_a.sent()).filter(function (entry) { return entry.parsed.pool.toString() === stakePoolId.toString(); });
                    return [4 /*yield*/, Promise.all(stakeEntries.map(function (stakeEntry) { return __awaiter(_this, void 0, void 0, function () {
                            return __generator(this, function (_a) {
                                switch (_a.label) {
                                    case 0: return [4 /*yield*/, metaplex.MetadataProgram.findMetadataAccount(stakeEntry.parsed.originalMint)];
                                    case 1: return [2 /*return*/, (_a.sent())[0]];
                                }
                            });
                        }); }))];
                case 2:
                    metaplexIds = _a.sent();
                    return [4 /*yield*/, getBatchedMultipleAccounts(connection, metaplexIds)];
                case 3:
                    metaplexAccountInfos = _a.sent();
                    metaplexData = metaplexAccountInfos.reduce(function (acc, accountInfo, i) {
                        try {
                            acc[stakeEntries[i].pubkey.toString()] = __assign(__assign({ pubkey: metaplexIds[i] }, accountInfo), { data: metaplex.MetadataData.deserialize(accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.data) });
                        }
                        catch (e) { }
                        return acc;
                    }, {});
                    return [4 /*yield*/, Promise.all(Object.values(metaplexData).map(function (md, i) { return __awaiter(_this, void 0, void 0, function () {
                            var json;
                            return __generator(this, function (_a) {
                                switch (_a.label) {
                                    case 0:
                                        _a.trys.push([0, 2, , 3]);
                                        if (!md)
                                            return [2 /*return*/, null];
                                        return [4 /*yield*/, fetch(md.data.data.uri).then(function (r) { return r.json(); })];
                                    case 1:
                                        json = _a.sent();
                                        return [2 /*return*/, {
                                                pubkey: md.pubkey,
                                                data: json,
                                            }];
                                    case 2:
                                        _a.sent();
                                        return [2 /*return*/, null];
                                    case 3: return [2 /*return*/];
                                }
                            });
                        }); }))];
                case 4:
                    metadata = _a.sent();
                    return [2 /*return*/, stakeEntries.map(function (stakeEntry) { return ({
                            stakeEntry: stakeEntry,
                            metaplexData: metaplexData[stakeEntry.pubkey.toString()],
                            metadata: metadata.find(function (data) {
                                var _a;
                                return data
                                    ? data.pubkey.toBase58() ===
                                        ((_a = metaplexData[stakeEntry.pubkey.toString()]) === null || _a === void 0 ? void 0 : _a.pubkey.toBase58())
                                    : undefined;
                            }),
                        }); })];
            }
        });
    });
}
var useStakedTokenDatas = function () {
    var stakePoolId = useStakePoolId();
    var walletIds = useWalletIds();
    var tokenList = useTokenList().data;
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    return useQuery([
        'stakedTokenDatas',
        stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString(),
        walletIds.join(','),
        tokenList === null || tokenList === void 0 ? void 0 : tokenList.length,
    ], function () { return __awaiter(void 0, void 0, void 0, function () {
        var stakeEntryDataGroups, tokenDatas, hydratedTokenDatas;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!stakePoolId || !walletIds || walletIds.length <= 0)
                        return [2 /*return*/];
                    return [4 /*yield*/, Promise.all(walletIds.map(function (walletId) {
                            return getStakeEntryDatas(secondaryConnection, stakePoolId, walletId);
                        }))];
                case 1:
                    stakeEntryDataGroups = _a.sent();
                    tokenDatas = stakeEntryDataGroups.flat();
                    hydratedTokenDatas = tokenDatas.reduce(function (acc, tokenData) {
                        var tokenListData;
                        try {
                            tokenListData = tokenList === null || tokenList === void 0 ? void 0 : tokenList.find(function (t) { var _a; return t.address === ((_a = tokenData.stakeEntry) === null || _a === void 0 ? void 0 : _a.parsed.originalMint.toString()); });
                        }
                        catch (e) { }
                        if (tokenListData) {
                            acc.push(__assign(__assign({}, tokenData), { tokenListData: tokenListData }));
                        }
                        else if (tokenData.metadata) {
                            acc.push(__assign(__assign({}, tokenData), { tokenListData: undefined }));
                        }
                        return acc;
                    }, []);
                    return [2 /*return*/, hydratedTokenDatas];
            }
        });
    }); }, { refetchInterval: 30000, enabled: !!stakePoolId && walletIds.length > 0 });
};

var useRewardEntries = function () {
    var _a;
    var rewardDistibutorData = useRewardDistributorData().data;
    var stakedTokenDatas = useStakedTokenDatas().data;
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    return useQuery([
        'useRewardEntries',
        (_a = rewardDistibutorData === null || rewardDistibutorData === void 0 ? void 0 : rewardDistibutorData.pubkey) === null || _a === void 0 ? void 0 : _a.toString(),
        stakedTokenDatas,
    ], function () { return __awaiter(void 0, void 0, void 0, function () {
        var rewardDistibutorId, stakeEntryIds, rewardEntryIds;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    rewardDistibutorId = rewardDistibutorData === null || rewardDistibutorData === void 0 ? void 0 : rewardDistibutorData.pubkey;
                    if (!rewardDistibutorData || !stakedTokenDatas || !rewardDistibutorId) {
                        return [2 /*return*/, []];
                    }
                    stakeEntryIds = stakedTokenDatas
                        .filter(function (tk) { return tk && tk.stakeEntry; })
                        .map(function (tk) { return tk.stakeEntry; })
                        .map(function (entry) { return entry.pubkey; });
                    return [4 /*yield*/, Promise.all(stakeEntryIds.map(function (stakeEntryId) { return __awaiter(void 0, void 0, void 0, function () {
                            return __generator(this, function (_a) {
                                switch (_a.label) {
                                    case 0: return [4 /*yield*/, findRewardEntryId(rewardDistibutorId, stakeEntryId)];
                                    case 1: return [2 /*return*/, (_a.sent())[0]];
                                }
                            });
                        }); }))];
                case 1:
                    rewardEntryIds = _a.sent();
                    return [4 /*yield*/, getRewardEntries(secondaryConnection, rewardEntryIds)];
                case 2: return [2 /*return*/, (_a.sent()).filter(function (rewardEntry) { return rewardEntry.parsed; })];
            }
        });
    }); });
};

var useRewardMintInfo = function () {
    var _a;
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var tokenList = useTokenList().data;
    var rewardDistibutorData = useRewardDistributorData().data;
    return useQuery([
        'useRewardMintInfo',
        (_a = rewardDistibutorData === null || rewardDistibutorData === void 0 ? void 0 : rewardDistibutorData.pubkey) === null || _a === void 0 ? void 0 : _a.toString(),
        tokenList === null || tokenList === void 0 ? void 0 : tokenList.length,
    ], function () { return __awaiter(void 0, void 0, void 0, function () {
        var tokenListData, rewardMint, mintInfo;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!rewardDistibutorData)
                        return [2 /*return*/];
                    tokenListData = tokenList === null || tokenList === void 0 ? void 0 : tokenList.find(function (tk) {
                        return tk.address === (rewardDistibutorData === null || rewardDistibutorData === void 0 ? void 0 : rewardDistibutorData.parsed.rewardMint.toString());
                    });
                    rewardMint = new splToken.Token(secondaryConnection, rewardDistibutorData.parsed.rewardMint, splToken.TOKEN_PROGRAM_ID, Keypair.generate() // not used
                    );
                    return [4 /*yield*/, rewardMint.getMintInfo()];
                case 1:
                    mintInfo = _a.sent();
                    return [2 /*return*/, {
                            mintInfo: mintInfo,
                            tokenListData: tokenListData,
                        }];
            }
        });
    }); });
};

var useRewards = function () {
    var _a;
    var rewardDistributorData = useRewardDistributorData().data;
    var rewardDistributorTokenAccount = useRewardDistributorTokenAccount().data;
    var stakedTokenDatas = useStakedTokenDatas().data;
    var rewardEntries = useRewardEntries().data;
    var rewardMintInfo = useRewardMintInfo().data;
    var UTCNow = useUTCNow$1().UTCNow;
    return useQuery([
        'useRewards',
        (_a = rewardDistributorData === null || rewardDistributorData === void 0 ? void 0 : rewardDistributorData.pubkey) === null || _a === void 0 ? void 0 : _a.toString(),
        rewardEntries,
        stakedTokenDatas,
        UTCNow,
    ], function () {
        if (!(stakedTokenDatas &&
            rewardEntries &&
            rewardDistributorData &&
            rewardMintInfo &&
            // rewardEntries.length > 0 &&
            ((rewardDistributorData === null || rewardDistributorData === void 0 ? void 0 : rewardDistributorData.parsed.kind) === RewardDistributorKind.Mint ||
                !!rewardDistributorTokenAccount))) {
            return { rewardMap: {}, claimableRewards: new BN(0) };
        }
        var stakeEntries = stakedTokenDatas
            .filter(function (tk) { return tk && tk.stakeEntry; })
            .map(function (tk) { return tk.stakeEntry; });
        return getRewardMap(stakeEntries, rewardEntries, rewardDistributorData, rewardDistributorData.parsed.kind === RewardDistributorKind.Mint
            ? rewardMintInfo === null || rewardMintInfo === void 0 ? void 0 : rewardMintInfo.mintInfo.supply
            : rewardDistributorTokenAccount.amount, UTCNow);
    }, {
        keepPreviousData: true,
        enabled: !!stakedTokenDatas &&
            !!rewardEntries &&
            !!rewardDistributorData &&
            ((rewardDistributorData === null || rewardDistributorData === void 0 ? void 0 : rewardDistributorData.parsed.kind) === RewardDistributorKind.Mint ||
                !!rewardDistributorTokenAccount),
    });
};

var useStakePoolEntries = function () {
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var stakePoolId = useStakePoolId();
    return useQuery(['useStakePoolEntries', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (stakePoolId) {
                return [2 /*return*/, getActiveStakeEntriesForPool(secondaryConnection, stakePoolId)];
            }
            return [2 /*return*/];
        });
    }); }, { enabled: !!stakePoolId });
};

var useStakePoolMaxStaked = function () {
    var stakePoolId = useStakePoolId();
    var addressMapping = stakePoolMetadatas.find(function (p) {
        return stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.equals(p.stakePoolAddress);
    });
    return (addressMapping === null || addressMapping === void 0 ? void 0 : addressMapping.maxStaked) || 0;
};

var useStakePoolMetadata = function () {
    var stakePoolId = useStakePoolId();
    return useQuery(['useStakePoolMetadata', stakePoolId === null || stakePoolId === void 0 ? void 0 : stakePoolId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (!stakePoolId)
                return [2 /*return*/];
            return [2 /*return*/, stakePoolMetadatas.find(function (p) { return p.stakePoolAddress.toString() === stakePoolId.toString(); })];
        });
    }); });
};

var getStakePoolsByAuthority = function (connection, user) { return __awaiter(void 0, void 0, void 0, function () {
    var programAccounts, stakePoolDatas, coder;
    return __generator(this, function (_a) {
        switch (_a.label) {
            case 0: return [4 /*yield*/, connection.getProgramAccounts(STAKE_POOL_ADDRESS, {
                    filters: [
                        {
                            memcmp: {
                                offset: 0,
                                bytes: utils.bytes.bs58.encode(BorshAccountsCoder.accountDiscriminator('stakePool')),
                            },
                        },
                        {
                            memcmp: {
                                offset: 17,
                                bytes: user.toBase58(),
                            },
                        },
                    ],
                })];
            case 1:
                programAccounts = _a.sent();
                stakePoolDatas = [];
                coder = new BorshAccountsCoder(STAKE_POOL_IDL);
                programAccounts.forEach(function (account) {
                    try {
                        var stakePoolData = coder.decode('stakePool', account.account.data);
                        if (stakePoolData) {
                            stakePoolDatas.push(__assign(__assign({}, account), { parsed: stakePoolData }));
                        }
                        // eslint-disable-next-line no-empty
                    }
                    catch (e) { }
                });
                return [2 /*return*/, stakePoolDatas.sort(function (a, b) {
                        return a.pubkey.toBase58().localeCompare(b.pubkey.toBase58());
                    })];
        }
    });
}); };
var useStakePoolsByAuthority = function () {
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var walletId = useWalletId();
    return useQuery(['useStakePoolsByAuthority', walletId === null || walletId === void 0 ? void 0 : walletId.toString()], function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (!walletId)
                return [2 /*return*/];
            return [2 /*return*/, getStakePoolsByAuthority(secondaryConnection, walletId)];
        });
    }); }, {
        enabled: !!walletId,
    });
};

var useUserTokenDatas = function () {
    var secondaryConnection = useEnvironmentCtx$1().secondaryConnection;
    var walletId = useWalletId();
    var tokenList = useTokenList().data;
    return useQuery(['useUserTokenDatas', walletId === null || walletId === void 0 ? void 0 : walletId.toString(), tokenList === null || tokenList === void 0 ? void 0 : tokenList.length], function () { return __awaiter(void 0, void 0, void 0, function () {
        var allTokenAccounts, tokenAccounts, metaplexIds, metaplexAccountInfos, metaplexData;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, secondaryConnection.getParsedTokenAccountsByOwner(walletId, {
                        programId: splToken.TOKEN_PROGRAM_ID,
                    })];
                case 1:
                    allTokenAccounts = _a.sent();
                    tokenAccounts = allTokenAccounts.value
                        .filter(function (tokenAccount) {
                        return tokenAccount.account.data.parsed.info.tokenAmount.uiAmount > 0;
                    })
                        .sort(function (a, b) { return a.pubkey.toBase58().localeCompare(b.pubkey.toBase58()); });
                    return [4 /*yield*/, Promise.all(tokenAccounts.map(function (tokenAccount) { return __awaiter(void 0, void 0, void 0, function () {
                            return __generator(this, function (_a) {
                                switch (_a.label) {
                                    case 0: return [4 /*yield*/, metaplex.MetadataProgram.findMetadataAccount(new PublicKey(tokenAccount.account.data.parsed.info.mint))];
                                    case 1: return [2 /*return*/, (_a.sent())[0]];
                                }
                            });
                        }); }))];
                case 2:
                    metaplexIds = _a.sent();
                    return [4 /*yield*/, getBatchedMultipleAccounts(secondaryConnection, metaplexIds)];
                case 3:
                    metaplexAccountInfos = _a.sent();
                    metaplexData = metaplexAccountInfos.reduce(function (acc, accountInfo, i) {
                        try {
                            acc[tokenAccounts[i].pubkey.toString()] = __assign(__assign({ pubkey: metaplexIds[i] }, accountInfo), { data: metaplex.MetadataData.deserialize(accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.data) });
                        }
                        catch (e) { }
                        return acc;
                    }, {});
                    return [2 /*return*/, tokenAccounts.map(function (tokenAccount, i) { return ({
                            tokenAccount: tokenAccount,
                            metaplexData: metaplexData[tokenAccount.pubkey.toString()],
                            tokenListData: tokenList === null || tokenList === void 0 ? void 0 : tokenList.find(function (t) {
                                return t.address === (tokenAccount === null || tokenAccount === void 0 ? void 0 : tokenAccount.account.data.parsed.info.mint.toString());
                            }),
                        }); })];
            }
        });
    }); }, {
        enabled: !!walletId,
    });
};

var firstParam = function (param) {
    if (!param)
        return '';
    return typeof param === 'string' ? param : param[0] || '';
};

var ENVIRONMENTS = [
    {
        label: 'mainnet-beta',
        primary: process.env.MAINNET_PRIMARY || 'https://ssc-dao.genesysgo.net',
        secondary: 'https://ssc-dao.genesysgo.net',
    },
    {
        label: 'testnet',
        primary: 'https://api.testnet.solana.com',
    },
    {
        label: 'devnet',
        primary: 'https://api.devnet.solana.com',
    },
];
var EnvironmentContext = React.createContext(null);
var getInitialProps = function (_a) {
    var ctx = _a.ctx;
    return __awaiter(void 0, void 0, void 0, function () {
        var cluster;
        var _b, _c, _d;
        return __generator(this, function (_e) {
            cluster = ((_c = (((_b = ctx.req) === null || _b === void 0 ? void 0 : _b.headers.host) || ctx.query.host)) === null || _c === void 0 ? void 0 : _c.includes('dev'))
                ? 'devnet'
                : ((_d = (ctx.query.project || ctx.query.host)) === null || _d === void 0 ? void 0 : _d.includes('test'))
                    ? 'testnet'
                    : ctx.query.cluster || process.env.BASE_CLUSTER;
            return [2 /*return*/, {
                    cluster: firstParam(cluster),
                }];
        });
    });
};
function EnvironmentProvider(_a) {
    var _b, _c;
    var children = _a.children, defaultCluster = _a.defaultCluster, query = _a.query;
    var cluster = ((_b = (query.project || query.host)) === null || _b === void 0 ? void 0 : _b.includes('dev'))
        ? 'devnet'
        : ((_c = query.host) === null || _c === void 0 ? void 0 : _c.includes('test'))
            ? 'testnet'
            : query.cluster || defaultCluster || process.env.BASE_CLUSTER;
    var foundEnvironment = ENVIRONMENTS.find(function (e) { return e.label === cluster; });
    var _d = useState(foundEnvironment !== null && foundEnvironment !== void 0 ? foundEnvironment : ENVIRONMENTS[0]), environment = _d[0], setEnvironment = _d[1];
    useMemo(function () {
        var foundEnvironment = ENVIRONMENTS.find(function (e) { return e.label === cluster; });
        setEnvironment(foundEnvironment !== null && foundEnvironment !== void 0 ? foundEnvironment : ENVIRONMENTS[0]);
    }, [cluster]);
    var connection = useMemo(function () { return new Connection(environment.primary, { commitment: 'recent' }); }, [environment]);
    var secondaryConnection = useMemo(function () {
        var _a;
        return new Connection((_a = environment.secondary) !== null && _a !== void 0 ? _a : environment.primary, {
            commitment: 'recent',
        });
    }, [environment]);
    return (React.createElement(EnvironmentContext.Provider, { value: {
            environment: environment,
            setEnvironment: setEnvironment,
            connection: connection,
            secondaryConnection: secondaryConnection,
        } }, children));
}
function useEnvironmentCtx() {
    var context = useContext(EnvironmentContext);
    if (!context) {
        throw new Error('Missing connection context');
    }
    return context;
}

var CLOCK_DRIFT_WARNING_THRESHOLD_SECONDS = 60 * 5;
var UTCNowContext = React.createContext({
    UTCNow: Math.floor(Date.now() / 1000),
    clockDrift: 0,
});
var getSolanaClock = function (connection) { return __awaiter(void 0, void 0, void 0, function () {
    var epochInfo, blockTimeInEpoch;
    return __generator(this, function (_a) {
        switch (_a.label) {
            case 0: return [4 /*yield*/, connection.getEpochInfo()];
            case 1:
                epochInfo = _a.sent();
                return [4 /*yield*/, connection.getBlockTime(epochInfo.absoluteSlot)];
            case 2:
                blockTimeInEpoch = _a.sent();
                return [2 /*return*/, blockTimeInEpoch];
        }
    });
}); };
function UTCNowProvider(_a) {
    var _this = this;
    var children = _a.children;
    var _b = useEnvironmentCtx(), secondaryConnection = _b.secondaryConnection, environment = _b.environment;
    var _c = useState(Date.now() / 1000), UTCNow = _c[0], setUTCNow = _c[1];
    var _d = useState(undefined), clockDrift = _d[0], setClockDrift = _d[1];
    useEffect(function () {
        var interval = setInterval((function fetchInterval() {
            setUTCNow(function (oldUTCNow) { return oldUTCNow + 1; });
            return fetchInterval;
        })(), 1000);
        return function () { return clearInterval(interval); };
    }, []);
    useMemo(function () { return __awaiter(_this, void 0, void 0, function () {
        var solanaClock;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    _a.trys.push([0, 2, , 3]);
                    return [4 /*yield*/, getSolanaClock(secondaryConnection)];
                case 1:
                    solanaClock = _a.sent();
                    if (solanaClock &&
                        Math.abs(Date.now() / 1000 - solanaClock) >
                            CLOCK_DRIFT_WARNING_THRESHOLD_SECONDS) {
                        setClockDrift(Date.now() / 1000 - solanaClock);
                        setUTCNow(solanaClock);
                    }
                    return [3 /*break*/, 3];
                case 2:
                    _a.sent();
                    return [3 /*break*/, 3];
                case 3: return [2 /*return*/];
            }
        });
    }); }, [environment]);
    return (React.createElement(UTCNowContext.Provider, { value: {
            UTCNow: UTCNow,
            clockDrift: clockDrift,
        } }, children));
}
function useUTCNow() {
    var context = useContext(UTCNowContext);
    return context;
}

export { ENVIRONMENTS, EnvironmentProvider, UTCNowProvider, allowedTokensForPool, getInitialProps, getStakeEntryDatas, getStakePoolsByAuthority, useAllStakeEntries, useAllStakePools, useAllowedTokenDatas, useEnvironmentCtx, useRecentSignatures, useRewardDistributorData, useRewardDistributorTokenAccount, useRewardEntries, useRewardMintInfo, useRewards, useStakeAuthorizationsForPool, useStakePoolData, useStakePoolEntries, useStakePoolId, useStakePoolMaxStaked, useStakePoolMetadata, useStakePoolsByAuthority, useStakedTokenDatas, useTokenList, useUTCNow, useUserTokenDatas, useWalletId, useWalletIds };