hive-react-kit 0.0.24 → 0.0.28

package/dist/main.d.ts

@@ -0,0 +1 @@
+import "./index.css";

package/dist/pages/Index.d.ts

@@ -0,0 +1,2 @@
+declare const Index: () => import("react/jsx-runtime").JSX.Element;
+export default Index;

package/dist/pages/NotFound.d.ts

@@ -0,0 +1,2 @@
+declare const NotFound: () => import("react/jsx-runtime").JSX.Element;
+export default NotFound;

package/dist/pages/UserProfile.d.ts

@@ -0,0 +1,2 @@
+declare const UserProfile: () => import("react/jsx-runtime").JSX.Element;
+export default UserProfile;

package/dist/services/activityListService.d.ts

@@ -0,0 +1,79 @@
+import { AccountHistoryItem, ActivityListItem, DirectionFilter, GeneralFilter, RewardFilter } from "@/types/activityList";
+declare class ActivityListService {
+    /**
+     * Get account history using condenser_api.get_account_history
+     * @param username - Hive username
+     * @param start - Starting operation index (-1 for most recent)
+     * @param limit - Number of operations to fetch
+     * @param operationFilterLow - Operation filter low (optional)
+     * @param operationFilterHigh - Operation filter high (optional)
+     * @returns Promise<AccountHistoryItem[]>
+     */
+    getAccountHistory(username: string, start?: number, limit?: number, operationFilterLow?: string, operationFilterHigh?: string): Promise<AccountHistoryItem[]>;
+    /**
+     * Get the next page of account history for pagination
+     * @param username - Hive username
+     * @param lastIndex - Last operation index from previous page
+     * @param limit - Number of operations to fetch
+     * @returns Promise<AccountHistoryItem[]>
+     */
+    getNextAccountHistoryPage(username: string, lastIndex: number, limit?: number): Promise<AccountHistoryItem[]>;
+    /**
+     * Convert account history items to activity list items
+     * @param historyItems - Raw account history items
+     * @param username - The account we're viewing history for
+     * @returns ActivityListItem[]
+     */
+    convertToActivityListItems(historyItems: AccountHistoryItem[], username: string): ActivityListItem[];
+    /**
+     * Parse individual operation and determine activity details
+     * @param historyItem - Account history item
+     * @param username - The account we're viewing history for
+     * @returns Parsed activity data
+     */
+    private parseOperation;
+    private parseVoteOperation;
+    private parseCommentOperation;
+    private parseCustomJsonOperation;
+    private parseCommentOptionsOperation;
+    private parseEffectiveCommentVoteOperation;
+    private parseCurationRewardOperation;
+    private parseAuthorRewardOperation;
+    private parseCommentBenefactorRewardOperation;
+    /**
+     * Filter activities by direction (in/out)
+     * @param activities - Activity list items
+     * @param filter - Direction filter
+     * @returns Filtered activities
+     */
+    filterByDirection(activities: ActivityListItem[], filter: DirectionFilter): ActivityListItem[];
+    /**
+     * Filter activities by general type
+     * @param activities - Activity list items
+     * @param filter - General filter
+     * @returns Filtered activities
+     */
+    filterByGeneralType(activities: ActivityListItem[], filter: GeneralFilter): ActivityListItem[];
+    /**
+     * Filter activities by reward type
+     * @param activities - Activity list items
+     * @param filter - Reward filter
+     * @returns Filtered activities
+     */
+    filterByRewardType(activities: ActivityListItem[], filter: RewardFilter): ActivityListItem[];
+    /**
+     * Search activities by text
+     * @param activities - Activity list items
+     * @param searchText - Search text
+     * @returns Filtered activities
+     */
+    searchActivities(activities: ActivityListItem[], searchText: string): ActivityListItem[];
+    /**
+     * Get relative time string
+     * @param timestamp - ISO timestamp
+     * @returns Relative time string
+     */
+    getRelativeTime(timestamp: string): string;
+}
+export declare const activityListService: ActivityListService;
+export {};

package/dist/services/activityService.d.ts

@@ -0,0 +1,104 @@
+import { ActivityHistoryItem, ActivityDisplayItem } from "@/types/activity";
+declare class ActivityService {
+    /**
+     * Get activity history for a user (posts, comments, replies)
+     * @param username - Hive username
+     * @param sortBy - Sort by "posts", "comments", or "replies" (default: "posts")
+     * @param limit - Maximum number of items to return (default: 20)
+     * @param startAuthor - Starting author for pagination (optional)
+     * @param startPermlink - Starting permlink for pagination (optional)
+     * @param observer - Observer username for personalized results (optional)
+     * @returns Promise<ActivityHistoryItem[]>
+     */
+    getActivityHistory(username: string, sortBy?: 'posts' | 'comments' | 'replies', limit?: number, startAuthor?: string | null, startPermlink?: string | null, observer?: string | null): Promise<ActivityHistoryItem[]>;
+    /**
+     * Get user's posts only
+     * @param username - Hive username
+     * @param limit - Maximum number of posts to return
+     * @returns Promise<ActivityHistoryItem[]>
+     */
+    getUserPosts(username: string, limit?: number): Promise<ActivityHistoryItem[]>;
+    /**
+     * Get user's comments only
+     * @param username - Hive username
+     * @param limit - Maximum number of comments to return
+     * @returns Promise<ActivityHistoryItem[]>
+     */
+    getUserComments(username: string, limit?: number): Promise<ActivityHistoryItem[]>;
+    /**
+     * Get user's replies only
+     * @param username - Hive username
+     * @param limit - Maximum number of replies to return
+     * @returns Promise<ActivityHistoryItem[]>
+     */
+    getUserReplies(username: string, limit?: number): Promise<ActivityHistoryItem[]>;
+    /**
+     * Get all user activity (posts, comments, and replies combined)
+     * @param username - Hive username
+     * @param limit - Maximum number of items per type
+     * @returns Promise<ActivityHistoryItem[]>
+     */
+    getAllUserActivity(username: string, limit?: number): Promise<ActivityHistoryItem[]>;
+    /**
+     * Convert raw activity item to display format
+     * @param item - Raw activity history item
+     * @returns ActivityDisplayItem
+     */
+    convertToDisplayItem(item: ActivityHistoryItem): ActivityDisplayItem;
+    /**
+     * Format activity timestamp to readable date
+     * @param timestamp - Activity timestamp
+     * @returns Formatted date string
+     */
+    formatTimestamp(timestamp: string): string;
+    /**
+     * Get relative time string (e.g., "2 hours ago")
+     * @param timestamp - Activity timestamp
+     * @returns Relative time string
+     */
+    getRelativeTime(timestamp: string): string;
+    /**
+     * Truncate text to specified length
+     * @param text - Text to truncate
+     * @param maxLength - Maximum length
+     * @returns Truncated text
+     */
+    truncateText(text: string, maxLength?: number): string;
+    /**
+     * Get activity summary statistics
+     * @param activities - Array of activities
+     * @returns Summary statistics
+     */
+    getActivitySummary(activities: ActivityHistoryItem[]): {
+        totalActivities: number;
+        postsCount: number;
+        commentsCount: number;
+        totalVotes: number;
+        totalPayout: string;
+        averageVotes: number;
+    };
+    /**
+     * Filter activities by category
+     * @param activities - Array of activities
+     * @param category - Category to filter by
+     * @returns Filtered activities
+     */
+    filterByCategory(activities: ActivityHistoryItem[], category: string): ActivityHistoryItem[];
+    /**
+     * Filter activities by date range
+     * @param activities - Array of activities
+     * @param startDate - Start date
+     * @param endDate - End date
+     * @returns Filtered activities
+     */
+    filterByDateRange(activities: ActivityHistoryItem[], startDate: Date, endDate: Date): ActivityHistoryItem[];
+    /**
+     * Search activities by text
+     * @param activities - Array of activities
+     * @param searchText - Text to search for
+     * @returns Filtered activities
+     */
+    searchActivities(activities: ActivityHistoryItem[], searchText: string): ActivityHistoryItem[];
+}
+export declare const activityService: ActivityService;
+export {};

package/dist/services/apiService.d.ts

@@ -0,0 +1,51 @@
+import { ThreeSpeakVideo, LoginModel, ActiveVote } from "@/types/video";
+import { TrendingTag } from "@/types/trending";
+import { Discussion } from "@/types/comment";
+import { Post, PostSort } from "@/types/post";
+declare const server: {
+    domain: string;
+    kThreeSpeakApiUrl: string;
+    userOwnerThumb: (username: string) => string;
+    graphQLServerUrl: string;
+};
+declare class ApiService {
+    private readonly commonFields;
+    private getGQLFeed;
+    handleLogin(result: LoginModel): Promise<Record<string, any>>;
+    handleUpvote({ author, permlink, weight, authToken, }: {
+        author: string;
+        permlink: string;
+        weight: number;
+        authToken: string;
+    }): Promise<Record<string, any>>;
+    handleComment({ author, permlink, body, authToken, }: {
+        author: string;
+        permlink: string;
+        body: string;
+        authToken: string;
+    }): Promise<Record<string, any>>;
+    getVideoDetails(username: string, permlink: string): Promise<ThreeSpeakVideo>;
+    private fetchFeed;
+    getUserVideos(username: string, skip?: number): Promise<ThreeSpeakVideo[]>;
+    getHomeVideos(skip?: number): Promise<ThreeSpeakVideo[]>;
+    getTrendingVideos(skip?: number): Promise<ThreeSpeakVideo[]>;
+    getNewVideos(skip?: number): Promise<ThreeSpeakVideo[]>;
+    getFirstUploadsVideos(skip?: number): Promise<ThreeSpeakVideo[]>;
+    getCommunityVideos(community: string, skip?: number): Promise<ThreeSpeakVideo[]>;
+    getRelatedVideos(username: string, skip?: number): Promise<ThreeSpeakVideo[]>;
+    getTaggedVideos(tag: string, skip?: number): Promise<ThreeSpeakVideo[]>;
+    getSearchFeed(term: string, skip?: number, lang?: string): Promise<ThreeSpeakVideo[]>;
+    getTrendingTags(): Promise<TrendingTag[]>;
+    private convertGQLItemsToThreeSpeakVideos;
+    getContentStats(author: string, permlink: string): Promise<{
+        numOfUpvotes: any;
+        numOfComments: any;
+        hiveValue: number;
+    }>;
+    getActiveVotes(author: string, permlink: string): Promise<ActiveVote[]>;
+    getCommentsList(author: string, permlink: string): Promise<Discussion[]>;
+    getMyVideos(authToken: string): Promise<ThreeSpeakVideo[]>;
+    getRankedPosts(sort?: PostSort, tag?: string, observer?: string, limit?: number, start_author?: string, start_permlink?: string): Promise<Post[]>;
+}
+export declare const apiService: ApiService;
+export { server };

package/dist/services/communityService.d.ts

@@ -0,0 +1,15 @@
+import { CommunityItem, CommunityDetailsResponse, CommunitySubscriber, CommunityActivity } from '../types/community';
+declare class CommunityService {
+    private readonly HIVE_API_URL;
+    getListOfCommunities(query?: string, limit?: number, last?: string): Promise<CommunityItem[]>;
+    getCommunityDetails(communityId: string): Promise<CommunityDetailsResponse>;
+    getCommunitySubscribers(communityId: string, limit?: number, last?: string): Promise<CommunitySubscriber[]>;
+    getCommunitySubscribersList(communityId: string, limit?: number, last?: string): Promise<CommunitySubscriber[]>;
+    getCommunityAccounts(communityId: string): Promise<any[]>;
+    getRankedPosts(communityId: string, sort?: string, limit?: number, startAuthor?: string, startPermlink?: string): Promise<any[]>;
+    communityIcon(value: string): string;
+    userOwnerThumb(value: string): string;
+    getCommunityActivities(account: string, limit?: number, lastId?: number): Promise<CommunityActivity[]>;
+}
+export declare const communityService: CommunityService;
+export {};

package/dist/services/proposalService.d.ts

@@ -0,0 +1,9 @@
+import { Proposal } from '../types/proposal';
+export declare class ProposalService {
+    private static instance;
+    static getInstance(): ProposalService;
+    getProposals(status: string): Promise<Proposal[]>;
+    private getActiveProposals;
+    private getExpiredProposals;
+}
+export declare const proposalService: ProposalService;

package/dist/services/transactionService.d.ts

@@ -0,0 +1,69 @@
+import { TransactionHistoryItem, Operation } from "@/types/transaction";
+declare class TransactionService {
+    /**
+     * Get transaction history for an account
+     * @param account - Hive account name
+     * @param index - Starting index (-1 for most recent)
+     * @param limit - Maximum number of transactions to return (default: 1000)
+     * @param start - Start block number (optional)
+     * @param stop - Stop block number (optional)
+     * @returns Promise<TransactionHistoryItem[]>
+     */
+    getTransactionHistory(account: string, index?: number, limit?: number, start?: number | null, stop?: number | null): Promise<TransactionHistoryItem[]>;
+    /**
+     * Get filtered transaction history by operation type
+     * @param account - Hive account name
+     * @param operationTypes - Array of operation types to filter by
+     * @param limit - Maximum number of transactions to return
+     * @returns Promise<TransactionHistoryItem[]>
+     */
+    getFilteredTransactionHistory(account: string, operationTypes?: string[], limit?: number): Promise<TransactionHistoryItem[]>;
+    /**
+     * Get recent transfers for an account
+     * @param account - Hive account name
+     * @param limit - Maximum number of transfers to return
+     * @returns Promise<TransactionHistoryItem[]>
+     */
+    getRecentTransfers(account: string, limit?: number): Promise<TransactionHistoryItem[]>;
+    /**
+     * Get recent votes for an account
+     * @param account - Hive account name
+     * @param limit - Maximum number of votes to return
+     * @returns Promise<TransactionHistoryItem[]>
+     */
+    getRecentVotes(account: string, limit?: number): Promise<TransactionHistoryItem[]>;
+    /**
+     * Get recent comments/posts for an account
+     * @param account - Hive account name
+     * @param limit - Maximum number of comments to return
+     * @returns Promise<TransactionHistoryItem[]>
+     */
+    getRecentComments(account: string, limit?: number): Promise<TransactionHistoryItem[]>;
+    /**
+     * Parse operation data from transaction
+     * @param transaction - Transaction history item
+     * @returns Parsed operation or null
+     */
+    parseOperation(transaction: TransactionHistoryItem): Operation | null;
+    /**
+     * Format transaction timestamp to readable date
+     * @param timestamp - Transaction timestamp
+     * @returns Formatted date string
+     */
+    formatTimestamp(timestamp: string): string;
+    /**
+     * Get transaction summary statistics
+     * @param transactions - Array of transactions
+     * @returns Summary statistics
+     */
+    getTransactionSummary(transactions: TransactionHistoryItem[]): {
+        totalTransactions: number;
+        operationCounts: Record<string, number>;
+        dateRange: {
+            earliest: string;
+            latest: string;
+        };
+    };
+}
+export declare const transactionService: TransactionService;
+export {};

package/dist/services/userService.d.ts

@@ -0,0 +1,15 @@
+import { Follower, Following, UserProfileResponse, Account } from "@/types/user";
+declare class UserService {
+    private readonly HIVE_API_URL;
+    getProfile(username: string): Promise<UserProfileResponse>;
+    getFollowers(username: string): Promise<Follower[]>;
+    getFollowing(username: string): Promise<Following[]>;
+    getAccounts(usernames: string[]): Promise<Account[]>;
+    getDynamicGlobalProperties(): Promise<any>;
+    convertVestingSharesToHive(vestingShares: string): Promise<string>;
+    getFeedHistory(): Promise<any>;
+    getVoteValue(username: string, weight?: number): Promise<string>;
+    userAvatar(username: string): string;
+}
+export declare const userService: UserService;
+export {};

package/dist/services/witnessService.d.ts

@@ -0,0 +1,61 @@
+import { Witness, WitnessVotesResponse, Account, WitnessVote } from "../types/witness";
+declare class WitnessService {
+    /**
+     * Get witnesses by vote with pagination
+     */
+    getWitnessesByVote(start?: string, limit?: number): Promise<Witness[]>;
+    /**
+     * Get account details including witness votes
+     */
+    getAccount(username: string): Promise<Account | null>;
+    /**
+     * Get multiple accounts at once
+     */
+    getAccounts(usernames: string[]): Promise<Account[]>;
+    /**
+     * Get witness votes for a specific witness
+     */
+    getWitnessVotes(witness: string, start?: string, limit?: number): Promise<WitnessVotesResponse>;
+    /**
+     * Get all witness votes for a witness with pagination
+     */
+    getAllWitnessVotes(witness: string): Promise<WitnessVote[]>;
+    /**
+     * Check if a user has voted for a witness
+     */
+    hasUserVotedForWitness(username: string, witness: string): Promise<boolean>;
+    /**
+     * Get user's witness votes
+     */
+    getUserWitnessVotes(username: string): Promise<string[]>;
+    /**
+     * Format votes to millions (MHP)
+     */
+    formatVotesToMHP(votes: string): string;
+    /**
+     * Calculate APR from hbd_interest_rate
+     */
+    calculateAPR(hbdInterestRate: number): number;
+    /**
+     * Get version status color based on running_version vs hardfork_version_vote
+     */
+    getVersionStatus(runningVersion: string, hardforkVersion: string): 'green' | 'red' | 'grey';
+    /**
+     * Parse version string to comparable format
+     */
+    private parseVersion;
+    /**
+     * Compare two version arrays
+     */
+    private compareVersions;
+    /**
+     * Get witness description from account metadata
+     */
+    getWitnessDescription(account: Account): string;
+    /**
+     * Format time ago
+     */
+    formatTimeAgo(dateString: string): string;
+}
+export declare const witnessService: WitnessService;
+export {};

package/dist/store/index.d.ts

@@ -0,0 +1,2 @@
+export { useWalletStore } from './walletStore';
+export { useWitnessStore } from './witnessStore';

package/dist/store/walletStore.d.ts

@@ -0,0 +1,2 @@
+import type { WalletStore } from "../types/wallet";
+export declare const useWalletStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WalletStore>>;

package/dist/store/witnessStore.d.ts

@@ -0,0 +1,31 @@
+import { Witness, WitnessFilters, WitnessVote, Account } from '../types/witness';
+interface WitnessState {
+    witnesses: Witness[];
+    witnessVotes: WitnessVote[];
+    userWitnessVotes: string[];
+    witnessDetails: Map<string, string>;
+    witnessAccounts: Map<string, Account>;
+    loadingWitnesses: boolean;
+    loadingMoreWitnesses: boolean;
+    loadingVotes: boolean;
+    loadingMoreVotes: boolean;
+    loadingUserVotes: boolean;
+    error: string | null;
+    nextWitnessStart: string;
+    nextVotesStart: string;
+    hasMoreWitnesses: boolean;
+    hasMoreVotes: boolean;
+    selectedWitness: string | null;
+    filters: WitnessFilters;
+    loadWitnesses: (start?: string, limit?: number) => Promise<void>;
+    loadMoreWitnesses: () => Promise<void>;
+    loadWitnessVotes: (witness: string) => Promise<void>;
+    loadMoreVotes: () => Promise<void>;
+    loadUserWitnessVotes: (username?: string) => Promise<void>;
+    loadWitnessDetails: (owners: string[]) => Promise<void>;
+    setFilters: (filters: WitnessFilters) => void;
+    setSelectedWitness: (witness: string | null) => void;
+    clearVotes: () => void;
+}
+export declare const useWitnessStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WitnessState>>;
+export {};

package/dist/types/activity.d.ts

@@ -0,0 +1,108 @@
+export interface ActivityHistoryItem {
+    id: number;
+    author: string;
+    permlink: string;
+    category: string;
+    parent_author: string;
+    parent_permlink: string;
+    title: string;
+    body: string;
+    json_metadata: string;
+    last_update: string;
+    created: string;
+    active: string;
+    last_payout: string;
+    depth: number;
+    children: number;
+    net_rshares: number;
+    abs_rshares: number;
+    vote_rshares: number;
+    children_abs_rshares: number;
+    cashout_time: string;
+    max_cashout_time: string;
+    total_vote_weight: number;
+    reward_weight: number;
+    total_payout_value: string;
+    curator_payout_value: string;
+    author_rewards: number;
+    net_votes: number;
+    root_author: string;
+    root_permlink: string;
+    max_accepted_payout: string;
+    percent_hbd: number;
+    allow_replies: boolean;
+    allow_votes: boolean;
+    allow_curation_rewards: boolean;
+    beneficiaries: any[];
+    url: string;
+    root_title: string;
+    pending_payout_value: string;
+    total_pending_payout_value: string;
+    active_votes: any[];
+    replies: string[];
+    author_reputation: number;
+    promoted: string;
+    body_length: number;
+    reblogged_by: string[];
+    active_votes_count: number;
+    author_title: string;
+    author_role: string;
+    author_about: string;
+    author_location: string;
+    author_website: string;
+    author_cover_image: string;
+    author_profile_image: string;
+    author_blacklist_description: string;
+    author_muted_list_description: string;
+    author_reputation_formatted: string;
+    author_vests_formatted: string;
+    author_balance_formatted: string;
+    author_hbd_balance_formatted: string;
+    author_savings_hbd_balance_formatted: string;
+    author_savings_balance_formatted: string;
+    author_vesting_shares_formatted: string;
+    author_delegated_vesting_shares_formatted: string;
+    author_received_vesting_shares_formatted: string;
+    author_vesting_withdraw_rate_formatted: string;
+    author_next_vesting_withdrawal_formatted: string;
+    author_vesting_withdraw_rate: number;
+    author_next_vesting_withdrawal: string;
+    author_vesting_shares: string;
+    author_delegated_vesting_shares: string;
+    author_received_vesting_shares: string;
+    author_balance: string;
+    author_hbd_balance: string;
+    author_savings_hbd_balance: string;
+    author_savings_balance: string;
+    author_post_count: number;
+    author_voting_power: number;
+    author_voting_manabar: any;
+    author_downvote_manabar: any;
+    author_rc_manabar: any;
+}
+export interface ActivityHistoryParams {
+    username: string;
+    sortBy?: 'posts' | 'comments' | 'replies';
+    limit?: number;
+    startAuthor?: string;
+    startPermlink?: string;
+    observer?: string;
+}
+export interface ActivityHistoryResponse {
+    result: ActivityHistoryItem[];
+}
+export interface ActivityDisplayItem {
+    id: number;
+    author: string;
+    permlink: string;
+    title: string;
+    body: string;
+    created: string;
+    category: string;
+    net_votes: number;
+    children: number;
+    total_payout_value: string;
+    pending_payout_value: string;
+    url: string;
+    type: 'post' | 'comment';
+}

package/dist/types/activityList.d.ts

@@ -0,0 +1,46 @@
+export interface AccountHistoryOperation {
+    type: string;
+    value: any;
+}
+export interface AccountHistoryItem {
+    index: number;
+    timestamp: string;
+    block: number;
+    trx_in_block: number;
+    op_in_trx: number;
+    virtual_op: boolean;
+    trx_id: string;
+    op: AccountHistoryOperation;
+}
+export interface AccountHistoryResponse {
+    id: number;
+    jsonrpc: string;
+    result: AccountHistoryItem[];
+}
+export interface ActivityListItem {
+    id: string;
+    type: 'vote' | 'comment' | 'custom_json' | 'comment_options' | 'effective_comment_vote' | 'curation_reward' | 'author_reward' | 'comment_benefactor_reward' | 'other';
+    direction: 'in' | 'out';
+    timestamp: string;
+    block: number;
+    description: string;
+    details: any;
+    index: number;
+    author?: string;
+    permlink?: string;
+    voter?: string;
+    weight?: number;
+    payout?: string;
+    community?: string;
+    curator?: string;
+    reward?: string;
+    hbd_payout?: string;
+    hive_payout?: string;
+    vesting_payout?: string;
+    benefactor?: string;
+    parent_author?: string;
+    parent_permlink?: string;
+}
+export type DirectionFilter = 'all' | 'in' | 'out';
+export type GeneralFilter = 'all' | 'votes' | 'comments' | 'replies' | 'curation' | 'others';
+export type RewardFilter = 'all' | 'author' | 'curation' | 'benefactor';

package/dist/types/comment.d.ts

@@ -0,0 +1,19 @@
+export interface Discussion {
+    active_votes: any[];
+    author: string;
+    permlink: string;
+    parent_author?: string;
+    parent_permlink?: string;
+    title?: string;
+    body?: string;
+    created?: string;
+    depth?: number;
+    children?: number;
+    net_votes?: number;
+    stats?: {
+        total_votes: number;
+    };
+    json_metadata?: string;
+    json_metadata_parsed?: any;
+    replies?: string[] | Discussion[];
+}