@talismn/balances 0.0.0-pr2068-20250630052217 → 0.0.0-pr2075-20250707031602

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

@@ -0,0 +1,99 @@
+export declare const NEW_BALANCE_MODULES: (import("./modules/IBalanceModule").IBalanceModule<"substrate-native", {
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, import("./modules/substrate-native/config").ModuleConfig, import("./modules/substrate-native/config").MiniMetadataExtra> | import("./modules/IBalanceModule").IBalanceModule<"substrate-assets", {
+    assetId: string;
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown> | import("./modules/IBalanceModule").IBalanceModule<"substrate-hydration", {
+    onChainId: number;
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown> | import("./modules/IBalanceModule").IBalanceModule<"substrate-foreignassets", {
+    onChainId: string;
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown> | import("./modules/IBalanceModule").IBalanceModule<"substrate-psp22", {
+    contractAddress: string;
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown> | import("./modules/IBalanceModule").IBalanceModule<"substrate-tokens", {
+    symbol: string;
+    decimals: number;
+    existentialDeposit: string;
+    onChainId: string | number;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, import("./modules/substrate-tokens/config").ModuleConfig, import("./modules/substrate-tokens/config").MiniMetadataExtra> | import("./modules/IBalanceModule").IBalanceModule<"evm-erc20", {
+    contractAddress: `0x${string}`;
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown> | import("./modules/IBalanceModule").IBalanceModule<"evm-uniswapv2", {
+    contractAddress: `0x${string}`;
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown> | import("./modules/IBalanceModule").IBalanceModule<"evm-native", {
+    symbol?: string | undefined;
+    networkId?: string | undefined;
+    isDefault?: boolean | undefined;
+    decimals?: number | undefined;
+    name?: string | undefined;
+    logo?: string | undefined;
+    coingeckoId?: string | undefined;
+    noDiscovery?: boolean | undefined;
+    mirrorOf?: string | undefined;
+}, unknown, unknown>)[];

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,6 @@
 export * from "./BalanceModule";
-export * from "./EvmTokenFetcher";
-export * from "./MiniMetadataUpdater";
 export * from "./TalismanBalancesDatabase";
 export * from "./modules";
 export * from "./types";
-export * from "./util";
+export * from "./NewBalanceModules";
+export * from "./version";

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 { erc20Abi } from "viem";
+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/IBalanceModule.d.ts

@@ -0,0 +1,100 @@
+import type { Address, IBalance } from "@talismn/balances";
+import type { ChainConnector } from "@talismn/chain-connector";
+import type { ChainConnectorEvm } from "@talismn/chain-connector-evm";
+import { AnyMiniMetadata, DotNetworkId, EthNetworkId, Token, TokenId, TokenOfType, TokenType } from "@talismn/chaindata-provider";
+import { Observable } from "rxjs";
+/**
+ * Changes:
+ * - each method is standalone
+ * - decoupled from chaindataProvider (which uses indexedDB so cant be used in node)
+ * - all methods are network specific: this way they can return without waiting on other networks, while still being able to group multiple fetchs in one query
+ * - connector is passed as a parameter on every method that needs one, so that an evm module doesnt need a substrate connector, and also to allow using a module without connector
+ * - miniMetadatas are be fully typed
+ * - TokenConfig would be made much simpler
+ * - the logic about what data to fetch and cache (ex: erc20 symbols/decimals) would be here, where it belongs
+ */
+export type PlatformOf<T extends TokenType> = TokenOfType<T>["platform"];
+export type ConnectorOf<P extends PlatformOf<TokenType>> = P extends "ethereum" ? ChainConnectorEvm : P extends "polkadot" ? ChainConnector : never;
+type DotTransferCallData = {
+    address: string;
+    method: `0x${string}`;
+};
+type EthTransferCallData = {
+    from: string;
+    to: string;
+    data: `0x${string}`;
+    value?: string;
+};
+export type BalanceTransferType = "keep-alive" | "all" | "allow-death";
+type CallDataOf<P extends PlatformOf<TokenType>> = P extends "ethereum" ? EthTransferCallData : P extends "polkadot" ? DotTransferCallData : never;
+export type TokensWithAddresses = Array<[Token, Address[]]>;
+export type FetchBalanceErrors = Array<{
+    tokenId: TokenId;
+    address: Address;
+    error: Error;
+}>;
+export type FetchBalanceResults = {
+    success: IBalance[];
+    errors: FetchBalanceErrors;
+};
+type MiniMetadata<Extra = null> = Omit<AnyMiniMetadata, "extra"> & {
+    extra: Extra;
+};
+export interface IBalanceModule<Type extends TokenType, TokenConfig = unknown, ModuleConfig = unknown, MiniMetadataExtra = unknown> {
+    type: Type;
+    platform: PlatformOf<Type>;
+    getMiniMetadata: (arg: PlatformOf<Type> extends "polkadot" ? {
+        networkId: string;
+        specVersion: number;
+        metadataRpc: `0x${string}`;
+        config?: ModuleConfig;
+    } : never) => PlatformOf<Type> extends "polkadot" ? MiniMetadata<MiniMetadataExtra> : never;
+    fetchTokens: (arg: PlatformOf<Type> extends "polkadot" ? {
+        networkId: DotNetworkId;
+        tokens: TokenConfig[];
+        connector: ChainConnector;
+        miniMetadata: MiniMetadata<MiniMetadataExtra>;
+        cache: Record<TokenId, unknown>;
+    } : PlatformOf<Type> extends "ethereum" ? {
+        networkId: EthNetworkId;
+        tokens: TokenConfig[];
+        connector: ChainConnectorEvm;
+        cache: Record<TokenId, unknown>;
+    } : never) => Promise<TokenOfType<Type>[]>;
+    fetchBalances: (arg: PlatformOf<Type> extends "polkadot" ? {
+        networkId: DotNetworkId;
+        addressesByToken: TokensWithAddresses;
+        connector: ChainConnector;
+        miniMetadata: MiniMetadata<MiniMetadataExtra>;
+    } : PlatformOf<Type> extends "ethereum" ? {
+        networkId: EthNetworkId;
+        addressesByToken: TokensWithAddresses;
+        connector: ChainConnectorEvm;
+    } : never) => Promise<FetchBalanceResults>;
+    subscribeBalances: (arg: PlatformOf<Type> extends "polkadot" ? {
+        networkId: DotNetworkId;
+        addressesByToken: TokensWithAddresses;
+        connector: ChainConnector;
+        miniMetadata: MiniMetadata<MiniMetadataExtra>;
+    } : PlatformOf<Type> extends "ethereum" ? {
+        networkId: EthNetworkId;
+        addressesByToken: TokensWithAddresses;
+        connector: ChainConnectorEvm;
+    } : never) => Observable<FetchBalanceResults>;
+    getTransferCallData: (arg: PlatformOf<Type> extends "polkadot" ? {
+        from: string;
+        to: string;
+        value: string;
+        token: Token;
+        metadataRpc: `0x${string}`;
+        type: BalanceTransferType;
+        connector: ChainConnector;
+        config?: ModuleConfig;
+    } : PlatformOf<Type> extends "ethereum" ? {
+        from: string;
+        to: string;
+        value: string;
+        token: Token;
+    } : never) => CallDataOf<PlatformOf<Type>> | Promise<CallDataOf<PlatformOf<Type>>>;
+}
+export {};

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>;