@talismn/balances 0.6.0 → 0.7.0

package/README.md

@@ -1 +1,123 @@
 # @talismn/balances
+
+<img src="talisman.svg" alt="Talisman" width="15%" align="right" />
+
+[![license](https://img.shields.io/github/license/talismansociety/talisman?style=flat-square)](https://github.com/TalismanSociety/talisman/blob/dev/LICENSE)
+[![npm-version](https://img.shields.io/npm/v/@talismn/balances?style=flat-square)](https://www.npmjs.com/package/@talismn/balances)
+[![npm-downloads](https://img.shields.io/npm/dw/@talismn/balances?style=flat-square)](https://www.npmjs.com/package/@talismn/balances)
+
+**@talismn/balances** is the core of a set of packages used to subscribe to on-chain account token balances.
+
+A quick rundown on each package is given below.
+
+### This (the core) package:
+
+**@talismn/balances** (this package) includes:
+
+- An API which wallets / dapps can use to access balances
+- An interface for balance modules to implement
+- A shared database (powered by dexie) for balance modules to store balances in
+- Helpers (utility functions) for balance modules to use
+- Provides a plugin architecture, which is used by the balance module packages to specify their balance types
+
+### The react API for wallets & dapps:
+
+**@talismn/balances-react** includes:
+
+- React hooks for subscribing to on-chain account token balances
+- (soon™): recoil atoms for on-chain account token balances
+
+### The balance modules:
+
+**@talismn/balances-default-modules**
+
+- Collates the default balance modules (which can be found below) into a single package
+
+**@talismn/substrate-native**
+
+- A balance module for substrate native tokens
+- Subscribes to the `system.account` state query balance for each token
+- Also subscribes to the crowdloans pallet balances
+- Also subscribes to the nompools pallet balances
+
+**@talismn/substrate-orml**
+
+- A proof-of-concept balance module for ORML token pallet tokens
+- Attempts to auto-detect tokens
+- **You should use @talismn/substrate-tokens instead**
+
+**@talismn/substrate-tokens**
+
+- A balance module for substrate ORML token pallet tokens
+- Supports any token which can be queried via the `tokens.accounts` state query
+- Requires configuration for each token (no auto-detection)
+- We recommend that you use this module for ORML tokens
+
+**@talismn/substrate-assets**
+
+- A balance module for substrate assets pallet tokens
+- Supports any token which can be queried via the `assets.account` state query
+- Requires configuration for each token (no auto-detection)
+
+**@talismn/substrate-equilibrium**
+
+- A balance module for substrate eqBalances pallet tokens
+- Used by [Equilibrium](https://equilibrium.io/) and [Genshiro](https://genshiro.io/)
+- Supports auto-detection
+
+**@talismn/evm-native**
+
+- A balance module for evm native tokens
+
+**@talismn/evm-erc20**
+
+- A balance module for evm erc20 tokens
+
+### The chain connectors:
+
+**@talismn/chain-connector**
+
+- A package which manages the open RPC connections to substrate chains
+- Allows developers to say "Send this query to the chain with this id", without them needing to specify which RPCs to use
+- Ensures that connections are only opened to the chains which are in use by the wallet/dapp
+- Ensures that only one connection is open per chain
+- Handles exponential backoff in the case of network failures
+- Provides an interface which can be shared between a serviceworker and frontend, which enables the two to share the pool of open connections
+- Provides an interface which mimics a polkadot-js `WsProvider`, which can be plugged into polkadot-js to make it use the shared pool of open connections
+
+**@talismn/chain-connector-evm**
+
+- A package which manages the connections to evm chains
+- Allows developers to say "Send this query to the chain with this id", without them needing to specify which RPC to use
+
+### The chaindata provider:
+
+**@talismn/chaindata-provider**
+
+- A database (powered by dexie) to store chains, evm chains and tokens in
+- An interface to interact with the database
+- Syncs with the list in the [chaindata repository](https://github.com/talismansociety/chaindata) via graphql
+- Supports custom (end-user-defined) chains and rpc overrides
+- Provides a plugin architecture, which is used by the balance module packages to specify their token types
+
+### The remaining packages:
+
+**@talismn/connection-meta**
+
+- Contains a small db which is used to optimise network performance in the wallet.
+- Two metrics are kept:
+  - chainPriorityRpc (the last known well-behaved RPC for a chain)
+  - chainBackoffInterval (the amount of time the wallet should wait before attempting to connect to a unreachable chain again)
+
+**@talismn/mutate-metadata**
+
+- A package which can splice a chain's metadata into smaller pieces
+- Enables us to make state queries across many chains at once without using all of the browser's memory
+
+**@talismn/token-rates**
+
+- Fetches and stores coingecko rates for each token in the @talismn/chaindata-provider database
+
+**@talismn/util**
+
+- Utility functions shared by the other packages, as well as the wallet and the portal

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

@@ -1,10 +1,12 @@
-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 type ExtendableTokenType = IToken;
+import { ChaindataProvider, ChainId, Token } from "@talismn/chaindata-provider";
+import { AddressesByToken, BalanceJson, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
+export type BalancesCommonTransferMethods = "transfer_keep_alive" | "transfer_all";
+export type BalancesTransferMethods = "transfer_allow_death" | BalancesCommonTransferMethods;
+export type BalancesLegacyTransferMethods = "transfer" | BalancesCommonTransferMethods;
+export type BalancesAllTransferMethods = BalancesLegacyTransferMethods | BalancesTransferMethods;
+export type SelectableTokenType = Token;
 export type ExtendableChainMeta = Record<string, unknown> | undefined;
 export type DefaultChainMeta = undefined;
 export type ExtendableModuleConfig = Record<string, unknown> | undefined;
@@ -14,16 +16,15 @@ export type BaseTransferParams = {
     from: string;
     to: string;
     amount: string;
+    transferMethod: BalancesAllTransferMethods;
+    metadataRpc: `0x${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;
+    callData: string;
 };
 export type ChainConnectors = {
     substrate?: ChainConnector;
@@ -33,30 +34,37 @@ 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 type NewBalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, 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 SelectableTokenType, 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> {
+export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends SelectableTokenType, 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 SelectableTokenType, 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(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
+    fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig, metadataRpc?: `0x${string}`, systemProperties?: Record<string, any>): Promise<TChainMeta | null>;
     /** Detects which tokens are available on a given substrate chain */
     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, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
+interface BalanceModuleEvm<TModuleType extends string, TTokenType extends SelectableTokenType, 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(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
     /** Detects which tokens are available on a given evm chain */
     fetchEvmChainTokens(chainId: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-interface BalanceModuleCommon<TModuleType extends string, TTokenType extends ExtendableTokenType, TTransferParams extends ExtendableTransferParams> {
+export type SubscriptionResultWithStatus = {
+    status: "initialising" | "live";
+    data: BalanceJson[];
+};
+interface BalanceModuleCommon<TModuleType extends string, TTokenType extends SelectableTokenType, 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(addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
+    subscribeBalances({ addressesByToken, initialBalances, }: {
+        addressesByToken: AddressesByToken<TTokenType>;
+        initialBalances?: BalanceJson[];
+    }, callback: SubscriptionCallback<Balances | SubscriptionResultWithStatus>): Promise<UnsubscribeFn>;
     /** Fetch balances for this module with optional filtering */
     fetchBalances(addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
     /** Prepare a tx to transfer some tokens from this module */

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

@@ -0,0 +1,11 @@
+import { ChaindataProvider, EvmNetworkId } from "@talismn/chaindata-provider";
+import { AnyBalanceModule } from "./modules/util";
+/**
+ * Fetches tokens for EVM networks.
+ */
+export declare class EvmTokenFetcher {
+    #private;
+    constructor(chaindataProvider: ChaindataProvider, balanceModules: Array<AnyBalanceModule>);
+    update(evmNetworkIds: EvmNetworkId[]): Promise<void>;
+    private updateEvmNetworks;
+}

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

@@ -0,0 +1,43 @@
+import { Chain, ChaindataProvider, ChainId } from "@talismn/chaindata-provider";
+import { ChainConnectors } from "./BalanceModule";
+import { AnyBalanceModule } from "./modules/util";
+import { MiniMetadata, MiniMetadataStatus } from "./types";
+/**
+ * A substrate dapp needs access to a set of types when it wants to communicate with a blockchain node.
+ *
+ * These types are used to encode requests & decode responses via the SCALE codec.
+ * Each chain generally has its own set of types.
+ *
+ * Substrate provides a construct to retrieve these types from a blockchain node.
+ * The chain metadata.
+ *
+ * The metadata includes the types required for any communication with the chain,
+ * including lots of methods which are not relevant to balance fetching.
+ *
+ * As such, the metadata can clock in at around 1-2MB per chain, which is a lot of storage
+ * for browser-based dapps which want to connect to lots of chains.
+ *
+ * By utilizing the wonderful [scale-ts](https://github.com/unstoppablejs/unstoppablejs/tree/main/packages/scale-ts#readme) library,
+ * we can trim the chain metadata down so that it only includes the types we need for balance fetching.
+ *
+ * Each balance module has a function to do just that, `BalanceModule::fetchSubstrateChainMeta`.
+ *
+ * But, we only want to run this operation when necessary.
+ *
+ * The purpose of this class, `MiniMetadataUpdater`, is to maintain a local cache of
+ * trimmed-down metadatas, which we'll refer to as `MiniMetadatas`.
+ */
+export declare class MiniMetadataUpdater {
+    #private;
+    constructor(chainConnectors: ChainConnectors, chaindataProvider: ChaindataProvider, balanceModules: Array<AnyBalanceModule>);
+    /** Subscribe to the metadata for a chain */
+    subscribe(chainId: ChainId): import("rxjs").Observable<MiniMetadata>;
+    update(chainIds: ChainId[]): Promise<void>;
+    statuses(chains: Array<Pick<Chain, "id" | "specName" | "specVersion" | "balancesConfig">>): Promise<{
+        wantedIdsByChain: Map<string, string[]>;
+        statusesByChain: Map<string, MiniMetadataStatus>;
+    }>;
+    hydrateFromChaindata(): Promise<boolean>;
+    hydrateCustomChains(): Promise<boolean>;
+    private updateSubstrateChains;
+}

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

@@ -1,7 +1,11 @@
 import { Dexie } from "dexie";
-import { BalanceJson } from "./types";
+import { MiniMetadata } from "./types";
 export declare class TalismanBalancesDatabase extends Dexie {
-    balances: Dexie.Table<BalanceJson, string>;
+    balancesBlob: Dexie.Table<{
+        data: Uint8Array;
+        id: string;
+    }, string>;
+    miniMetadatas: Dexie.Table<MiniMetadata, string>;
     constructor();
 }
 export declare const db: TalismanBalancesDatabase;

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

@@ -1,4 +1,7 @@
 export * from "./BalanceModule";
+export * from "./EvmTokenFetcher";
+export * from "./MiniMetadataUpdater";
 export * from "./TalismanBalancesDatabase";
-export * from "./helpers";
+export * from "./modules";
 export * from "./types";
+export * from "./util";

package/dist/declarations/src/modules/EvmErc20Module.d.ts

@@ -0,0 +1,33 @@
+import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule } from "../BalanceModule";
+import { NewBalanceType } from "../types";
+import { erc20Abi } from "./abis/erc20";
+import { erc20BalancesAggregatorAbi } from "./abis/erc20BalancesAggregator";
+export { erc20Abi, erc20BalancesAggregatorAbi };
+type ModuleType = "evm-erc20";
+export type EvmErc20Token = Extract<Token, {
+    type: ModuleType;
+    isCustom?: true;
+}>;
+export type CustomEvmErc20Token = Extract<Token, {
+    type: ModuleType;
+    isCustom: true;
+}>;
+export declare const evmErc20TokenId: (chainId: EvmNetworkId, tokenContractAddress: EvmErc20Token["contractAddress"]) => string;
+export type EvmErc20ChainMeta = {
+    isTestnet: boolean;
+};
+export type EvmErc20ModuleConfig = {
+    tokens?: Array<{
+        symbol?: string;
+        decimals?: number;
+        contractAddress?: string;
+    } & BalancesConfigTokenParams>;
+};
+export type EvmErc20Balance = NewBalanceType<ModuleType, "simple", "ethereum">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "evm-erc20": EvmErc20Balance;
+    }
+}
+export declare const EvmErc20Module: NewBalanceModule<ModuleType, EvmErc20Token | CustomEvmErc20Token, EvmErc20ChainMeta, EvmErc20ModuleConfig>;

package/dist/declarations/src/modules/EvmNativeModule.d.ts

@@ -0,0 +1,26 @@
+import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule } from "../BalanceModule";
+import { NewBalanceType } from "../types";
+type ModuleType = "evm-native";
+export type EvmNativeToken = Extract<Token, {
+    type: ModuleType;
+}>;
+export type CustomEvmNativeToken = Extract<Token, {
+    type: ModuleType;
+}>;
+export declare const evmNativeTokenId: (chainId: EvmNetworkId) => string;
+export type EvmNativeChainMeta = {
+    isTestnet: boolean;
+};
+export type EvmNativeModuleConfig = {
+    symbol?: string;
+    decimals?: number;
+} & BalancesConfigTokenParams;
+export type EvmNativeBalance = NewBalanceType<ModuleType, "simple", "ethereum">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "evm-native": EvmNativeBalance;
+    }
+}
+export declare const EvmNativeModule: NewBalanceModule<ModuleType, EvmNativeToken | CustomEvmNativeToken, EvmNativeChainMeta, EvmNativeModuleConfig>;
+export {};

package/dist/declarations/src/modules/EvmUniswapV2Module.d.ts

@@ -0,0 +1,39 @@
+import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule } from "../BalanceModule";
+import { NewBalanceType } from "../types";
+import { uniswapV2PairAbi } from "./abis/uniswapV2Pair";
+export { uniswapV2PairAbi };
+type ModuleType = "evm-uniswapv2";
+export type EvmUniswapV2Token = Extract<Token, {
+    type: ModuleType;
+    isCustom?: true;
+}>;
+export type CustomEvmUniswapV2Token = Extract<Token, {
+    type: ModuleType;
+    isCustom: true;
+}>;
+export declare const evmUniswapV2TokenId: (chainId: EvmNetworkId, contractAddress: EvmUniswapV2Token["contractAddress"]) => string;
+export type EvmUniswapV2ChainMeta = {
+    isTestnet: boolean;
+};
+export type EvmUniswapV2ModuleConfig = {
+    pools?: Array<{
+        contractAddress?: string;
+        decimals?: number;
+        symbol0?: string;
+        symbol1?: string;
+        decimals0?: number;
+        decimals1?: number;
+        tokenAddress0?: string;
+        tokenAddress1?: string;
+        coingeckoId0?: string;
+        coingeckoId1?: string;
+    } & BalancesConfigTokenParams>;
+};
+export type EvmUniswapV2Balance = NewBalanceType<"evm-uniswapv2", "complex", "ethereum">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "evm-uniswapv2": EvmUniswapV2Balance;
+    }
+}
+export declare const EvmUniswapV2Module: NewBalanceModule<ModuleType, EvmUniswapV2Token | CustomEvmUniswapV2Token, EvmUniswapV2ChainMeta, EvmUniswapV2ModuleConfig>;

package/dist/declarations/src/modules/SubstrateAssetsModule.d.ts

@@ -0,0 +1,38 @@
+import { TypeRegistry } from "@polkadot/types";
+import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { NewBalanceType } from "../types";
+type ModuleType = "substrate-assets";
+export type SubAssetsToken = Extract<Token, {
+    type: ModuleType;
+}>;
+export declare const subAssetTokenId: (chainId: ChainId, assetId: string, tokenSymbol: string) => string;
+export type SubAssetsChainMeta = {
+    isTestnet: boolean;
+    miniMetadata?: string;
+    metadataVersion?: number;
+};
+export type SubAssetsModuleConfig = {
+    tokens?: Array<{
+        assetId: string | number;
+    } & BalancesConfigTokenParams>;
+};
+export type SubAssetsBalance = NewBalanceType<ModuleType, "complex", "substrate">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "substrate-assets": SubAssetsBalance;
+    }
+}
+export type SubAssetsTransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    userExtensions?: ExtDef;
+}>;
+export declare const SubAssetsModule: NewBalanceModule<ModuleType, SubAssetsToken, SubAssetsChainMeta, SubAssetsModuleConfig, SubAssetsTransferParams>;
+export {};

package/dist/declarations/src/modules/SubstrateEquilibriumModule.d.ts

@@ -0,0 +1,39 @@
+import { TypeRegistry } from "@polkadot/types";
+import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { NewBalanceType } from "../types";
+type ModuleType = "substrate-equilibrium";
+export type SubEquilibriumToken = Extract<Token, {
+    type: ModuleType;
+}>;
+export declare const subEquilibriumTokenId: (chainId: ChainId, tokenSymbol: string) => string;
+export type SubEquilibriumChainMeta = {
+    isTestnet: boolean;
+    miniMetadata?: string;
+    metadataVersion?: number;
+};
+export type SubEquilibriumModuleConfig = {
+    disable?: boolean;
+    tokens?: Array<{
+        assetId?: string;
+    } & BalancesConfigTokenParams>;
+};
+export type SubEquilibriumBalance = NewBalanceType<ModuleType, "simple", "substrate">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "substrate-equilibrium": SubEquilibriumBalance;
+    }
+}
+export type SubEquilibriumTransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    userExtensions?: ExtDef;
+}>;
+export declare const SubEquilibriumModule: NewBalanceModule<ModuleType, SubEquilibriumToken, SubEquilibriumChainMeta, SubEquilibriumModuleConfig, SubEquilibriumTransferParams>;
+export {};

package/dist/declarations/src/modules/SubstrateForeignAssetsModule.d.ts

@@ -0,0 +1,38 @@
+import { TypeRegistry } from "@polkadot/types";
+import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { NewBalanceType } from "../types";
+type ModuleType = "substrate-foreignassets";
+export type SubForeignAssetsToken = Extract<Token, {
+    type: ModuleType;
+}>;
+export declare const subForeignAssetTokenId: (chainId: ChainId, tokenSymbol: string) => string;
+export type SubForeignAssetsChainMeta = {
+    isTestnet: boolean;
+    miniMetadata?: string;
+    metadataVersion?: number;
+};
+export type SubForeignAssetsModuleConfig = {
+    tokens?: Array<{
+        onChainId: string;
+    } & BalancesConfigTokenParams>;
+};
+export type SubForeignAssetsBalance = NewBalanceType<ModuleType, "complex", "substrate">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "substrate-foreignassets": SubForeignAssetsBalance;
+    }
+}
+export type SubForeignAssetsTransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    userExtensions?: ExtDef;
+}>;
+export declare const SubForeignAssetsModule: NewBalanceModule<ModuleType, SubForeignAssetsToken, SubForeignAssetsChainMeta, SubForeignAssetsModuleConfig, SubForeignAssetsTransferParams>;
+export {};

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

@@ -0,0 +1,7 @@
+import { NewBalanceModule } from "../../BalanceModule";
+import { CustomSubNativeToken, ModuleType, SubNativeChainMeta, SubNativeModuleConfig, SubNativeToken, SubNativeTransferParams } from "./types";
+export { filterBaseLocks, getLockTitle } from "./util/balanceLockTypes";
+export type { BalanceLockType } from "./util/balanceLockTypes";
+export type { CustomSubNativeToken, ModuleType, SubNativeBalance, SubNativeChainMeta, SubNativeModuleConfig, SubNativeToken, SubNativeTransferParams, } from "./types";
+export { subNativeTokenId } from "./types";
+export declare const SubNativeModule: NewBalanceModule<ModuleType, SubNativeToken | CustomSubNativeToken, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams>;

package/dist/declarations/src/modules/SubstrateNativeModule/subscribeBase.d.ts

@@ -0,0 +1,5 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { SubscriptionCallback } from "../../types";
+import { RpcStateQuery } from "../util";
+import { SubNativeBalance } from "./types";
+export declare function subscribeBase(queries: RpcStateQuery<SubNativeBalance>[], chainConnector: ChainConnector, callback: SubscriptionCallback<SubNativeBalance[]>): Promise<import("../../types").UnsubscribeFn>;

package/dist/declarations/src/modules/SubstrateNativeModule/subscribeCrowdloans.d.ts

@@ -0,0 +1,5 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider } from "@talismn/chaindata-provider";
+import { AddressesByToken, SubscriptionCallback } from "../../types";
+import { CustomSubNativeToken, SubNativeBalance, SubNativeToken } from "./types";
+export declare function subscribeCrowdloans(chaindataProvider: ChaindataProvider, chainConnector: ChainConnector, addressesByToken: AddressesByToken<SubNativeToken | CustomSubNativeToken>, callback: SubscriptionCallback<SubNativeBalance[]>): Promise<() => void>;

package/dist/declarations/src/modules/SubstrateNativeModule/subscribeNompoolStaking.d.ts

@@ -0,0 +1,5 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider } from "@talismn/chaindata-provider";
+import { AddressesByToken, SubscriptionCallback } from "../../types";
+import { SubNativeBalance, SubNativeToken } from "./types";
+export declare function subscribeNompoolStaking(chaindataProvider: ChaindataProvider, chainConnector: ChainConnector, addressesByToken: AddressesByToken<SubNativeToken>, callback: SubscriptionCallback<SubNativeBalance[]>): Promise<() => void>;

package/dist/declarations/src/modules/SubstrateNativeModule/subscribeSubtensorStaking.d.ts

@@ -0,0 +1,5 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider } from "@talismn/chaindata-provider";
+import { AddressesByToken, SubscriptionCallback } from "../../types";
+import { SubNativeBalance, SubNativeToken } from "./types";
+export declare function subscribeSubtensorStaking(chaindataProvider: ChaindataProvider, chainConnector: ChainConnector, addressesByToken: AddressesByToken<SubNativeToken>, callback: SubscriptionCallback<SubNativeBalance[]>): Promise<() => void>;

package/dist/declarations/src/modules/SubstrateNativeModule/types.d.ts

@@ -0,0 +1,49 @@
+import { TypeRegistry } from "@polkadot/types";
+import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
+import { NewTransferParamsType } from "../../BalanceModule";
+import { NewBalanceType } from "../../types";
+export { filterBaseLocks, getLockTitle } from "./util/balanceLockTypes";
+export type { BalanceLockType } from "./util/balanceLockTypes";
+export type ModuleType = "substrate-native";
+export declare const moduleType: ModuleType;
+export type SubNativeToken = Extract<Token, {
+    type: ModuleType;
+    isCustom?: true;
+}>;
+export type CustomSubNativeToken = Extract<Token, {
+    type: ModuleType;
+    isCustom: true;
+}>;
+export declare const subNativeTokenId: (chainId: ChainId) => string;
+export type SubNativeChainMeta = {
+    isTestnet: boolean;
+    useLegacyTransferableCalculation?: boolean;
+    symbol?: string;
+    decimals?: number;
+    existentialDeposit?: string;
+    nominationPoolsPalletId?: string;
+    crowdloanPalletId?: string;
+    hasSubtensorPallet?: boolean;
+    miniMetadata?: string;
+    metadataVersion?: number;
+};
+export type SubNativeModuleConfig = {
+    disable?: boolean;
+} & BalancesConfigTokenParams;
+export type SubNativeBalance = NewBalanceType<ModuleType, "complex", "substrate">;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        "substrate-native": SubNativeBalance;
+    }
+}
+export type SubNativeTransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    userExtensions?: ExtDef;
+}>;

package/dist/declarations/src/modules/SubstrateNativeModule/util/QueryCache.d.ts

@@ -0,0 +1,13 @@
+import { ChaindataProvider } from "@talismn/chaindata-provider";
+import { AddressesByToken } from "../../../types";
+import { RpcStateQuery } from "../../util";
+import { SubNativeBalance, SubNativeToken } from "../types";
+export declare class QueryCache {
+    private chaindataProvider;
+    private balanceQueryCache;
+    private metadataSub;
+    constructor(chaindataProvider: ChaindataProvider);
+    ensureSetup(): void;
+    destroy(): void;
+    getQueries(addressesByToken: AddressesByToken<SubNativeToken>): Promise<RpcStateQuery<SubNativeBalance>[]>;
+}

package/dist/declarations/src/modules/SubstrateNativeModule/util/SubNativeBalanceError.d.ts

@@ -0,0 +1,5 @@
+export declare class SubNativeBalanceError extends Error {
+    #private;
+    constructor(tokenId: string, message: string);
+    get tokenId(): string;
+}

package/dist/declarations/src/modules/SubstrateNativeModule/util/asObservable.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from "rxjs";
+import { SubscriptionCallback, UnsubscribeFn } from "../../../types";
+/**
+ * Converts a subscription function into an Observable
+ *
+ * The type of a subscription function which can be converted into an observable:
+ *
+ *     <TArgs, TResult>(...arguments: TArgs, callback: SubscriptionCallback<TResult>) => UnsubscribeFn
+ */
+export declare const asObservable: <T extends unknown[], R>(handler: (...args: [...T, SubscriptionCallback<R>]) => UnsubscribeFn) => (...args: T) => Observable<R>;