@talismn/balances 0.0.0-pr2043-20250703063959 → 0.0.0-pr2059-20250626001054

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

@@ -1,27 +1,16 @@
 import { ChainConnector } from "@talismn/chain-connector";
 import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
-import { ChaindataProvider, DotNetworkId, EthNetworkId, Token } from "@talismn/chaindata-provider";
+import { ChaindataProvider, ChainId, Token } from "@talismn/chaindata-provider";
 import { AddressesByToken, BalanceJson, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
-export type ChainMeta<Extra extends Record<string, unknown> | null> = {
-    miniMetadata: `0x${string}` | null;
-    extra: Extra;
-};
-export type TokenConfig = object;
-export type BalancesConfig<ModConfig extends object | undefined, TokenConfig extends object | undefined> = {
-    config?: ModConfig;
-    tokens?: TokenConfig[];
-};
 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 = ChainMeta<Record<string, unknown> | null>;
-export type DefaultChainMeta = ChainMeta<null>;
+export type ExtendableChainMeta = Record<string, unknown> | undefined;
+export type DefaultChainMeta = undefined;
 export type ExtendableModuleConfig = Record<string, unknown> | undefined;
-export type ExtendableTokenConfig = Record<string, unknown> | undefined;
 export type DefaultModuleConfig = undefined;
-export type DefaultTokenConfig = undefined;
 export type BaseTransferParams = {
     tokenId: string;
     from: string;
@@ -45,21 +34,21 @@ export type Hydrate = {
     chainConnectors: ChainConnectors;
     chaindataProvider: ChaindataProvider;
 };
-export type NewBalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTokenConfig extends ExtendableTokenConfig = DefaultTokenConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> = (hydrate: Hydrate) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTokenConfig, TTransferParams>;
-export interface BalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTokenConfig extends ExtendableTokenConfig = DefaultTokenConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTokenConfig, TTransferParams>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTokenConfig, 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 SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTokenConfig extends ExtendableTokenConfig = DefaultTokenConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTokenConfig, TTransferParams>;
-interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta, TModuleConfig extends ExtendableModuleConfig, TTokenConfig extends ExtendableTokenConfig, TTransferParams extends ExtendableTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
+export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams>(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: DotNetworkId, moduleConfig?: TModuleConfig, metadataRpc?: `0x${string}`): 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: DotNetworkId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig, tokens?: TTokenConfig[]): Promise<Record<TTokenType["id"], TTokenType>>;
+    fetchSubstrateChainTokens(chainId: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-interface BalanceModuleEvm<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTokenConfig extends ExtendableTokenConfig = DefaultTokenConfig, 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: EthNetworkId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
+    fetchEvmChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
     /** Detects which tokens are available on a given evm chain */
-    fetchEvmChainTokens(chainId: EthNetworkId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig, tokens?: TTokenConfig[]): Promise<Record<TTokenType["id"], TTokenType>>;
+    fetchEvmChainTokens(chainId: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
 export type SubscriptionResultWithStatus = {
     status: "initialising" | "live";

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/index.d.ts

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

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

@@ -1,30 +1,33 @@
-import { EvmErc20Token } from "@talismn/chaindata-provider";
-import z from "zod/v4";
-import { DefaultChainMeta, DefaultModuleConfig, NewBalanceModule } from "../BalanceModule";
+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 EvmErc20ChainMeta = DefaultChainMeta;
-export type EvmErc20ModuleConfig = DefaultModuleConfig;
-export declare const EvmErc20TokenConfigSchema: z.ZodObject<{
-    symbol: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    decimals: z.ZodOptional<z.ZodInt>;
-    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    noDiscovery: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    mirrorOf: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    contractAddress: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-}, z.core.$strict>;
-export type EvmErc20TokenConfig = z.infer<typeof EvmErc20TokenConfigSchema>;
-export type EvmErc20Balance = NewBalanceType<ModuleType, "simple">;
+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, EvmErc20ChainMeta, EvmErc20ModuleConfig, EvmErc20TokenConfig>;
+export declare const EvmErc20Module: NewBalanceModule<ModuleType, EvmErc20Token | CustomEvmErc20Token, EvmErc20ChainMeta, EvmErc20ModuleConfig>;

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

@@ -1,27 +1,26 @@
-import { EvmNativeToken } from "@talismn/chaindata-provider";
-import z from "zod/v4";
-import { DefaultChainMeta, DefaultModuleConfig, NewBalanceModule } from "../BalanceModule";
+import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule } from "../BalanceModule";
 import { NewBalanceType } from "../types";
 type ModuleType = "evm-native";
-export type EvmNativeChainMeta = DefaultChainMeta;
-export type EvmNativeModuleConfig = DefaultModuleConfig;
-export type EvmNativeBalance = NewBalanceType<ModuleType, "simple">;
-export declare const EvmNativeTokenConfigSchema: z.ZodObject<{
-    symbol: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    decimals: z.ZodOptional<z.ZodInt>;
-    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    noDiscovery: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    mirrorOf: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-}, z.core.$strict>;
-export type EvmNativeTokenConfig = z.infer<typeof EvmNativeTokenConfigSchema>;
+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, EvmNativeChainMeta, EvmNativeModuleConfig, EvmNativeTokenConfig>;
+export declare const EvmNativeModule: NewBalanceModule<ModuleType, EvmNativeToken | CustomEvmNativeToken, EvmNativeChainMeta, EvmNativeModuleConfig>;
 export {};

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

@@ -1,37 +1,39 @@
-import { EvmUniswapV2Token } from "@talismn/chaindata-provider";
-import z from "zod/v4";
-import { DefaultChainMeta, DefaultModuleConfig, NewBalanceModule } from "../BalanceModule";
+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 EvmUniswapV2ChainMeta = DefaultChainMeta;
-export declare const EvmUniswapV2TokenConfigSchema: z.ZodObject<{
-    symbol0: z.ZodOptional<z.ZodString>;
-    symbol1: z.ZodOptional<z.ZodString>;
-    decimals0: z.ZodOptional<z.ZodInt>;
-    decimals1: z.ZodOptional<z.ZodInt>;
-    tokenAddress0: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
-    tokenAddress1: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
-    coingeckoId0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId1: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    symbol: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    decimals: z.ZodOptional<z.ZodInt>;
-    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    noDiscovery: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    mirrorOf: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    contractAddress: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-}, z.core.$strict>;
-export type EvmUniswapV2TokenConfig = z.infer<typeof EvmUniswapV2TokenConfigSchema>;
-export type EvmUniswapV2ModuleConfig = DefaultModuleConfig;
-export type EvmUniswapV2Balance = NewBalanceType<"evm-uniswapv2", "complex">;
+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, EvmUniswapV2ChainMeta, EvmUniswapV2ModuleConfig, EvmUniswapV2TokenConfig>;
+export declare const EvmUniswapV2Module: NewBalanceModule<ModuleType, EvmUniswapV2Token | CustomEvmUniswapV2Token, EvmUniswapV2ChainMeta, EvmUniswapV2ModuleConfig>;

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

@@ -1,26 +1,24 @@
 import { TypeRegistry } from "@polkadot/types";
 import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
-import { SubAssetsToken } from "@talismn/chaindata-provider";
-import z from "zod/v4";
-import { ChainMeta, DefaultModuleConfig, NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
 import { NewBalanceType } from "../types";
 type ModuleType = "substrate-assets";
-export type SubAssetsChainMeta = ChainMeta<null>;
-export declare const SubAssetsTokenConfigSchema: z.ZodObject<{
-    symbol: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    decimals: z.ZodOptional<z.ZodInt>;
-    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    noDiscovery: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    mirrorOf: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    assetId: z.ZodPipe<z.ZodUnion<readonly [z.ZodUInt32, z.ZodString]>, z.ZodTransform<string, string | number>>;
-}, z.core.$strict>;
-export type SubAssetsTokenConfig = z.infer<typeof SubAssetsTokenConfigSchema>;
-export type SubAssetsModuleConfig = DefaultModuleConfig;
-export type SubAssetsBalance = NewBalanceType<ModuleType, "complex">;
+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;
@@ -36,5 +34,5 @@ export type SubAssetsTransferParams = NewTransferParamsType<{
     tip?: string;
     userExtensions?: ExtDef;
 }>;
-export declare const SubAssetsModule: NewBalanceModule<ModuleType, SubAssetsToken, SubAssetsChainMeta, SubAssetsModuleConfig, SubAssetsTokenConfig, SubAssetsTransferParams>;
+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

@@ -1,26 +1,24 @@
 import { TypeRegistry } from "@polkadot/types";
 import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
-import { SubForeignAssetsToken } from "@talismn/chaindata-provider";
-import z from "zod/v4";
-import { DefaultChainMeta, DefaultModuleConfig, NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
 import { NewBalanceType } from "../types";
 type ModuleType = "substrate-foreignassets";
-export type SubForeignAssetsChainMeta = DefaultChainMeta;
-export declare const SubForeignAssetsTokenConfigSchema: z.ZodObject<{
-    symbol: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    decimals: z.ZodOptional<z.ZodInt>;
-    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    noDiscovery: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    mirrorOf: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    onChainId: z.ZodString;
-}, z.core.$strict>;
-export type SubForeignAssetsTokenConfig = z.infer<typeof SubForeignAssetsTokenConfigSchema>;
-export type SubForeignAssetsModuleConfig = DefaultModuleConfig;
-export type SubForeignAssetsBalance = NewBalanceType<ModuleType, "complex">;
+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;
@@ -36,5 +34,5 @@ export type SubForeignAssetsTransferParams = NewTransferParamsType<{
     tip?: string;
     userExtensions?: ExtDef;
 }>;
-export declare const SubForeignAssetsModule: NewBalanceModule<ModuleType, SubForeignAssetsToken, SubForeignAssetsChainMeta, SubForeignAssetsModuleConfig, SubForeignAssetsTokenConfig, SubForeignAssetsTransferParams>;
+export declare const SubForeignAssetsModule: NewBalanceModule<ModuleType, SubForeignAssetsToken, SubForeignAssetsChainMeta, SubForeignAssetsModuleConfig, SubForeignAssetsTransferParams>;
 export {};

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

@@ -1,21 +1,8 @@
-import { SubNativeToken } from "@talismn/chaindata-provider";
-import z from "zod/v4";
 import { NewBalanceModule } from "../../BalanceModule";
-import { ModuleType, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams } from "./types";
+import { CustomSubNativeToken, ModuleType, SubNativeChainMeta, SubNativeModuleConfig, SubNativeToken, SubNativeTransferParams } from "./types";
 export { filterBaseLocks, getLockTitle } from "./util/balanceLockTypes";
 export type { BalanceLockType } from "./util/balanceLockTypes";
-export type { ModuleType, SubNativeBalance, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams, } from "./types";
+export { subNativeTokenId } from "./types";
+export type { CustomSubNativeToken, ModuleType, SubNativeBalance, SubNativeChainMeta, SubNativeModuleConfig, SubNativeToken, SubNativeTransferParams, } from "./types";
 export * from "./util/subtensor";
-export declare const SubNativeTokenConfigSchema: z.ZodObject<{
-    symbol: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    decimals: z.ZodOptional<z.ZodInt>;
-    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    coingeckoId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    noDiscovery: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-    mirrorOf: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-}, z.core.$strict>;
-export type SubNativeTokenConfig = z.infer<typeof SubNativeTokenConfigSchema>;
-export declare const SubNativeModule: NewBalanceModule<ModuleType, SubNativeToken, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTokenConfig, SubNativeTransferParams>;
+export declare const SubNativeModule: NewBalanceModule<ModuleType, SubNativeToken | CustomSubNativeToken, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams>;

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

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

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

@@ -1,20 +1,37 @@
 import { TypeRegistry } from "@polkadot/types";
 import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
-import { SubNativeBalancesConfig } from "@talismn/chaindata-provider";
-import { ChainMeta, NewTransferParamsType } from "../../BalanceModule";
+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 SubNativeChainMeta = ChainMeta<{
+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;
-} | null>;
-export type SubNativeModuleConfig = SubNativeBalancesConfig;
-export type SubNativeBalance = NewBalanceType<ModuleType, "complex">;
+    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;

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

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

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

@@ -1,14 +1,13 @@
-import { DotNetwork, DotNetworkId, SubNativeToken, Token } from "@talismn/chaindata-provider";
-import { SubNativeModule } from "..";
+import { Chain, Token } from "@talismn/chaindata-provider";
 import { AddressesByToken, MiniMetadata } from "../../../types";
 import { RpcStateQuery, StorageCoders } from "../../util";
-import { SubNativeBalance } from "../types";
+import { SubNativeBalance, SubNativeToken } from "../types";
 export type QueryKey = string;
-export declare function buildQueries(chains: Record<string, DotNetwork>, tokens: Record<string, Token>, chainStorageCoders: StorageCoders<{
+export declare function buildQueries(chains: Record<string, Chain>, tokens: Record<string, Token>, chainStorageCoders: StorageCoders<{
     base: ["System", "Account"];
     stakingLedger: ["Staking", "Ledger"];
     reserves: ["Balances", "Reserves"];
     holds: ["Balances", "Holds"];
     locks: ["Balances", "Locks"];
     freezes: ["Balances", "Freezes"];
-}>, miniMetadatas: Map<DotNetworkId, MiniMetadata<typeof SubNativeModule>>, addressesByToken: AddressesByToken<SubNativeToken>): Promise<Record<QueryKey, Array<RpcStateQuery<SubNativeBalance>>>>;
+}>, miniMetadatas: Map<string, MiniMetadata>, addressesByToken: AddressesByToken<SubNativeToken>): Promise<Record<QueryKey, Array<RpcStateQuery<SubNativeBalance>>>>;

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

@@ -0,0 +1,4 @@
+/**
+ * Crowdloan contributions are stored in the `childstate` key returned by this function.
+ */
+export declare const crowdloanFundContributionsChildKey: (fundIndex: number) => `0x${string}`;

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

@@ -0,0 +1,2 @@
+import { MiniMetadata } from "../../../types";
+export declare const detectMiniMetadataChanges: () => import("rxjs").UnaryFunction<import("rxjs").Observable<Map<string, MiniMetadata>>, import("rxjs").Observable<Set<string>>>;

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

@@ -1 +1 @@
-export declare const sortChainsNativeTokensByPriority: (a: string, b: string) => 1 | 0 | -1;
+export declare const sortChains: (a: string, b: string) => 0 | 1 | -1;