@talismn/balances-react 0.3.3 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @talismn/balances-react
 
+## 0.4.0
+
+### Minor Changes
+
+- a6969098: refactor: tweaks to trigger less balance subscription resets
+
+### Patch Changes
+
+- 3068bd60: feat: stale balances and exponential rpc backoff
+- 6643a4e4: fix: tokenRates in @talismn/balances-react
+- 6643a4e4: fix: ported useDbCache related perf fixes to @talismn/balances-react
+- Updated dependencies [3068bd60]
+- Updated dependencies [6643a4e4]
+- Updated dependencies [79f6ccf6]
+- Updated dependencies [6643a4e4]
+- Updated dependencies [c24dc1fb]
+  - @talismn/chain-connector@0.4.3
+  - @talismn/connection-meta@0.0.2
+  - @talismn/balances@0.4.0
+  - @talismn/token-rates@0.1.15
+  - @talismn/chaindata-provider-extension@0.4.3
+  - @talismn/chaindata-provider@0.4.3
+  - @talismn/chain-connector-evm@0.4.3
+
 ## 0.3.3
 
 ### Patch Changes

package/dist/declarations/src/hooks/index.d.ts

@@ -1,3 +1,23 @@
+export * from "./useAllAddresses";
+export * from "./useBalanceModules";
 export * from "./useBalances";
+export * from "./useBalancesHydrate";
+export * from "./useBalancesStatus";
+export * from "./useChainConnectors";
 export * from "./useChaindata";
+export * from "./useChains";
+export * from "./useDbCache";
+export * from "./useDbCacheSubscription";
+export * from "./useEvmNetworks";
 export * from "./useTokenRates";
+export * from "./useTokens";
+export * from "./useWithTestnets";
+import { BalanceModule, Hydrate } from "@talismn/balances";
+import { ReactNode } from "react";
+export type BalancesProviderProps = {
+    balanceModules: Array<(hydrate: Hydrate) => BalanceModule<any, any, any, any, any>>;
+    onfinalityApiKey?: string;
+    withTestnets?: boolean;
+    children?: ReactNode;
+};
+export declare const BalancesProvider: ({ balanceModules, onfinalityApiKey, withTestnets, children, }: BalancesProviderProps) => JSX.Element;

package/dist/declarations/src/hooks/useAllAddresses.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const AllAddressesProvider: import("react").FC<{
+    children?: import("react").ReactNode;
+}>, useAllAddresses: () => [string[], import("react").Dispatch<import("react").SetStateAction<string[]>>];

package/dist/declarations/src/hooks/useBalanceModules.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { BalanceModule, Hydrate } from "@talismn/balances";
+export type BalanceModulesProviderOptions = {
+    balanceModules: Array<(hydrate: Hydrate) => BalanceModule<any, any, any, any, any>>;
+};
+export declare const BalanceModulesProvider: import("react").FC<BalanceModulesProviderOptions & {
+    children?: import("react").ReactNode;
+}>, useBalanceModules: () => BalanceModule<any, any, any, any, any>[];

package/dist/declarations/src/hooks/useBalances.d.ts

@@ -1,6 +1,3 @@
-import { AddressesByToken, BalanceModule, Balances } from "@talismn/balances";
-import { ChaindataProvider, Token } from "@talismn/chaindata-provider";
-export type Options = {
-    onfinalityApiKey?: string;
-};
-export declare function useBalances(balanceModules: Array<BalanceModule<any, any, any, any>>, chaindataProvider: ChaindataProvider | null, addressesByToken: AddressesByToken<Token> | null, options?: Options): Balances | undefined;
+import { AddressesByToken, Balances } from "@talismn/balances";
+import { Token } from "@talismn/chaindata-provider";
+export declare function useBalances(addressesByToken: AddressesByToken<Token> | null): Balances;

package/dist/declarations/src/hooks/useBalancesHydrate.d.ts

@@ -0,0 +1,2 @@
+import { HydrateDb } from "@talismn/balances";
+export declare const useBalancesHydrate: () => HydrateDb;

package/dist/declarations/src/hooks/useBalancesStatus.d.ts

@@ -0,0 +1,19 @@
+import { Balances } from "@talismn/balances";
+export type BalancesStatus = {
+    status: "live";
+} | {
+    status: "fetching";
+} | {
+    status: "stale";
+    staleChains: string[];
+};
+/**
+ * Given a collection of `Balances`, this hook returns a `BalancesStatus` summary for the collection.
+ *
+ * @param balances The collection of balances to get the status from.
+ * @param isLoadingLocks Because the wallet currently fetches locks outside of the balances api, this param can be used to indicate that the locks are still loading, even if the `Balances` collection is not.
+ * @returns An instance of `BalancesStatus` which represents the status of the balances collection.
+
+ */
+export declare const useBalancesStatus: (balances: Balances, isLoadingLocks?: boolean) => BalancesStatus;
+export declare const getStaleChains: (balances: Balances) => string[];

package/dist/declarations/src/hooks/useChainConnectors.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
+export type ChainConnectorsProviderOptions = {
+    onfinalityApiKey?: string;
+};
+export declare const ChainConnectorsProvider: import("react").FC<ChainConnectorsProviderOptions & {
+    children?: import("react").ReactNode;
+}>, useChainConnectors: () => {
+    substrate: ChainConnector;
+    evm: ChainConnectorEvm;
+};

package/dist/declarations/src/hooks/useChaindata.d.ts

@@ -1,25 +1,8 @@
-import { Chain, ChainId, ChainList, ChaindataProvider, EvmNetwork, EvmNetworkId, EvmNetworkList, Token, TokenId, TokenList } from "@talismn/chaindata-provider";
-export type Options = {
+/// <reference types="react" />
+import { ChaindataProviderExtension } from "@talismn/chaindata-provider-extension";
+export type ChaindataProviderOptions = {
     onfinalityApiKey?: string;
 };
-export declare function useChaindata(options?: Options): (ChaindataProvider & {
-    generation?: number | undefined;
-}) | null;
-export declare function useChains(chaindata: (ChaindataProvider & {
-    generation?: number;
-}) | null): ChainList;
-export declare function useChain(chaindata: (ChaindataProvider & {
-    generation?: number;
-}) | null, chainId?: ChainId): Chain | null | undefined;
-export declare function useEvmNetworks(chaindata: (ChaindataProvider & {
-    generation?: number;
-}) | null): EvmNetworkList;
-export declare function useEvmNetwork(chaindata: (ChaindataProvider & {
-    generation?: number;
-}) | null, evmNetworkId?: EvmNetworkId): EvmNetwork | null | undefined;
-export declare function useTokens(chaindata: (ChaindataProvider & {
-    generation?: number;
-}) | null): TokenList;
-export declare function useToken(chaindata: (ChaindataProvider & {
-    generation?: number;
-}) | null, tokenId?: TokenId): Token | null | undefined;
+export declare const ChaindataProvider: import("react").FC<ChaindataProviderOptions & {
+    children?: import("react").ReactNode;
+}>, useChaindata: () => ChaindataProviderExtension;

package/dist/declarations/src/hooks/useChains.d.ts

@@ -0,0 +1,3 @@
+import { ChainId } from "@talismn/chaindata-provider";
+export declare function useChains(withTestnets?: boolean): Record<string, import("@talismn/chaindata-provider").Chain | import("@talismn/chaindata-provider").CustomChain>;
+export declare function useChain(chainId?: ChainId, withTestnets?: boolean): import("@talismn/chaindata-provider").Chain | undefined;

package/dist/declarations/src/hooks/useDbCache.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { BalanceJson } from "@talismn/balances";
+import { Chain, ChainId, CustomChain, CustomEvmNetwork, EvmNetwork, EvmNetworkId, Token, TokenId } from "@talismn/chaindata-provider";
+import { TokenRates } from "@talismn/token-rates";
+type DbCache = {
+    chainsWithTestnets: (Chain | CustomChain)[];
+    chainsWithoutTestnets: (Chain | CustomChain)[];
+    evmNetworksWithTestnets: (EvmNetwork | CustomEvmNetwork)[];
+    evmNetworksWithoutTestnets: (EvmNetwork | CustomEvmNetwork)[];
+    tokensWithTestnets: Token[];
+    tokensWithoutTestnets: Token[];
+    chainsWithTestnetsMap: Record<ChainId, Chain | CustomChain>;
+    chainsWithoutTestnetsMap: Record<ChainId, Chain | CustomChain>;
+    evmNetworksWithTestnetsMap: Record<EvmNetworkId, EvmNetwork | CustomEvmNetwork>;
+    evmNetworksWithoutTestnetsMap: Record<EvmNetworkId, EvmNetwork | CustomEvmNetwork>;
+    tokensWithTestnetsMap: Record<TokenId, Token>;
+    tokensWithoutTestnetsMap: Record<TokenId, Token>;
+    tokenRatesMap: Record<TokenId, TokenRates>;
+    balances: BalanceJson[];
+};
+export declare const DbCacheProvider: import("react").FC<{
+    children?: import("react").ReactNode;
+}>, useDbCache: () => DbCache;
+export {};

package/dist/declarations/src/hooks/useDbCacheSubscription.d.ts

@@ -0,0 +1,13 @@
+export type DbEntityType = "chains" | "evmNetworks" | "tokens";
+/**
+ * This hook is responsible for fetching the data used for balances and inserting it into the db.
+ */
+export declare const useDbCacheSubscription: (subscribeTo: DbEntityType) => void;
+/**
+ * This hook is responsible for fetching the data used for token rates and inserting it into the db.
+ */
+export declare function useDbCacheTokenRatesSubscription(): void;
+/**
+ * This hook is responsible for fetching the data used for balances and inserting it into the db.
+ */
+export declare function useDbCacheBalancesSubscription(): void;

package/dist/declarations/src/hooks/useEvmNetworks.d.ts

@@ -0,0 +1,3 @@
+import { EvmNetworkId } from "@talismn/chaindata-provider";
+export declare function useEvmNetworks(withTestnets?: boolean): Record<string, import("@talismn/chaindata-provider").EvmNetwork | import("@talismn/chaindata-provider").CustomEvmNetwork>;
+export declare function useEvmNetwork(evmNetworkId?: EvmNetworkId, withTestnets?: boolean): import("@talismn/chaindata-provider").EvmNetwork | undefined;

package/dist/declarations/src/hooks/useTokenRates.d.ts

@@ -1,3 +1,3 @@
-import { IToken, TokenId } from "@talismn/chaindata-provider";
-import { TokenRatesList } from "@talismn/token-rates";
-export declare function useTokenRates(tokens?: Record<TokenId, IToken>): TokenRatesList;
+import { TokenId } from "@talismn/chaindata-provider";
+export declare function useTokenRates(): Record<string, import("@talismn/token-rates").TokenRates>;
+export declare function useTokenRate(tokenId?: TokenId): import("@talismn/token-rates").TokenRates | undefined;

package/dist/declarations/src/hooks/useTokens.d.ts

@@ -0,0 +1,3 @@
+import { TokenId } from "@talismn/chaindata-provider";
+export declare function useTokens(withTestnets?: boolean): Record<string, import("@talismn/chaindata-provider").IToken>;
+export declare function useToken(tokenId?: TokenId, withTestnets?: boolean): import("@talismn/chaindata-provider").IToken | undefined;

package/dist/declarations/src/hooks/useWithTestnets.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare const WithTestnetsProvider: import("react").FC<{
+    withTestnets?: boolean | undefined;
+} & {
+    children?: import("react").ReactNode;
+}>, useWithTestnets: () => {
+    withTestnets: boolean | undefined;
+};

package/dist/declarations/src/index.d.ts

@@ -1 +1,2 @@
 export * from "./hooks";
+export * from "./util";

package/dist/declarations/src/util/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./provideContext";
+export * from "./useMulticastSubscription";

package/dist/declarations/src/util/provideContext.d.ts

@@ -0,0 +1,9 @@
+import { FC, ReactNode } from "react";
+/**
+ * This utility generates a context provider from a react hook passed as argument
+ *
+ * @returns an array containing the provider and the consumer hook
+ */
+export declare const provideContext: <P, T>(useProviderContext: (props: P) => T) => [FC<P & {
+    children?: ReactNode;
+}>, () => T];

package/dist/declarations/src/util/useMulticastSubscription.d.ts

@@ -0,0 +1,16 @@
+export type Unsubscribe = () => void;
+/**
+ * Creates a subscription function that can be used to subscribe to a multicast observable created from an upstream source.
+ *
+ * An example of when this is useful is when we want to subscribe to some data from multiple components, but we only want
+ * to actively keep that data hydrated when at least one component is subscribed to it.
+ *
+ * When the first component subscribes, the `upstream` function will be called. It should then set up a subscription and return a teardown function.
+ * When subsequent components subscribe, they will be added to the existing subscription.
+ * When the last component unsubscribes, the teardown function returned from the `upstream` function will be called.
+ *
+ * @param upstream A function that takes a "next" callback function as an argument, and returns either an unsubscribe function or void.
+ * @returns A subscription function that can be used to subscribe to the multicast observable.
+ */
+export declare const useMulticastSubscription: <T>(upstream: (next: (val: T) => void) => Unsubscribe | void) => (callback?: ((val: T) => void) | undefined) => Unsubscribe;
+export declare const createMulticastSubscription: <T>(upstream: (next: (val: T) => void) => Unsubscribe | void) => (callback?: ((val: T) => void) | undefined) => Unsubscribe;

package/dist/declarations/src/util/useSharedSubscription.d.ts

@@ -0,0 +1,9 @@
+type UnsubscribeFn = () => void;
+type InitSubscriptionCallback = () => UnsubscribeFn;
+/**
+ * This hook ensures a subscription is created only once, and unsubscribe automatically as soon as there is no consumer to the hook
+ * @param key key that is unique to the subscription's parameters
+ * @param subscribe // subscribe function that will be shared by all consumers of the key
+ */
+export declare const useSharedSubscription: (key: string, subscribe: InitSubscriptionCallback) => void;
+export {};