@talismn/balances 0.0.0-pr2067-20250630033435 → 0.0.0-pr2075-20250703111149

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

@@ -1,16 +1,27 @@
 import { ChainConnector } from "@talismn/chain-connector";
 import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
-import { ChaindataProvider, ChainId, Token } from "@talismn/chaindata-provider";
+import { ChaindataProvider, DotNetworkId, EthNetworkId, 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 = Record<string, unknown> | undefined;
-export type DefaultChainMeta = undefined;
+export type ExtendableChainMeta = ChainMeta<Record<string, unknown> | null>;
+export type DefaultChainMeta = ChainMeta<null>;
 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;
@@ -34,21 +45,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, 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 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 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> {
+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> {
     /** Pre-processes any substrate chain metadata required by this module ahead of time */
-    fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig, metadataRpc?: `0x${string}`, systemProperties?: Record<string, any>): Promise<TChainMeta | null>;
+    fetchSubstrateChainMeta(chainId: DotNetworkId, moduleConfig?: TModuleConfig, metadataRpc?: `0x${string}`): 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>>;
+    fetchSubstrateChainTokens(chainId: DotNetworkId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig, tokens?: TTokenConfig[]): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-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> {
+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> {
     /** Pre-processes any evm chain metadata required by this module ahead of time */
-    fetchEvmChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
+    fetchEvmChainMeta(chainId: EthNetworkId, 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>>;
+    fetchEvmChainTokens(chainId: EthNetworkId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig, tokens?: TTokenConfig[]): Promise<Record<TTokenType["id"], TTokenType>>;
 }
 export type SubscriptionResultWithStatus = {
     status: "initialising" | "live";

package/dist/declarations/src/getMiniMetadata/getMetadataRpc.d.ts

@@ -0,0 +1,3 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { DotNetworkId } from "@talismn/chaindata-provider";
+export declare const getMetadataRpc: (chainConnector: ChainConnector, networkId: DotNetworkId) => Promise<`0x${string}`>;

package/dist/declarations/src/getMiniMetadata/getMiniMetadatas.d.ts

@@ -0,0 +1,4 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider, DotNetworkId } from "@talismn/chaindata-provider";
+import { MiniMetadata } from "../types";
+export declare const getMiniMetadatas: (chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, networkId: DotNetworkId, specVersion: number, signal?: AbortSignal) => Promise<MiniMetadata[]>;

package/dist/declarations/src/getMiniMetadata/getSpecVersion.d.ts

@@ -0,0 +1,6 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { DotNetworkId } from "@talismn/chaindata-provider";
+/**
+ * fetches the spec version of a network. current request is cached in case of multiple calls (all balance modules will kick in at once)
+ */
+export declare const getSpecVersion: (chainConnector: ChainConnector, networkId: DotNetworkId) => Promise<number>;

package/dist/declarations/src/getMiniMetadata/getUpdatedMiniMetadatas.d.ts

@@ -0,0 +1,4 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider, DotNetworkId } from "@talismn/chaindata-provider";
+import { MiniMetadata } from "../types";
+export declare const getUpdatedMiniMetadatas: (chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, chainId: DotNetworkId, specVersion: number, signal?: AbortSignal) => Promise<MiniMetadata[]>;

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

@@ -0,0 +1,5 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider, NetworkId as DotNetworkId } from "@talismn/chaindata-provider";
+import { AnyNewBalanceModule } from "../modules";
+import { MiniMetadata } from "../types";
+export declare const getMiniMetadata: <T extends AnyNewBalanceModule>(chaindataProvider: ChaindataProvider, chainConnector: ChainConnector, chainId: DotNetworkId, source: string, signal?: AbortSignal) => Promise<MiniMetadata<T>>;

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

@@ -1,7 +1,4 @@
 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/libVersion.d.ts

@@ -0,0 +1 @@
+export declare const libVersion: string;

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

@@ -1,33 +1,30 @@
-import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
-import { NewBalanceModule } from "../BalanceModule";
+import { EvmErc20Token } from "@talismn/chaindata-provider";
+import z from "zod/v4";
+import { DefaultChainMeta, DefaultModuleConfig, 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">;
+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">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
         "evm-erc20": EvmErc20Balance;
     }
 }
-export declare const EvmErc20Module: NewBalanceModule<ModuleType, EvmErc20Token | CustomEvmErc20Token, EvmErc20ChainMeta, EvmErc20ModuleConfig>;
+export declare const EvmErc20Module: NewBalanceModule<ModuleType, EvmErc20Token, EvmErc20ChainMeta, EvmErc20ModuleConfig, EvmErc20TokenConfig>;

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

@@ -1,26 +1,27 @@
-import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
-import { NewBalanceModule } from "../BalanceModule";
+import { EvmNativeToken } from "@talismn/chaindata-provider";
+import z from "zod/v4";
+import { DefaultChainMeta, DefaultModuleConfig, 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">;
+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>;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
         "evm-native": EvmNativeBalance;
     }
 }
-export declare const EvmNativeModule: NewBalanceModule<ModuleType, EvmNativeToken | CustomEvmNativeToken, EvmNativeChainMeta, EvmNativeModuleConfig>;
+export declare const EvmNativeModule: NewBalanceModule<ModuleType, EvmNativeToken, EvmNativeChainMeta, EvmNativeModuleConfig, EvmNativeTokenConfig>;
 export {};

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

@@ -1,39 +1,37 @@
-import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
-import { NewBalanceModule } from "../BalanceModule";
+import { EvmUniswapV2Token } from "@talismn/chaindata-provider";
+import z from "zod/v4";
+import { DefaultChainMeta, DefaultModuleConfig, 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">;
+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">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
         "evm-uniswapv2": EvmUniswapV2Balance;
     }
 }
-export declare const EvmUniswapV2Module: NewBalanceModule<ModuleType, EvmUniswapV2Token | CustomEvmUniswapV2Token, EvmUniswapV2ChainMeta, EvmUniswapV2ModuleConfig>;
+export declare const EvmUniswapV2Module: NewBalanceModule<ModuleType, EvmUniswapV2Token, EvmUniswapV2ChainMeta, EvmUniswapV2ModuleConfig, EvmUniswapV2TokenConfig>;

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

@@ -1,24 +1,26 @@
 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 { SubAssetsToken } from "@talismn/chaindata-provider";
+import z from "zod/v4";
+import { ChainMeta, DefaultModuleConfig, 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">;
+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">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
         "substrate-assets": SubAssetsBalance;
@@ -34,5 +36,5 @@ export type SubAssetsTransferParams = NewTransferParamsType<{
     tip?: string;
     userExtensions?: ExtDef;
 }>;
-export declare const SubAssetsModule: NewBalanceModule<ModuleType, SubAssetsToken, SubAssetsChainMeta, SubAssetsModuleConfig, SubAssetsTransferParams>;
+export declare const SubAssetsModule: NewBalanceModule<ModuleType, SubAssetsToken, SubAssetsChainMeta, SubAssetsModuleConfig, SubAssetsTokenConfig, SubAssetsTransferParams>;
 export {};

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

@@ -1,24 +1,26 @@
 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 { SubForeignAssetsToken } from "@talismn/chaindata-provider";
+import z from "zod/v4";
+import { DefaultChainMeta, DefaultModuleConfig, 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">;
+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">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
         "substrate-foreignassets": SubForeignAssetsBalance;
@@ -34,5 +36,5 @@ export type SubForeignAssetsTransferParams = NewTransferParamsType<{
     tip?: string;
     userExtensions?: ExtDef;
 }>;
-export declare const SubForeignAssetsModule: NewBalanceModule<ModuleType, SubForeignAssetsToken, SubForeignAssetsChainMeta, SubForeignAssetsModuleConfig, SubForeignAssetsTransferParams>;
+export declare const SubForeignAssetsModule: NewBalanceModule<ModuleType, SubForeignAssetsToken, SubForeignAssetsChainMeta, SubForeignAssetsModuleConfig, SubForeignAssetsTokenConfig, SubForeignAssetsTransferParams>;
 export {};

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

@@ -1,8 +1,21 @@
+import { SubNativeToken } from "@talismn/chaindata-provider";
+import z from "zod/v4";
 import { NewBalanceModule } from "../../BalanceModule";
-import { CustomSubNativeToken, ModuleType, SubNativeChainMeta, SubNativeModuleConfig, SubNativeToken, SubNativeTransferParams } from "./types";
+import { ModuleType, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams } from "./types";
 export { filterBaseLocks, getLockTitle } from "./util/balanceLockTypes";
 export type { BalanceLockType } from "./util/balanceLockTypes";
-export { subNativeTokenId } from "./types";
-export type { CustomSubNativeToken, ModuleType, SubNativeBalance, SubNativeChainMeta, SubNativeModuleConfig, SubNativeToken, SubNativeTransferParams, } from "./types";
+export type { ModuleType, SubNativeBalance, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams, } from "./types";
 export * from "./util/subtensor";
-export declare const SubNativeModule: NewBalanceModule<ModuleType, SubNativeToken | CustomSubNativeToken, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams>;
+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>;

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

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

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

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

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

@@ -1,37 +1,20 @@
 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 { SubNativeBalancesConfig } from "@talismn/chaindata-provider";
+import { ChainMeta, 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;
+export type SubNativeChainMeta = ChainMeta<{
     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">;
+} | null>;
+export type SubNativeModuleConfig = SubNativeBalancesConfig;
+export type SubNativeBalance = NewBalanceType<ModuleType, "complex">;
 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 { ChaindataProvider } from "@talismn/chaindata-provider";
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider, SubNativeToken } from "@talismn/chaindata-provider";
 import { AddressesByToken } from "../../../types";
 import { RpcStateQuery } from "../../util";
-import { SubNativeBalance, SubNativeToken } from "../types";
+import { SubNativeBalance } from "../types";
 export declare class QueryCache {
+    #private;
     private chaindataProvider;
+    private miniMetadatas;
     private balanceQueryCache;
-    private metadataSub;
-    constructor(chaindataProvider: ChaindataProvider);
-    ensureSetup(): void;
-    destroy(): void;
+    constructor(chaindataProvider: ChaindataProvider, chainConnector: ChainConnector);
     getQueries(addressesByToken: AddressesByToken<SubNativeToken>): Promise<RpcStateQuery<SubNativeBalance>[]>;
 }

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

@@ -1,13 +1,14 @@
-import { Chain, Token } from "@talismn/chaindata-provider";
+import { DotNetwork, DotNetworkId, SubNativeToken, Token } from "@talismn/chaindata-provider";
+import { SubNativeModule } from "..";
 import { AddressesByToken, MiniMetadata } from "../../../types";
 import { RpcStateQuery, StorageCoders } from "../../util";
-import { SubNativeBalance, SubNativeToken } from "../types";
+import { SubNativeBalance } from "../types";
 export type QueryKey = string;
-export declare function buildQueries(chains: Record<string, Chain>, tokens: Record<string, Token>, chainStorageCoders: StorageCoders<{
+export declare function buildQueries(chains: Record<string, DotNetwork>, 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<string, MiniMetadata>, addressesByToken: AddressesByToken<SubNativeToken>): Promise<Record<QueryKey, Array<RpcStateQuery<SubNativeBalance>>>>;
+}>, miniMetadatas: Map<DotNetworkId, MiniMetadata<typeof SubNativeModule>>, addressesByToken: AddressesByToken<SubNativeToken>): Promise<Record<QueryKey, Array<RpcStateQuery<SubNativeBalance>>>>;

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

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

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

@@ -0,0 +1,5 @@
+import { ChainConnector } from "@talismn/chain-connector";
+export declare const getChainProperties: (chainConnector: ChainConnector, networkId: string) => Promise<{
+    tokenDecimals: number;
+    tokenSymbol: string;
+}>;

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

@@ -1,25 +1,26 @@
 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 { SubPsp22Token } from "@talismn/chaindata-provider";
+import z from "zod/v4";
+import { DefaultChainMeta, DefaultModuleConfig, NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
 import { NewBalanceType } from "../types";
 type ModuleType = "substrate-psp22";
-export type SubPsp22Token = Extract<Token, {
-    type: ModuleType;
-}>;
-export declare const subPsp22TokenId: (chainId: ChainId, tokenSymbol: string) => string;
-export type SubPsp22ChainMeta = {
-    isTestnet: boolean;
-};
-export type SubPsp22ModuleConfig = {
-    tokens?: Array<{
-        symbol?: string;
-        decimals?: number;
-        ed?: string;
-        contractAddress?: string;
-    } & BalancesConfigTokenParams>;
-};
-export type SubPsp22Balance = NewBalanceType<ModuleType, "simple", "substrate">;
+export declare const SubPsp22TokenConfigSchema: 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.ZodString;
+}, z.core.$strict>;
+export type SubPsp22TokenConfig = z.infer<typeof SubPsp22TokenConfigSchema>;
+export type SubPsp22ChainMeta = DefaultChainMeta;
+export type SubPsp22ModuleConfig = DefaultModuleConfig;
+export type SubPsp22Balance = NewBalanceType<ModuleType, "simple">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
         "substrate-psp22": SubPsp22Balance;
@@ -35,5 +36,5 @@ export type SubPsp22TransferParams = NewTransferParamsType<{
     tip?: string;
     userExtensions?: ExtDef;
 }>;
-export declare const SubPsp22Module: NewBalanceModule<ModuleType, SubPsp22Token, SubPsp22ChainMeta, SubPsp22ModuleConfig, SubPsp22TransferParams>;
+export declare const SubPsp22Module: NewBalanceModule<ModuleType, SubPsp22Token, SubPsp22ChainMeta, SubPsp22ModuleConfig, SubPsp22TokenConfig, SubPsp22TransferParams>;
 export {};