tek-wallet 0.0.813 → 0.0.822

package/dist/components/TekWallet/hooks/data/useNfts/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_query_1 = require("@tanstack/react-query");
+var api_1 = require("./api");
+var useQueryKeyDependenceOnAccount_1 = __importDefault(require("../../store/useQueryKeys/useQueryKeyDependenceOnAccount"));
+var type_1 = require("../../store/useQueryKeys/type");
+var react_1 = require("react");
+var LIMIT = 20;
+function useNfts(enabled) {
+    if (enabled === void 0) { enabled = true; }
+    var _a = (0, useQueryKeyDependenceOnAccount_1.default)(type_1.QueryKeyNames.NFTs), queryKeyAccount = _a.queryKey, isReadyAccount = _a.isReady;
+    var _b = (0, react_query_1.useInfiniteQuery)({
+        queryKey: queryKeyAccount,
+        queryFn: function (_a) {
+            var pageParam = _a.pageParam;
+            return (0, api_1.getNftsServices)({ limit: LIMIT, cursor: pageParam });
+        },
+        getNextPageParam: function (lastPage) {
+            var _a;
+            return (_a = lastPage === null || lastPage === void 0 ? void 0 : lastPage.paginated) === null || _a === void 0 ? void 0 : _a.cursor;
+        },
+        initialPageParam: undefined,
+        enabled: enabled && isReadyAccount,
+    }), data = _b.data, rest = __rest(_b, ["data"]);
+    var nfts = (0, react_1.useMemo)(function () {
+        return (data === null || data === void 0 ? void 0 : data.pages.flatMap(function (page) { var _a; return (_a = page === null || page === void 0 ? void 0 : page.data) === null || _a === void 0 ? void 0 : _a.nfts; })) || [];
+    }, [data]);
+    return __assign({ nfts: nfts }, rest);
+}
+exports.default = useNfts;

package/dist/components/TekWallet/hooks/data/useNfts/nftQueryKey.d.ts

@@ -0,0 +1,5 @@
+import { NftListParams } from "./state.type";
+export declare const NftQueryKey: {
+    all: readonly ["nfts"];
+    list: (params: NftListParams) => readonly ["nfts", string | undefined, string | undefined];
+};

package/dist/components/TekWallet/hooks/data/useNfts/nftQueryKey.js

@@ -0,0 +1,18 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftQueryKey = void 0;
+exports.NftQueryKey = {
+    all: ["nfts"],
+    list: function (params) {
+        return __spreadArray(__spreadArray([], exports.NftQueryKey.all, true), [params === null || params === void 0 ? void 0 : params.search, params === null || params === void 0 ? void 0 : params.accessToken], false);
+    },
+};

package/dist/components/TekWallet/hooks/data/useNfts/service.type.d.ts

@@ -0,0 +1,84 @@
+import { Cursor } from "../../../services/axios/type";
+import { NetworkData } from "../../../services/axios/expose";
+export interface GetNftsServiceQuery {
+    cursor?: string;
+    limit?: number;
+    keyword?: string;
+}
+export interface GetNftsServiceResponse {
+    success: boolean;
+    message: string;
+    data: NftData;
+    timestamp: string;
+}
+export interface NftData {
+    nfts: Nft[];
+    paginated: Cursor;
+}
+export declare enum NftStatus {
+    MINTED = "minted",
+    UNMINTED = "unminted",
+    MINTING = "minting",
+    SENDING = "sending"
+}
+export interface Nft {
+    animation_url: null;
+    external_app_url: null;
+    id: string;
+    image_url: string;
+    is_unique: boolean;
+    media_type: null;
+    media_url: string;
+    metadata: Metadata;
+    owner: Owner;
+    thumbnails: null;
+    token: Token;
+    token_type: string;
+    value: string;
+    status: NftStatus;
+    network: NetworkData;
+}
+export interface Token {
+    address_hash: string;
+    circulating_market_cap: null;
+    decimals: null;
+    exchange_rate: null;
+    holders_count: string;
+    icon_url: null;
+    name: string;
+    symbol: string;
+    total_supply: string;
+    type: string;
+    volume_24h: null;
+}
+export interface Owner {
+    ens_domain_name: null;
+    hash: string;
+    implementations: any[];
+    is_contract: boolean;
+    is_scam: boolean;
+    is_verified: boolean;
+    metadata: null;
+    name: null;
+    private_tags: any[];
+    proxy_type: null;
+    public_tags: any[];
+    watchlist_names: any[];
+}
+export interface Metadata {
+    attributes: Attribute[];
+    image: string;
+}
+export interface Attribute {
+    trait_type: string;
+    value?: string;
+}
+export interface NftActionPayload {
+    id: string;
+}
+export interface MintNfsPayload extends NftActionPayload {
+}
+export interface SendNftPayload extends NftActionPayload {
+    to_address: string;
+    passcode: string;
+}

package/dist/components/TekWallet/hooks/data/useNfts/service.type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftStatus = void 0;
+var NftStatus;
+(function (NftStatus) {
+    NftStatus["MINTED"] = "minted";
+    NftStatus["UNMINTED"] = "unminted";
+    NftStatus["MINTING"] = "minting";
+    NftStatus["SENDING"] = "sending";
+})(NftStatus || (exports.NftStatus = NftStatus = {}));

package/dist/components/TekWallet/hooks/data/useNfts/state.type.d.ts

@@ -0,0 +1,4 @@
+export interface NftListParams {
+    search?: string;
+    accessToken?: string;
+}

package/dist/components/TekWallet/hooks/data/useNfts/state.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/components/TekWallet/hooks/data/useNfts/useNft.d.ts

@@ -0,0 +1,22 @@
+import { Nft, GetNftsServiceResponse, SendNftPayload } from "./service.type";
+import { ReactEventHandler } from "react";
+import { Voucher } from "../useVouchers/service.type";
+import { InfiniteData } from "@tanstack/react-query";
+import { Transaction } from "../../../services/axios/get-activities-service/type";
+type MintNftContext = {
+    previousData?: InfiniteData<GetNftsServiceResponse>;
+};
+declare function useNft(id?: string, useSnapshot?: boolean): {
+    metadataAttributes: Voucher | null;
+    mintNft: import("@tanstack/react-query").UseMutationResult<Nft, Error, void, MintNftContext>;
+    sendNft: import("@tanstack/react-query").UseMutationResult<Transaction, Error, SendNftPayload, MintNftContext>;
+    voucherUnit: string;
+    voucherValue: number | undefined;
+    isMinting: boolean;
+    isMinted: boolean;
+    isSending: boolean;
+    handleClickButton: ReactEventHandler;
+    buttonLabel: string;
+    network: import("../../../services/axios/type").NetworkData | undefined;
+};
+export default useNft;

package/dist/components/TekWallet/hooks/data/useNfts/useNft.js

@@ -0,0 +1,213 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var useQueryKeys_1 = __importDefault(require("../../store/useQueryKeys"));
+var type_1 = require("../../store/useQueryKeys/type");
+var service_type_1 = require("./service.type");
+var react_1 = require("react");
+var service_type_2 = require("../useVouchers/service.type");
+var react_query_1 = require("@tanstack/react-query");
+var api_1 = require("./api");
+var useEditPageQuery_1 = __importDefault(require("../../utils/useEditPageQuery"));
+var useRealtime_1 = __importDefault(require("../../useRealtime"));
+var useCustomRouter_1 = __importDefault(require("../../useCustomRouter"));
+var providers_1 = require("../../../providers");
+var _1 = __importDefault(require("."));
+function useNft(id, useSnapshot) {
+    var _this = this;
+    if (useSnapshot === void 0) { useSnapshot = false; }
+    var queryKey = (0, useQueryKeys_1.default)(function (state) { return state.getQueryKey(type_1.QueryKeyNames.NFTs); });
+    var options = (0, providers_1.useWalletSetup)().options;
+    var snapshotNft = (0, react_1.useRef)(undefined);
+    var basePath = options === null || options === void 0 ? void 0 : options.basePath;
+    var editPageQuery = (0, useEditPageQuery_1.default)().editPageQuery;
+    var queryClient = (0, react_query_1.useQueryClient)();
+    var pushNotification = (0, useRealtime_1.default)().pushNotification;
+    var router = (0, useCustomRouter_1.default)();
+    var nfts = (0, _1.default)().nfts;
+    var nft = (0, react_1.useMemo)(function () {
+        var matchedNft = nfts === null || nfts === void 0 ? void 0 : nfts.find(function (item) { return (item === null || item === void 0 ? void 0 : item.id) === id; });
+        if (useSnapshot && matchedNft) {
+            snapshotNft.current = matchedNft;
+        }
+        return useSnapshot ? snapshotNft.current : matchedNft;
+    }, [id, nfts, useSnapshot]);
+    var metadata = (nft || {}).metadata;
+    var metadataAttributes = (0, react_1.useMemo)(function () {
+        if (!metadata)
+            return null;
+        var attributes = metadata.attributes;
+        var result = attributes.reduce(function (acc, attribute) {
+            acc[attribute.trait_type] = attribute.value;
+            return acc;
+        }, {});
+        return result; // in this phase we use nft metadata for voucher data
+    }, [metadata]);
+    var mintNft = (0, react_query_1.useMutation)({
+        mutationFn: function () { return (0, api_1.mintNftServices)({ id: nft === null || nft === void 0 ? void 0 : nft.id }); },
+        onMutate: function () { return __awaiter(_this, void 0, void 0, function () {
+            var previousData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, editPageQuery(queryKey, function (page) {
+                            var _a, _b;
+                            return __assign(__assign({}, page), { data: __assign(__assign({}, page === null || page === void 0 ? void 0 : page.data), { nfts: (_b = (_a = page === null || page === void 0 ? void 0 : page.data) === null || _a === void 0 ? void 0 : _a.nfts) === null || _b === void 0 ? void 0 : _b.map(function (item) {
+                                        return item.id === (nft === null || nft === void 0 ? void 0 : nft.id) ? __assign(__assign({}, item), { status: service_type_1.NftStatus.MINTING }) : item;
+                                    }) }) });
+                        })];
+                    case 1:
+                        previousData = (_a.sent()).previousData;
+                        return [2 /*return*/, { previousData: previousData }];
+                }
+            });
+        }); },
+        onSuccess: function (newNft) {
+            pushNotification({
+                id: "nft-minted-".concat(newNft.id),
+                message: "Claiming voucher successfully",
+                type: "success",
+            });
+            editPageQuery(queryKey, function (page) {
+                var _a, _b;
+                return __assign(__assign({}, page), { data: __assign(__assign({}, page === null || page === void 0 ? void 0 : page.data), { nfts: (_b = (_a = page === null || page === void 0 ? void 0 : page.data) === null || _a === void 0 ? void 0 : _a.nfts) === null || _b === void 0 ? void 0 : _b.map(function (item) { return (item.id === (nft === null || nft === void 0 ? void 0 : nft.id) ? newNft : item); }) }) });
+            });
+        },
+        onError: function (_, __, context) {
+            pushNotification({
+                id: "nft-minted-".concat(nft === null || nft === void 0 ? void 0 : nft.id),
+                message: "Claiming voucher failed",
+                type: "error",
+            });
+            if (context === null || context === void 0 ? void 0 : context.previousData) {
+                queryClient.setQueryData(queryKey, context.previousData);
+            }
+        },
+    });
+    var sendNft = (0, react_query_1.useMutation)({
+        mutationFn: function (payload) { return (0, api_1.sendNftServices)(payload); },
+        onMutate: function () { return __awaiter(_this, void 0, void 0, function () {
+            var previousData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, editPageQuery(queryKey, function (page) {
+                            var _a, _b;
+                            return __assign(__assign({}, page), { data: __assign(__assign({}, page === null || page === void 0 ? void 0 : page.data), { nfts: (_b = (_a = page === null || page === void 0 ? void 0 : page.data) === null || _a === void 0 ? void 0 : _a.nfts) === null || _b === void 0 ? void 0 : _b.map(function (item) {
+                                        return item.id === (nft === null || nft === void 0 ? void 0 : nft.id) ? __assign(__assign({}, item), { status: service_type_1.NftStatus.SENDING }) : item;
+                                    }) }) });
+                        })];
+                    case 1:
+                        previousData = (_a.sent()).previousData;
+                        return [2 /*return*/, { previousData: previousData }];
+                }
+            });
+        }); },
+        onSuccess: function (transaction, variables) {
+            editPageQuery(queryKey, function (page) {
+                var _a, _b;
+                return __assign(__assign({}, page), { data: __assign(__assign({}, page === null || page === void 0 ? void 0 : page.data), { nfts: (_b = (_a = page === null || page === void 0 ? void 0 : page.data) === null || _a === void 0 ? void 0 : _a.nfts) === null || _b === void 0 ? void 0 : _b.filter(function (item) { return item.id !== (variables === null || variables === void 0 ? void 0 : variables.id); }) }) });
+            });
+        },
+        onError: function (_, __, context) {
+            pushNotification({
+                id: "nft-sent-".concat(nft === null || nft === void 0 ? void 0 : nft.id),
+                message: "Sending NFT failed",
+                type: "error",
+            });
+            if (context === null || context === void 0 ? void 0 : context.previousData) {
+                queryClient.setQueryData(queryKey, context.previousData);
+            }
+        },
+    });
+    var voucherUnit = (metadataAttributes === null || metadataAttributes === void 0 ? void 0 : metadataAttributes.type) === service_type_2.VoucherType.PERCENT ? "%" : "";
+    var voucherValue = metadataAttributes === null || metadataAttributes === void 0 ? void 0 : metadataAttributes.amount;
+    var isMinting = (0, react_1.useMemo)(function () { return (nft === null || nft === void 0 ? void 0 : nft.status) === service_type_1.NftStatus.MINTING; }, [nft]);
+    var isSending = (0, react_1.useMemo)(function () { return (nft === null || nft === void 0 ? void 0 : nft.status) === service_type_1.NftStatus.SENDING; }, [nft]);
+    var isMinted = (0, react_1.useMemo)(function () { return (nft === null || nft === void 0 ? void 0 : nft.status) === service_type_1.NftStatus.MINTED; }, [nft]);
+    var network = (0, react_1.useMemo)(function () { return nft === null || nft === void 0 ? void 0 : nft.network; }, [nft]);
+    var buttonLabel = (0, react_1.useMemo)(function () {
+        switch (true) {
+            case isMinted:
+                return "Use";
+            case isMinting:
+                return "Claim"; // it is loading state, so we don't need to show the loading label as Claiming
+            case isSending:
+                return "Sending..."; // it is loading state, so we don't need to show the loading label as Sending
+            default:
+                return "Claim";
+        }
+    }, [isMinted, isMinting, isSending]);
+    var handleClickButton = (0, react_1.useCallback)(function (e) {
+        e.preventDefault();
+        e.stopPropagation();
+        if (isMinting || isSending)
+            return;
+        if (isMinted) {
+            router.push("".concat(basePath || "", "/tek-wallet/send/nft?id=").concat(nft === null || nft === void 0 ? void 0 : nft.id));
+            return;
+        }
+        mintNft.mutate();
+    }, [mintNft, isMinting, isSending, isMinted, router, nft === null || nft === void 0 ? void 0 : nft.id, basePath]);
+    return {
+        metadataAttributes: metadataAttributes,
+        mintNft: mintNft,
+        sendNft: sendNft,
+        voucherUnit: voucherUnit,
+        voucherValue: voucherValue,
+        isMinting: isMinting,
+        isMinted: isMinted,
+        isSending: isSending,
+        handleClickButton: handleClickButton,
+        buttonLabel: buttonLabel,
+        network: network,
+    };
+}
+exports.default = useNft;

package/dist/components/TekWallet/hooks/data/useVouchers/service.type.d.ts

@@ -0,0 +1,22 @@
+export declare enum VoucherType {
+    PERCENT = "percent",
+    FIXED = "fixed"
+}
+export declare enum VoucherStatus {
+    DRAFT = "draft",
+    PUBLISHED = "published",
+    ARCHIVED = "archived"
+}
+export interface Voucher {
+    id: number;
+    status: VoucherStatus;
+    title: string;
+    description: string;
+    image: string;
+    expire: string;
+    type: string;
+    amount: number;
+    tag: string;
+    date_created: string;
+    date_updated: string;
+}

package/dist/components/TekWallet/hooks/data/useVouchers/service.type.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoucherStatus = exports.VoucherType = void 0;
+var VoucherType;
+(function (VoucherType) {
+    VoucherType["PERCENT"] = "percent";
+    VoucherType["FIXED"] = "fixed";
+})(VoucherType || (exports.VoucherType = VoucherType = {}));
+var VoucherStatus;
+(function (VoucherStatus) {
+    VoucherStatus["DRAFT"] = "draft";
+    VoucherStatus["PUBLISHED"] = "published";
+    VoucherStatus["ARCHIVED"] = "archived";
+})(VoucherStatus || (exports.VoucherStatus = VoucherStatus = {}));

package/dist/components/TekWallet/hooks/store/useQueryKeys/index.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryKeysStore } from "./type";
+declare const useQueryKeysStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UseQueryKeysStore>>;
+export default useQueryKeysStore;

package/dist/components/TekWallet/hooks/store/useQueryKeys/index.js

@@ -0,0 +1,86 @@
+"use strict";
+"use client";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var zustand_1 = require("zustand");
+var type_1 = require("./type");
+var createInitialQueryKeys = function () {
+    return Object.values(type_1.QueryKeyNames).reduce(function (acc, queryKeyName) {
+        acc[queryKeyName] = (0, type_1.createQueryKeyRecord)(queryKeyName);
+        return acc;
+    }, {});
+};
+var ensureDefaultFields = function (map, name) {
+    type_1.DEFAULT_QUERY_KEY_FIELDS.forEach(function (field) {
+        if (field === "name") {
+            map.set(field, name);
+            return;
+        }
+        if (!map.has(field)) {
+            map.set(field, "");
+        }
+    });
+    return map;
+};
+var initialQueryKeys = createInitialQueryKeys();
+var useQueryKeysStore = (0, zustand_1.create)(function (set, get) { return ({
+    queryKeys: initialQueryKeys,
+    setQueryKey: function (queryKeyName, payload) {
+        set(function (state) {
+            var _a;
+            var _b;
+            var currentRecord = (_b = state.queryKeys[queryKeyName]) !== null && _b !== void 0 ? _b : (0, type_1.createQueryKeyRecord)(queryKeyName);
+            var workingMap = (0, type_1.cloneQueryKeyMap)(currentRecord.map);
+            var updatedMap = typeof payload === "function" ? payload(workingMap) : (0, type_1.cloneQueryKeyMap)(payload);
+            ensureDefaultFields(updatedMap, queryKeyName);
+            return {
+                queryKeys: __assign(__assign({}, state.queryKeys), (_a = {}, _a[queryKeyName] = {
+                    map: updatedMap,
+                    array: (0, type_1.mapToArray)(updatedMap),
+                }, _a)),
+            };
+        });
+    },
+    getQueryKey: function (queryKeyName) {
+        var _a;
+        var record = (_a = get().queryKeys[queryKeyName]) !== null && _a !== void 0 ? _a : (0, type_1.createQueryKeyRecord)(queryKeyName);
+        return record.array;
+    },
+    getQueryKeyMap: function (queryKeyName) {
+        var _a;
+        var record = (_a = get().queryKeys[queryKeyName]) !== null && _a !== void 0 ? _a : (0, type_1.createQueryKeyRecord)(queryKeyName);
+        return record.map;
+    },
+    setQueryFields: function (queryKeyName, fields) {
+        set(function (state) {
+            var _a;
+            var _b;
+            var currentRecord = (_b = state.queryKeys[queryKeyName]) !== null && _b !== void 0 ? _b : (0, type_1.createQueryKeyRecord)(queryKeyName);
+            var workingMap = (0, type_1.cloneQueryKeyMap)(currentRecord.map);
+            Object.entries(fields).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                if (key === "name")
+                    return;
+                workingMap.set(key, value);
+            });
+            ensureDefaultFields(workingMap, queryKeyName);
+            return {
+                queryKeys: __assign(__assign({}, state.queryKeys), (_a = {}, _a[queryKeyName] = {
+                    map: workingMap,
+                    array: (0, type_1.mapToArray)(workingMap),
+                }, _a)),
+            };
+        });
+    },
+}); });
+exports.default = useQueryKeysStore;

package/dist/components/TekWallet/hooks/store/useQueryKeys/type.d.ts

@@ -0,0 +1,27 @@
+export declare const QueryKeyNames: {
+    readonly NFTs: "nfts";
+};
+export type QueryKeyName = (typeof QueryKeyNames)[keyof typeof QueryKeyNames];
+export type DefaultQueryKeyFields = {
+    name: QueryKeyName;
+};
+export type QueryKeyMap = Map<string, unknown>;
+export type QueryKeyArray = unknown[];
+export type QueryKeyRecord = {
+    map: QueryKeyMap;
+    array: QueryKeyArray;
+};
+export type UpdateQueryKey = (prev: QueryKeyMap) => QueryKeyMap;
+export type QueryKeys = Record<QueryKeyName, QueryKeyRecord>;
+export interface UseQueryKeysStore {
+    queryKeys: QueryKeys;
+    setQueryKey: (queryKey: QueryKeyName, value: QueryKeyMap | UpdateQueryKey) => void;
+    getQueryKey: (queryKey: QueryKeyName) => QueryKeyArray;
+    getQueryKeyMap: (queryKey: QueryKeyName) => QueryKeyMap;
+    setQueryFields: (queryKey: QueryKeyName, fields: Record<string, unknown>) => void;
+}
+export declare const DEFAULT_QUERY_KEY_FIELDS: Array<keyof DefaultQueryKeyFields>;
+export declare const createQueryKeyMap: (name: QueryKeyName) => QueryKeyMap;
+export declare const cloneQueryKeyMap: (map: QueryKeyMap) => QueryKeyMap;
+export declare const mapToArray: (map: QueryKeyMap) => QueryKeyArray;
+export declare const createQueryKeyRecord: (name: QueryKeyName) => QueryKeyRecord;

package/dist/components/TekWallet/hooks/store/useQueryKeys/type.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueryKeyRecord = exports.mapToArray = exports.cloneQueryKeyMap = exports.createQueryKeyMap = exports.DEFAULT_QUERY_KEY_FIELDS = exports.QueryKeyNames = void 0;
+exports.QueryKeyNames = {
+    NFTs: "nfts",
+};
+exports.DEFAULT_QUERY_KEY_FIELDS = ["name"];
+var createQueryKeyMap = function (name) {
+    var map = new Map();
+    map.set("name", name);
+    return map;
+};
+exports.createQueryKeyMap = createQueryKeyMap;
+var cloneQueryKeyMap = function (map) {
+    return new Map(map);
+};
+exports.cloneQueryKeyMap = cloneQueryKeyMap;
+var mapToArray = function (map) {
+    return Array.from(map.entries());
+};
+exports.mapToArray = mapToArray;
+var createQueryKeyRecord = function (name) {
+    var map = (0, exports.createQueryKeyMap)(name);
+    return {
+        map: map,
+        array: (0, exports.mapToArray)(map),
+    };
+};
+exports.createQueryKeyRecord = createQueryKeyRecord;

package/dist/components/TekWallet/hooks/store/useQueryKeys/useQueryKeyDependence.d.ts

@@ -0,0 +1,11 @@
+import { QueryKeyName } from "./type";
+export interface QueryKeyDependence {
+    value: unknown;
+    requiredToReady?: boolean;
+    requiredTruthyValue?: boolean;
+}
+declare function useQueryKeyDependence(name: QueryKeyName, dependencies: Record<string, QueryKeyDependence>, enabledTracking?: boolean): {
+    queryKey: import("./type").QueryKeyArray;
+    isReady: boolean | undefined;
+};
+export default useQueryKeyDependence;

package/dist/components/TekWallet/hooks/store/useQueryKeys/useQueryKeyDependence.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+var _1 = __importDefault(require("./"));
+function useQueryKeyDependence(name, dependencies, enabledTracking) {
+    var queryKey = (0, _1.default)(function (state) { return state.getQueryKey(name); });
+    var queryKeyMap = (0, _1.default)(function (state) { return state.getQueryKeyMap(name); });
+    var setQueryFields = (0, _1.default)(function (state) { return state.setQueryFields; });
+    var isReady = (0, react_1.useMemo)(function () {
+        return (enabledTracking &&
+            Object.keys(dependencies).every(function (dependency) {
+                return (!dependencies[dependency].requiredToReady ||
+                    (!!dependencies[dependency].requiredToReady && queryKeyMap.has(dependency))) &&
+                    (!dependencies[dependency].requiredTruthyValue ||
+                        (!!dependencies[dependency].requiredTruthyValue && !!dependencies[dependency].value));
+            }));
+    }, [dependencies, queryKeyMap, enabledTracking]);
+    (0, react_1.useEffect)(function () {
+        if (!enabledTracking)
+            return;
+        var dependenciesObject = Object.keys(dependencies).reduce(function (acc, key) {
+            acc[key] = dependencies[key].value;
+            return acc;
+        }, {});
+        setQueryFields(name, dependenciesObject);
+    }, [dependencies, name, setQueryFields, enabledTracking]);
+    return {
+        queryKey: queryKey,
+        isReady: isReady,
+    };
+}
+exports.default = useQueryKeyDependence;