player-map 1.0.7 → 1.0.8

package/dist/types/components/modals/ConnectWalletModal.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+
+interface ConnectWalletModalProps {
+    isOpen: boolean;
+    onConnectWallet: () => void;
+}
+export declare const ConnectWalletModal: React.FC<ConnectWalletModalProps>;
+export {};

package/dist/types/components/modals/CreatePlayerModal.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface CreatePlayerModalProps {
+    isOpen: boolean;
+    onCreatePlayer: () => void;
+    onClose?: () => void;
+}
+export declare const CreatePlayerModal: React.FC<CreatePlayerModalProps>;
+export {};

package/dist/types/components/modals/index.d.ts

@@ -0,0 +1,2 @@
+export { ConnectWalletModal } from './ConnectWalletModal';
+export { CreatePlayerModal } from './CreatePlayerModal';

package/dist/types/components/vote/ClaimItem.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { VoteItem, VoteDirection } from '../../types/vote';
+import { Network } from '../../hooks/useAtomData';
+
+interface ClaimItemProps {
+    voteItem: VoteItem;
+    onChangeUnits: (id: bigint, direction: VoteDirection, units: number) => void;
+    isVoteDirectionAllowed?: (tripleId: bigint, direction: VoteDirection) => boolean;
+    walletAddress?: string;
+    network?: Network;
+}
+export declare const ClaimItem: React.FC<ClaimItemProps>;
+export {};

package/dist/types/components/vote/ClaimList.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { VoteItem, VoteDirection } from '../../types/vote';
+import { Network } from '../../hooks/useAtomData';
+
+interface ClaimListProps {
+    isLoading: boolean;
+    voteItems: VoteItem[];
+    onChangeUnits: (id: bigint, direction: VoteDirection, units: number) => void;
+    isVoteDirectionAllowed?: (tripleId: bigint, direction: VoteDirection) => boolean;
+    walletAddress?: string;
+    network?: Network;
+}
+export declare const ClaimList: React.FC<ClaimListProps>;
+export {};

package/dist/types/components/vote/ClaimVoting.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { Network } from '../../hooks/useAtomData';
+
+interface ClaimVotingProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    onClose?: () => void;
+    network?: Network;
+    onConnectWallet?: () => void;
+    onCreatePlayer?: () => void;
+    wagmiConfig?: any;
+    walletHooks?: any;
+}
+export declare const ClaimVoting: React.FC<ClaimVotingProps>;
+export {};

package/dist/types/components/vote/SubmitButton.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+
+interface SubmitButtonProps {
+    onSubmit: () => void;
+    isSubmitting: boolean;
+    isDepositLoading: boolean;
+    totalUnits: number;
+    numberOfTransactions: number;
+}
+export declare const SubmitButton: React.FC<SubmitButtonProps>;
+export {};

package/dist/types/components/vote/TransactionInfo.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface TransactionInfoProps {
+    numberOfTransactions: number;
+    totalUnits: number;
+    onResetAll: () => void;
+}
+export declare const TransactionInfo: React.FC<TransactionInfoProps>;
+export {};

package/dist/types/components/vote/TransactionStatus.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+
+type TransactionStatusType = {
+    status: "idle" | "pending" | "success" | "error" | "approval_pending" | "whitelist_error";
+    message: string;
+};
+interface TransactionStatusDisplayProps {
+    transactionStatus: TransactionStatusType;
+}
+export declare const TransactionStatusDisplay: React.FC<TransactionStatusDisplayProps>;
+export {};

package/dist/types/components/vote/VotingHeader.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+
+interface VotingHeaderProps {
+    onClose?: () => void;
+}
+export declare const VotingHeader: React.FC<VotingHeaderProps>;
+export {};

package/dist/types/hooks/useCheckSpecificTriplePosition.d.ts

@@ -0,0 +1,14 @@
+import { Network } from './useAtomData';
+
+interface UseCheckSpecificTriplePositionProps {
+    walletAddress: string;
+    tripleId: string | number;
+    network?: Network;
+}
+export declare const useCheckSpecificTriplePosition: ({ walletAddress, tripleId, network }: UseCheckSpecificTriplePositionProps) => {
+    hasPosition: boolean;
+    isFor: boolean | null;
+    loading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/types/hooks/useDepositTriple.d.ts

@@ -0,0 +1,14 @@
+import { VoteDirection, DepositResponse } from '../types/vote';
+import { Network } from './useAtomData';
+
+interface UseDepositTripleProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+}
+export declare const useDepositTriple: ({ walletConnected, walletAddress, publicClient, network, }: UseDepositTripleProps) => {
+    depositTriple: (claimId: bigint, units: number, direction: VoteDirection) => Promise<DepositResponse>;
+    isLoading: boolean;
+};
+export {};

package/dist/types/hooks/useDisplayTriplesWithPosition.d.ts

@@ -0,0 +1,5 @@
+export declare const useDisplayTriplesWithPosition: (walletAddress: string) => {
+    data: any;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/types/hooks/useFetchTripleDetails.d.ts

@@ -0,0 +1,27 @@
+import { Network } from './useAtomData';
+
+export interface TripleDetails {
+    id: string;
+    subject?: {
+        label: string;
+    };
+    predicate?: {
+        label: string;
+    };
+    object?: {
+        label: string;
+    };
+    vault_id?: string;
+    vault_position_count?: number;
+    counter_vault_id?: string;
+    counter_vault_position_count?: number;
+}
+interface UseFetchTripleDetailsProps {
+    network?: Network;
+    onError?: (message: string) => void;
+}
+export declare const useFetchTripleDetails: ({ network, onError }?: UseFetchTripleDetailsProps) => {
+    fetchTripleDetails: (tripleId: bigint) => Promise<TripleDetails | null>;
+    isLoading: boolean;
+};
+export {};

package/dist/types/hooks/useSubmitVotes.d.ts

@@ -0,0 +1,22 @@
+import { VoteItem, DepositResponse } from '../types/vote';
+import { Network } from './useAtomData';
+
+type TransactionStatus = {
+    status: "idle" | "pending" | "success" | "error" | "approval_pending" | "whitelist_error";
+    message: string;
+};
+interface UseSubmitVotesProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+    onSuccess?: () => void;
+}
+export declare const useSubmitVotes: ({ walletConnected, walletAddress, publicClient, network, onSuccess }: UseSubmitVotesProps) => {
+    submitVotes: (voteItems: VoteItem[]) => Promise<DepositResponse | null>;
+    isSubmitting: boolean;
+    isDepositLoading: boolean;
+    transactionStatus: TransactionStatus;
+    setTransactionStatus: import('react').Dispatch<import('react').SetStateAction<TransactionStatus>>;
+};
+export {};

package/dist/types/hooks/useVoteItemsManagement.d.ts

@@ -0,0 +1,21 @@
+import { VoteItem, VoteDirection } from '../types/vote';
+import { Network } from './useAtomData';
+
+interface UseVoteItemsManagementProps {
+    network?: Network;
+    walletAddress?: string;
+    onError?: (message: string) => void;
+}
+export declare const useVoteItemsManagement: ({ network, walletAddress, onError }: UseVoteItemsManagementProps) => {
+    voteItems: VoteItem[];
+    setVoteItems: import('react').Dispatch<import('react').SetStateAction<VoteItem[]>>;
+    isLoading: boolean;
+    totalUnits: number;
+    numberOfTransactions: number;
+    handleChangeUnits: (id: bigint, direction: VoteDirection, units: number) => void;
+    resetAllVotes: () => void;
+    loadTripleDetails: () => Promise<void>;
+    isVoteDirectionAllowed: (tripleId: bigint, direction: VoteDirection) => boolean;
+    userPositions: Record<string, VoteDirection>;
+};
+export {};

package/dist/types/hooks.old.local/useAccountAtom.d.ts

@@ -0,0 +1,19 @@
+import { Network } from './useAtomData';
+
+export interface AccountAtomResponse {
+    account: {
+        atom: {
+            id: string;
+        } | null;
+    } | null;
+}
+export declare const fetchAccountAtom: (accountId: string, network?: Network) => Promise<AccountAtomResponse>;
+export declare const useAccountAtom: (accountId: string, network?: Network) => {
+    loading: boolean;
+    error: Error | null;
+    hasAccountAtom: boolean;
+    accountAtomId: string | null;
+    network: Network;
+    rawData: AccountAtomResponse | null;
+};
+export default useAccountAtom;

package/dist/types/hooks.old.local/useAtomCreation.d.ts

@@ -0,0 +1,23 @@
+export type IpfsAtom = {
+    '@context': string;
+    '@type': string;
+    name: string;
+    description?: string;
+    image?: string;
+};
+export type IpfsAtomInput = {
+    name: string;
+    description?: string;
+    image?: string | undefined;
+};
+export interface UseAtomCreationProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+}
+export declare const useAtomCreation: ({ walletConnected, walletAddress, publicClient }: UseAtomCreationProps) => {
+    createAtom: (input: IpfsAtomInput) => Promise<{
+        atomId: bigint;
+        ipfsHash: string;
+    }>;
+};

package/dist/types/hooks.old.local/useAtomData.d.ts

@@ -0,0 +1,61 @@
+import { createServerClient } from '@0xintuition/graphql';
+
+export interface AtomData {
+    id: number;
+    label: string;
+    type: string;
+    data: string | null;
+    emoji: string | null;
+    image: string | null;
+    creator_id: string;
+    creator: {
+        id: string;
+        label: string;
+    };
+    value: {
+        id: number;
+    } | null;
+    block_number: number;
+    block_timestamp: string;
+    transaction_hash: string;
+}
+export interface AtomResponse {
+    atom: AtomData;
+}
+export declare enum Network {
+    MAINNET = "mainnet",
+    TESTNET = "testnet"
+}
+export declare const API_URLS: {
+    mainnet: string;
+    testnet: string;
+};
+export declare const createClient: (network?: Network) => ReturnType<typeof createServerClient>;
+export declare const fetchAtomById: (id: number, network?: Network) => Promise<AtomResponse>;
+export declare const fetchAtomByLabel: (label: string, network?: Network) => Promise<{
+    atoms: AtomData[];
+}>;
+export interface AtomByIdHook {
+    data: AtomResponse | null;
+    loading: boolean;
+    error: string | null;
+    network: Network;
+}
+export interface AtomByLabelHook {
+    data: AtomData | null;
+    loading: boolean;
+    error: string | null;
+    network: Network;
+}
+export { useMainnetAtomById, useMainnetAtomByLabel } from './useMainnetAtomData';
+export { useTestnetAtomById, useTestnetAtomByLabel } from './useTestnetAtomData';
+export declare const useAtomById: (id: number, network?: Network) => {
+    data: AtomResponse | null;
+    loading: boolean;
+    error: string | null;
+};
+export declare const useAtomByLabel: (label: string, network?: Network) => {
+    data: AtomData | null;
+    loading: boolean;
+    error: string | null;
+};

package/dist/types/hooks.old.local/useAtomTriples.d.ts

@@ -0,0 +1,22 @@
+import { Network } from './useAtomData';
+
+export interface Triple {
+    subject_id: string;
+    predicate_id: string;
+    object_id: string;
+}
+export interface AtomTriplesResponse {
+    atom: {
+        as_subject_triples: Triple[];
+    } | null;
+}
+export declare const fetchAtomTriples: (atomId: number, network?: Network) => Promise<AtomTriplesResponse>;
+export declare const useAtomTriples: (atomId: string | null, network?: Network) => {
+    loading: boolean;
+    error: Error | null;
+    triples: Triple[];
+    hasTriple: (predicateId: string, objectId: string) => boolean;
+    network: Network;
+    rawData: AtomTriplesResponse | null;
+};
+export default useAtomTriples;

package/dist/types/hooks.old.local/useAtomsByCreator.d.ts

@@ -0,0 +1,14 @@
+import { Network, AtomData } from './useAtomData';
+
+export interface AtomsByCreatorResponse {
+    atoms: AtomData[];
+}
+export declare const fetchAtomsByCreator: (creatorId: string, network?: Network) => Promise<AtomsByCreatorResponse>;
+export declare const useAtomsByCreator: (creatorId: string, network?: Network) => {
+    loading: boolean;
+    error: Error | null;
+    atoms: AtomData[];
+    network: Network;
+    rawData: AtomsByCreatorResponse | null;
+};
+export default useAtomsByCreator;

package/dist/types/hooks.old.local/useBatchCreateTriple.d.ts

@@ -0,0 +1,16 @@
+export interface TripleToCreate {
+    subjectId: bigint;
+    predicateId: bigint;
+    objectId: bigint;
+}
+interface UseBatchCreateTripleProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+}
+export declare const useBatchCreateTriple: ({ walletConnected, walletAddress, publicClient }: UseBatchCreateTripleProps) => {
+    checkTripleExists: (subjectId: bigint, predicateId: bigint, objectId: bigint) => Promise<boolean>;
+    batchCreateTriple: (triples: TripleToCreate[]) => Promise<any>;
+    createPlayerTriples: (playerAtomId: bigint) => Promise<any>;
+};
+export {};

package/dist/types/hooks.old.local/useCreateSingleTriple.d.ts

@@ -0,0 +1,10 @@
+interface UseCreateSingleTripleProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+}
+export declare const useCreateSingleTriple: ({ walletConnected, walletAddress, publicClient }: UseCreateSingleTripleProps) => {
+    checkTripleExists: (subjectId: bigint, predicateId: bigint, objectId: bigint) => Promise<boolean>;
+    createSingleTriple: (subjectId: bigint, predicateId: bigint, objectId: bigint) => Promise<bigint>;
+};
+export {};

package/dist/types/hooks.old.local/useDepositTriple.d.ts

@@ -0,0 +1,14 @@
+import { VoteDirection, DepositResponse } from '../types/vote';
+import { Network } from './useAtomData';
+
+interface UseDepositTripleProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+}
+export declare const useDepositTriple: ({ walletConnected, walletAddress, publicClient, network, }: UseDepositTripleProps) => {
+    depositTriple: (claimId: bigint, units: number, direction: VoteDirection) => Promise<DepositResponse>;
+    isLoading: boolean;
+};
+export {};

package/dist/types/hooks.old.local/useDisplayTriplesWithPosition.d.ts

@@ -0,0 +1,5 @@
+export declare const useDisplayTriplesWithPosition: (walletAddress: string) => {
+    data: any;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/types/hooks.old.local/useFetchTripleDetails.d.ts

@@ -0,0 +1,27 @@
+import { Network } from './useAtomData';
+
+export interface TripleDetails {
+    id: string;
+    subject?: {
+        label: string;
+    };
+    predicate?: {
+        label: string;
+    };
+    object?: {
+        label: string;
+    };
+    vault_id?: string;
+    vault_position_count?: number;
+    counter_vault_id?: string;
+    counter_vault_position_count?: number;
+}
+interface UseFetchTripleDetailsProps {
+    network?: Network;
+    onError?: (message: string) => void;
+}
+export declare const useFetchTripleDetails: ({ network, onError }?: UseFetchTripleDetailsProps) => {
+    fetchTripleDetails: (tripleId: bigint) => Promise<TripleDetails | null>;
+    isLoading: boolean;
+};
+export {};

package/dist/types/hooks.old.local/useMainnetAtomData.d.ts

@@ -0,0 +1,20 @@
+import { Network, AtomResponse, AtomData } from './useAtomData';
+
+/**
+ * Hook pour récupérer un atome par ID sur le mainnet
+ */
+export declare const useMainnetAtomById: (id: number) => {
+    data: AtomResponse | null;
+    loading: boolean;
+    error: string | null;
+    network: Network;
+};
+/**
+ * Hook pour récupérer un atome par label sur le mainnet
+ */
+export declare const useMainnetAtomByLabel: (label: string) => {
+    data: AtomData | null;
+    loading: boolean;
+    error: string | null;
+    network: Network;
+};

package/dist/types/hooks.old.local/useSubmitVotes.d.ts

@@ -0,0 +1,22 @@
+import { VoteItem, DepositResponse } from '../types/vote';
+import { Network } from './useAtomData';
+
+type TransactionStatus = {
+    status: "idle" | "pending" | "success" | "error" | "approval_pending" | "whitelist_error";
+    message: string;
+};
+interface UseSubmitVotesProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+    onSuccess?: () => void;
+}
+export declare const useSubmitVotes: ({ walletConnected, walletAddress, publicClient, network, onSuccess }: UseSubmitVotesProps) => {
+    submitVotes: (voteItems: VoteItem[]) => Promise<DepositResponse | null>;
+    isSubmitting: boolean;
+    isDepositLoading: boolean;
+    transactionStatus: TransactionStatus;
+    setTransactionStatus: import('react').Dispatch<import('react').SetStateAction<TransactionStatus>>;
+};
+export {};

package/dist/types/hooks.old.local/useTestnetAtomData.d.ts

@@ -0,0 +1,20 @@
+import { Network, AtomResponse, AtomData } from './useAtomData';
+
+/**
+ * Hook pour récupérer un atome par ID sur le testnet
+ */
+export declare const useTestnetAtomById: (id: number) => {
+    data: AtomResponse | null;
+    loading: boolean;
+    error: string | null;
+    network: Network;
+};
+/**
+ * Hook pour récupérer un atome par label sur le testnet
+ */
+export declare const useTestnetAtomByLabel: (label: string) => {
+    data: AtomData | null;
+    loading: boolean;
+    error: string | null;
+    network: Network;
+};

package/dist/types/hooks.old.local/useTripleByCreator.d.ts

@@ -0,0 +1,39 @@
+import { Network } from './useAtomData';
+
+export interface Triple {
+    id: string;
+    subject_id: string;
+    predicate_id: string;
+    object_id: string;
+    subject: {
+        id: string;
+        label: string;
+        type: string;
+        creator_id: string;
+    };
+    predicate: {
+        id: string;
+        label: string;
+        type: string;
+    };
+    object: {
+        id: string;
+        label: string;
+        type: string;
+    };
+    block_number: number;
+    block_timestamp: string;
+    transaction_hash: string;
+}
+export interface TriplesByCreatorResponse {
+    triples: Triple[];
+}
+export declare const fetchTriplesByCreator: (creatorId: string, predicateId?: number, objectId?: number, network?: Network) => Promise<TriplesByCreatorResponse>;
+export declare const useTripleByCreator: (creatorId: string, predicateId?: number, objectId?: number, network?: Network) => {
+    loading: boolean;
+    error: Error | null;
+    triples: Triple[];
+    network: Network;
+    rawData: TriplesByCreatorResponse | null;
+};
+export default useTripleByCreator;

package/dist/types/hooks.old.local/useVoteItemsManagement.d.ts

@@ -0,0 +1,18 @@
+import { VoteItem, VoteDirection } from '../types/vote';
+import { Network } from './useAtomData';
+
+interface UseVoteItemsManagementProps {
+    network?: Network;
+    onError?: (message: string) => void;
+}
+export declare const useVoteItemsManagement: ({ network, onError }: UseVoteItemsManagementProps) => {
+    voteItems: VoteItem[];
+    setVoteItems: import('react').Dispatch<import('react').SetStateAction<VoteItem[]>>;
+    isLoading: boolean;
+    totalUnits: number;
+    numberOfTransactions: number;
+    handleChangeUnits: (id: bigint, direction: VoteDirection, units: number) => void;
+    resetAllVotes: () => void;
+    loadTripleDetails: () => Promise<void>;
+};
+export {};

package/dist/types/pages/DirectPositionCheck.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+declare const DirectPositionCheck: React.FC;
+export default DirectPositionCheck;

package/dist/types/types/vote.d.ts

@@ -0,0 +1,26 @@
+export declare enum VoteDirection {
+    For = "FOR",
+    Against = "AGAINST",
+    None = "NONE"
+}
+export interface Claim {
+    id: bigint;
+    subject: string;
+    predicate: string;
+    object: string;
+}
+export interface VoteItem extends Claim {
+    units: number;
+    direction: VoteDirection;
+    vault_id?: string;
+    vault_position_count?: number;
+    counter_vault_id?: string;
+    counter_vault_position_count?: number;
+    userHasPosition?: boolean;
+    userPositionDirection?: VoteDirection;
+}
+export interface DepositResponse {
+    success: boolean;
+    hash?: string;
+    error?: string;
+}

package/dist/types/utils/debugPosition.d.ts

@@ -0,0 +1,11 @@
+import { Network } from '../hooks/useAtomData';
+
+/**
+ * Function to directly check a user's position on a specific triple
+ * This can be helpful for debugging position-related issues
+ */
+export declare const checkTriplePosition: (walletAddress: string, tripleId: string | number, network?: Network) => Promise<{
+    hasPosition: boolean;
+    isFor: boolean | null;
+    result: any;
+}>;

package/dist/types/utils/voteConstants.d.ts

@@ -0,0 +1,2 @@
+export declare const UNIT_VALUE = 1000000000000000n;
+export declare const PREDEFINED_CLAIM_IDS: bigint[];

package/dist/types/utils/voteUtils.d.ts

@@ -0,0 +1,32 @@
+import { VoteItem } from '../types/vote';
+
+/**
+ * Calculates the total number of transactions needed for the current vote selection
+ * @param voteItems Array of vote items
+ * @returns Number of transactions
+ */
+export declare const calculateNumberOfTransactions: (voteItems: VoteItem[]) => number;
+/**
+ * Calculates the total units selected across all vote items
+ * @param voteItems Array of vote items
+ * @returns Total units
+ */
+export declare const calculateTotalUnits: (voteItems: VoteItem[]) => number;
+/**
+ * Calculates the total ETH cost based on number of units
+ * @param units Number of units
+ * @returns Total ETH cost as a string with 3 decimal places
+ */
+export declare const calculateEthCost: (units: number) => string;
+/**
+ * Calculates the estimated gas cost for a set of transactions
+ * @param transactionCount Number of transactions
+ * @returns Estimated gas cost as a string with 4 decimal places
+ */
+export declare const calculateGasCost: (transactionCount: number) => string;
+/**
+ * Reset all vote items to zero units and no direction
+ * @param voteItems Array of vote items
+ * @returns New array with reset vote items
+ */
+export declare const resetVoteItems: (voteItems: VoteItem[]) => VoteItem[];