import { useNetworkStore } from '@zknoid/hooks';
 
const network = useNetworkStore();

export interface NetworkState {
  minaNetwork: Network | undefined;
  setNetwork: (chainId: string) => Promise<void>;
  address: string | undefined;
  connected: boolean;
  protokitClientStarted: boolean;
  onConnect: (address: string | undefined) => Promise<void>;
  onProtokitClientStarted: () => void;
  connectWallet: () => Promise<void>;
  walletInstalled: () => boolean;
  pendingL2Transactions: PendingTransaction[];
  addPendingL2Transaction: (pendingTransaction: PendingTransaction) => void;
  removePendingL2Transaction: (pendingTransaction: PendingTransaction) => void;
}

import { useProtokitChainStore } from '@zknoid/hooks';
 
const chain = useProtokitChainStore();

interface ChainState {
  loading: boolean;
  block?: {
    height: string;
  } & ComputedBlockJSON;
  loadBlock: () => Promise<void>;
}

import { useChainStore } from '@zknoid/hooks';
 
const chain = useChainStore();

interface ChainState {
  loading: boolean;
  block?: {
    height: string;
  } & ComputedBlockJSON;
  loadBlock: (chainId: string) => Promise<void>;
}

import { useProtokitBalancesStore } from "@zknoid/hooks";
 
const balancesStore = useProtokitBalancesStore();

interface BalancesState {
  loading: boolean;
  balances: {
    // address - balance
    [key: string]: bigint;
  };
  loadBalance: (client: ClientAppChain<typeof DefaultRuntimeModules>, address: string) => Promise<void>;
}

import { useMinaBridge } from "@zknoid/hooks";
 
const bridge = useMinaBridge();
  ...
const createCompetition = async () => {
  const gameHub = client.runtime.resolve('ArkanoidGameHub');
  if (await bridge(BigInt(funding) * 10n ** 9n))
    throw Error('Not enough funds');
  ...
}

(amount: number) => Promise<void>

import { useSessionKeyStore } from "@zknoid/hooks";
 
const sessionPublicKey = useStore(useSessionKeyStore, (state) => state.getSessionKey()).toPublicKey();
const sessionPrivateKey = useStore(useSessionKeyStore, (state) => state.getSessionKey());

interface MatchQueueState {
    sessionKeyBase58: any;
    getSessionKey: () => PrivateKey;
    newSessionKey: () => PrivateKey;
}
 
UseBoundStore<Write<StoreApi<MatchQueueState>, StorePersist<MatchQueueState, never>>>

const sessionPrivateKey = useStore(useSessionKeyStore, (state) =>
  state.getSessionKey()
);
...
  const createNewLobby = async (
    name: string,
    participationFee: number,
    privateLobby: boolean,
    accessKey: number
  ) => {
    const lobbyManager = await client.runtime.resolve(params.contractName);
 
    const tx = await client.transaction(
      PublicKey.fromBase58(networkStore.address!),
      async () => {
        lobbyManager.createLobby(
          CircuitString.fromString(name),
          ProtoUInt64.from(participationFee).mul(10 ** 9),
          Bool(privateLobby),
          sessionPrivateKey.toPublicKey(),
          Field.from(accessKey)
        );
      }
    );
  }