@talismn/balances 0.3.3 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @talismn/balances
 
+## 0.4.1
+
+### Patch Changes
+
+- fb8ee962: feat: proxy dapp websocket requests to talisman wallet backend when available
+- f7aca48b: eslint rules
+- 01bf239b: feat: crowdloan and nom pool balances
+- 48f0222e: fix: removed some explicit `any`s
+- 01bf239b: fix: packages publishing with incorrect interdependency versions
+- Updated dependencies [fb8ee962]
+- Updated dependencies [c898da98]
+- Updated dependencies [f7aca48b]
+- Updated dependencies [01bf239b]
+- Updated dependencies [48f0222e]
+- Updated dependencies [01bf239b]
+  - @talismn/chain-connector@0.4.4
+  - @talismn/chain-connector-evm@0.4.4
+  - @talismn/chaindata-provider@0.4.4
+  - @talismn/token-rates@0.1.16
+  - @talismn/util@0.1.9
+
+## 0.4.0
+
+### 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 [c24dc1fb]
+  - @talismn/chain-connector@0.4.3
+  - @talismn/util@0.1.8
+  - @talismn/token-rates@0.1.15
+  - @talismn/chaindata-provider@0.4.3
+  - @talismn/chain-connector-evm@0.4.3
+
 ## 0.3.3
 
 ### Patch Changes

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

@@ -1,43 +1,65 @@
+import { UnsignedTransaction } from "@substrate/txwrapper-core";
 import { ChainConnector } from "@talismn/chain-connector";
 import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
 import { ChainId, ChaindataProvider, IToken } from "@talismn/chaindata-provider";
+import { ethers } from "ethers";
 import { AddressesByToken, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
-export interface BalanceModule<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig> {
-}
-export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends IToken, TChainMeta extends ExtendableChainMeta = undefined, TModuleConfig extends ExtendableModuleConfig = undefined>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig>;
 export type ExtendableTokenType = IToken;
 export type ExtendableChainMeta = Record<string, unknown> | undefined;
 export type DefaultChainMeta = undefined;
 export type ExtendableModuleConfig = Record<string, unknown> | undefined;
 export type DefaultModuleConfig = undefined;
-interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> extends BalanceModuleCommon<TModuleType, TTokenType> {
+export type BaseTransferParams = {
+    tokenId: string;
+    from: string;
+    to: string;
+    amount: string;
+};
+export type ExtendableTransferParams = BaseTransferParams | undefined;
+export type DefaultTransferParams = undefined;
+export type NewTransferParamsType<T extends Record<string, unknown>> = BaseTransferParams & T;
+export type TransferTokenTx = {
+    type: "substrate";
+    tx: UnsignedTransaction;
+} | {
+    type: "evm";
+    tx: ethers.providers.TransactionRequest;
+};
+export type ChainConnectors = {
+    substrate?: ChainConnector;
+    evm?: ChainConnectorEvm;
+};
+export type Hydrate = {
+    chainConnectors: ChainConnectors;
+    chaindataProvider: ChaindataProvider;
+};
+export type NewBalanceModule<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> = (hydrate: Hydrate) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
+export interface BalanceModule<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams> {
+}
+export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends IToken, TChainMeta extends ExtendableChainMeta = undefined, TModuleConfig extends ExtendableModuleConfig = undefined, TTransferParams extends ExtendableTransferParams = undefined>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
+interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
     /** Pre-processes any substrate chain metadata required by this module ahead of time */
-    fetchSubstrateChainMeta(chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, chainId: ChainId, moduleConfig: TModuleConfig | undefined): Promise<TChainMeta | null>;
+    fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
     /** Detects which tokens are available on a given substrate chain */
-    fetchSubstrateChainTokens(chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, chainId: ChainId, chainMeta: TChainMeta, moduleConfig: TModuleConfig | undefined): Promise<Record<TTokenType["id"], TTokenType>>;
+    fetchSubstrateChainTokens(chainId: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-interface BalanceModuleEvm<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> extends BalanceModuleCommon<TModuleType, TTokenType> {
+interface BalanceModuleEvm<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
     /** Pre-processes any evm chain metadata required by this module ahead of time */
-    fetchEvmChainMeta(chainConnector: ChainConnectorEvm, chaindataProvider: ChaindataProvider, chainId: ChainId, moduleConfig: TModuleConfig | undefined): Promise<TChainMeta | null>;
+    fetchEvmChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
     /** Detects which tokens are available on a given evm chain */
-    fetchEvmChainTokens(chainConnector: ChainConnectorEvm, chaindataProvider: ChaindataProvider, chainId: ChainId, chainMeta: TChainMeta, moduleConfig: TModuleConfig | undefined): Promise<Record<TTokenType["id"], TTokenType>>;
+    fetchEvmChainTokens(chainId: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-interface BalanceModuleCommon<TModuleType extends string, TTokenType extends ExtendableTokenType> {
+interface BalanceModuleCommon<TModuleType extends string, TTokenType extends ExtendableTokenType, TTransferParams extends ExtendableTransferParams> {
     get type(): TModuleType;
     /**
      * Subscribe to balances for this module with optional filtering.
      *
      * If subscriptions are not possible, this function should poll at some reasonable interval.
      */
-    subscribeBalances(chainConnectors: {
-        substrate?: ChainConnector;
-        evm?: ChainConnectorEvm;
-    }, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
+    subscribeBalances(addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
     /** Fetch balances for this module with optional filtering */
-    fetchBalances(chainConnectors: {
-        substrate?: ChainConnector;
-        evm?: ChainConnectorEvm;
-    }, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
-    [x: string | number | symbol]: unknown;
+    fetchBalances(addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
+    /** Prepare a tx to transfer some tokens from this module */
+    transferToken(transferParams: TTransferParams): Promise<TransferTokenTx | null>;
 }
 export {};

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

@@ -1,29 +1,64 @@
-import { TypeRegistry } from "@polkadot/types";
+import type { Registry } from "@polkadot/types-codec/types";
 import { ChainConnector } from "@talismn/chain-connector";
-import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
-import { ChaindataProvider } from "@talismn/chaindata-provider";
-import { BalanceModule, DefaultChainMeta, DefaultModuleConfig, ExtendableChainMeta, ExtendableModuleConfig, ExtendableTokenType } from "./BalanceModule";
-import { AddressesByToken, Balance, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
+import { Chain, ChainId } from "@talismn/chaindata-provider";
+import { BalanceModule, DefaultChainMeta, DefaultModuleConfig, DefaultTransferParams, ExtendableChainMeta, ExtendableModuleConfig, ExtendableTokenType, ExtendableTransferParams, NewBalanceModule } from "./BalanceModule";
+import { AddressesByToken, Balance, BalanceJson, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
 /**
  * Wraps a BalanceModule's fetch/subscribe methods with a single `balances` method.
  * This `balances` method will subscribe if a callback parameter is provided, or otherwise fetch.
  */
-export declare function balances<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig>(balanceModule: BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig>, chainConnectors: {
-    substrate?: ChainConnector;
-    evm?: ChainConnectorEvm;
-}, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
-export declare function balances<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig>(balanceModule: BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig>, chainConnectors: {
-    substrate?: ChainConnector;
-    evm?: ChainConnectorEvm;
-}, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
+export declare function balances<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams>(balanceModule: BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>, addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
+export declare function balances<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams>(balanceModule: BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>, addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
+export type GetOrCreateTypeRegistry = (chainId: ChainId, metadataRpc?: `0x${string}`) => Registry;
+export declare const createTypeRegistryCache: () => {
+    getOrCreateTypeRegistry: GetOrCreateTypeRegistry;
+};
+export type AnyBalanceModule = BalanceModule<any, any, any, any, any>;
+export type AnyNewBalanceModule = NewBalanceModule<any, any, any, any, any>;
+/**
+ * The following `Infer*` collection of generic types can be used when you want to
+ * extract one of the generic type arguments from an existing BalanceModule.
+ *
+ * For example, you might want to write a function which can accept any BalanceModule
+ * as an input, and then return the specific TokenType for that module:
+ * function getTokens<T extends AnyBalanceModule>(module: T): InferTokenType<T>
+ *
+ * Or for another example, you might want a function which can take any BalanceModule `type`
+ * string as input, and then return some data associated with that module with the correct type:
+ * function getChainMeta<T extends AnyBalanceModule>(type: InferModuleType<T>): InferChainMeta<T> | undefined
+ */
+type InferBalanceModuleTypes<T extends AnyNewBalanceModule> = T extends NewBalanceModule<infer TModuleType, infer TTokenType, infer TChainMeta, infer TModuleConfig, infer TTransferParams> ? {
+    TModuleType: TModuleType;
+    TTokenType: TTokenType;
+    TChainMeta: TChainMeta;
+    TModuleConfig: TModuleConfig;
+    TTransferParams: TTransferParams;
+} : never;
+export type InferModuleType<T extends AnyNewBalanceModule> = InferBalanceModuleTypes<T>["TModuleType"];
+export type InferTokenType<T extends AnyNewBalanceModule> = InferBalanceModuleTypes<T>["TTokenType"];
+export type InferChainMeta<T extends AnyNewBalanceModule> = InferBalanceModuleTypes<T>["TChainMeta"];
+export type InferModuleConfig<T extends AnyNewBalanceModule> = InferBalanceModuleTypes<T>["TModuleConfig"];
+export type InferTransferParams<T extends AnyNewBalanceModule> = InferBalanceModuleTypes<T>["TTransferParams"];
+/**
+ * Given a `moduleType` and a `chain` from a chaindataProvider, this function will find the chainMeta
+ * associated with the given balanceModule for the given chain.
+ */
+export declare const findChainMeta: <TBalanceModule extends AnyNewBalanceModule>(moduleType: InferModuleType<TBalanceModule>, chain?: Chain) => InferChainMeta<TBalanceModule> | undefined;
 export declare const filterMirrorTokens: (balance: Balance, i: number, balances: Balance[]) => boolean;
+export declare const getValidSubscriptionIds: () => Set<string>;
+export declare const createSubscriptionId: () => string;
+export declare const deleteSubscriptionId: () => void;
+/**
+ * Sets all balance statuses from `live-${string}` to either `live` or `cached`
+ */
+export declare const deriveStatuses: (validSubscriptionIds: string[], balances: BalanceJson[]) => BalanceJson[];
 /**
  * Used by a variety of balance modules to help encode and decode substrate state calls.
  */
 export declare class StorageHelper {
     #private;
     tags: any;
-    constructor(registry: TypeRegistry, module: string, method: string, ...parameters: any[]);
+    constructor(registry: Registry, module: string, method: string, ...parameters: any[]);
     get stateKey(): `0x${string}` | undefined;
     get module(): string;
     get method(): string;
@@ -31,3 +66,21 @@ export declare class StorageHelper {
     tag(tags: any): this;
     decode(input?: string | null): import("@polkadot/types-codec/types").Codec | undefined;
 }
+/**
+ * Pass some these into an `RpcStateQueryHelper` in order to easily batch multiple state queries into the one rpc call.
+ */
+export type RpcStateQuery<T> = {
+    chainId: string;
+    stateKey: string;
+    decodeResult: (change: string | null) => T;
+};
+/**
+ * Used by a variety of balance modules to help batch multiple state queries into the one rpc call.
+ */
+export declare class RpcStateQueryHelper<T> {
+    #private;
+    constructor(chainConnector: ChainConnector, queries: Array<RpcStateQuery<T>>);
+    subscribe(callback: SubscriptionCallback<T[]>, timeout?: number | false, subscribeMethod?: string, responseMethod?: string, unsubscribeMethod?: string): Promise<UnsubscribeFn>;
+    fetch(method?: string): Promise<T[]>;
+}
+export {};

package/dist/declarations/src/types/balances.d.ts

@@ -61,6 +61,19 @@ export declare class Balances {
      * @returns All balances which match the query.
      */
     find: (query: BalanceSearchQuery | BalanceSearchQuery[]) => Balances;
+    /**
+     * Filters this collection to exclude token balances where the token has a `mirrorOf` field
+     * and another balance exists in this collection for the token specified by the `mirrorOf` field.
+     */
+    filterMirrorTokens: () => Balances;
+    /**
+     * Filters this collection to only include balances which are not zero.
+     */
+    filterNonZero: (type: "total" | "free" | "reserved" | "locked" | "frozen" | "transferable" | "feePayable") => Balances;
+    /**
+     * Filters this collection to only include balances which are not zero AND have a fiat conversion rate.
+     */
+    filterNonZeroFiat: (type: "total" | "free" | "reserved" | "locked" | "frozen" | "transferable" | "feePayable", currency: TokenRateCurrency) => Balances;
     /**
      * Add some balances to this collection.
      * Added balances take priority over existing balances.
@@ -80,6 +93,7 @@ export declare class Balances {
      * @returns The new collection of balances.
      */
     remove: (ids: string[] | string) => Balances;
+    get each(): Balance[];
     /**
      * Get an array of balances in this collection, sorted by chain sortIndex.
      *
@@ -133,9 +147,21 @@ export declare class Balance {
     get free(): BalanceFormatter;
     /** The reserved balance of this token. Is included in the total. */
     get reserved(): BalanceFormatter;
+    get reserves(): {
+        amount: BalanceFormatter;
+        label: string;
+        meta?: unknown;
+    }[];
     /** The frozen balance of this token. Is included in the free amount. */
     get locked(): BalanceFormatter;
-    /** @depreacted - use balance.locked */
+    get locks(): {
+        amount: BalanceFormatter;
+        label: string;
+        meta?: unknown;
+        includeInTransferable?: boolean | undefined;
+        excludeFromFeePayable?: boolean | undefined;
+    }[];
+    /** @deprecated Use balance.locked */
     get frozen(): BalanceFormatter;
     /** The transferable balance of this token. Is generally the free amount - the miscFrozen amount. */
     get transferable(): BalanceFormatter;
@@ -150,6 +176,26 @@ export declare class BalanceFormatter {
     get tokens(): string;
     fiat(currency: TokenRateCurrency): number | null;
 }
+export declare class PlanckSumBalancesFormatter {
+    #private;
+    constructor(balances: Balances);
+    /**
+     * The total balance of these tokens. Includes the free and the reserved amount.
+     */
+    get total(): bigint;
+    /** The non-reserved balance of these tokens. Includes the frozen amount. Is included in the total. */
+    get free(): bigint;
+    /** The reserved balance of these tokens. Is included in the total. */
+    get reserved(): bigint;
+    /** The frozen balance of these tokens. Is included in the free amount. */
+    get locked(): bigint;
+    /** @deprecated Use balances.locked */
+    get frozen(): bigint;
+    /** The transferable balance of these tokens. Is generally the free amount - the miscFrozen amount. */
+    get transferable(): bigint;
+    /** The feePayable balance of these tokens. Is generally the free amount - the feeFrozen amount. */
+    get feePayable(): bigint;
+}
 export declare class FiatSumBalancesFormatter {
     #private;
     constructor(balances: Balances, currency: TokenRateCurrency);
@@ -163,7 +209,7 @@ export declare class FiatSumBalancesFormatter {
     get reserved(): number;
     /** The frozen balance of these tokens. Is included in the free amount. */
     get locked(): number;
-    /** @deprecated - use balances.locked */
+    /** @deprecated Use balances.locked */
     get frozen(): number;
     /** The transferable balance of these tokens. Is generally the free amount - the miscFrozen amount. */
     get transferable(): number;
@@ -173,5 +219,6 @@ export declare class FiatSumBalancesFormatter {
 export declare class SumBalancesFormatter {
     #private;
     constructor(balances: Balances);
+    get planck(): PlanckSumBalancesFormatter;
     fiat(currency: TokenRateCurrency): FiatSumBalancesFormatter;
 }

package/dist/declarations/src/types/balancetypes.d.ts

@@ -23,11 +23,18 @@ export type BalanceTypes = {
 export type BalanceJson = BalanceTypes[keyof BalanceTypes] extends never ? IBalance : BalanceTypes[keyof BalanceTypes];
 /** A collection of `BalanceJson` objects */
 export type BalanceJsonList = Record<string, BalanceJson>;
-export type BalanceStatus = "live" | "cache";
+export type BalanceStatusLive = `live-${string}`;
+export declare const BalanceStatusLive: (subscriptionId: string) => BalanceStatusLive;
+export type BalanceStatus = BalanceStatusLive | "live" | "cache" | "stale";
 /** `IBalance` is a common interface which all balance types must implement. */
 export type IBalance = {
     /** The module that this balance was retrieved by */
     source: string;
+    /**
+     * For modules which fetch balances via module sources, this is the sub-source
+     * e.g. `staking` or `crowdloans`
+     **/
+    subSource?: string;
     /** Has this balance never been fetched, or is it from a cache, or is it up to date? */
     status: BalanceStatus;
     /** The address of the account which owns this balance */
@@ -57,6 +64,7 @@ export type Amount = string;
 export type AmountWithLabel<TLabel extends string> = {
     label: TLabel;
     amount: Amount;
+    meta?: unknown;
 };
 /** A labelled locked amount of a balance */
 export type LockedAmount<TLabel extends string> = AmountWithLabel<TLabel> & {