@talismn/balances 0.6.1 → 0.7.1

package/README.md

@@ -5,7 +5,6 @@
 [![license](https://img.shields.io/github/license/talismansociety/talisman?style=flat-square)](https://github.com/TalismanSociety/talisman/blob/dev/LICENSE)
 [![npm-version](https://img.shields.io/npm/v/@talismn/balances?style=flat-square)](https://www.npmjs.com/package/@talismn/balances)
 [![npm-downloads](https://img.shields.io/npm/dw/@talismn/balances?style=flat-square)](https://www.npmjs.com/package/@talismn/balances)
-[![discord-link](https://img.shields.io/discord/858891448271634473?logo=discord&logoColor=white&style=flat-square)](https://discord.gg/talisman)
 
 **@talismn/balances** is the core of a set of packages used to subscribe to on-chain account token balances.
 
@@ -93,10 +92,7 @@ A quick rundown on each package is given below.
 
 ### The chaindata provider:
 
-Currently split into two packages because we initially intended to write several implementations of the chaindata interface.  
-Will be merged into one package soon™.
-
-**@talismn/chaindata-provider** and **@talismn/chaindata-provider-extension**
+**@talismn/chaindata-provider**
 
 - A database (powered by dexie) to store chains, evm chains and tokens in
 - An interface to interact with the database

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

@@ -1,9 +1,12 @@
-import { UnsignedTransaction } from "@substrate/txwrapper-core";
 import { ChainConnector } from "@talismn/chain-connector";
 import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
-import { ChainId, ChaindataProvider, IToken } from "@talismn/chaindata-provider";
-import { Address, AddressesByToken, BalanceJson, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
-export type ExtendableTokenType = IToken;
+import { ChaindataProvider, ChainId, Token } from "@talismn/chaindata-provider";
+import { AddressesByToken, BalanceJson, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
+export type BalancesCommonTransferMethods = "transfer_keep_alive" | "transfer_all";
+export type BalancesTransferMethods = "transfer_allow_death" | BalancesCommonTransferMethods;
+export type BalancesLegacyTransferMethods = "transfer" | BalancesCommonTransferMethods;
+export type BalancesAllTransferMethods = BalancesLegacyTransferMethods | BalancesTransferMethods;
+export type SelectableTokenType = Token;
 export type ExtendableChainMeta = Record<string, unknown> | undefined;
 export type DefaultChainMeta = undefined;
 export type ExtendableModuleConfig = Record<string, unknown> | undefined;
@@ -13,13 +16,15 @@ export type BaseTransferParams = {
     from: string;
     to: string;
     amount: string;
+    transferMethod: BalancesAllTransferMethods;
+    metadataRpc: `0x${string}`;
 };
 export type ExtendableTransferParams = BaseTransferParams | undefined;
 export type DefaultTransferParams = undefined;
 export type NewTransferParamsType<T extends Record<string, unknown>> = BaseTransferParams & T;
 export type TransferTokenTx = {
     type: "substrate";
-    tx: UnsignedTransaction;
+    callData: string;
 };
 export type ChainConnectors = {
     substrate?: ChainConnector;
@@ -29,32 +34,37 @@ export type Hydrate = {
     chainConnectors: ChainConnectors;
     chaindataProvider: ChaindataProvider;
 };
-export type NewBalanceModule<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> = (hydrate: Hydrate) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
-export interface BalanceModule<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams> {
+export type NewBalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> = (hydrate: Hydrate) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
+export interface BalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams> {
 }
-export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends IToken, TChainMeta extends ExtendableChainMeta = undefined, TModuleConfig extends ExtendableModuleConfig = undefined, TTransferParams extends ExtendableTransferParams = undefined>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
-interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
+export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = undefined, TModuleConfig extends ExtendableModuleConfig = undefined, TTransferParams extends ExtendableTransferParams = undefined>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
+interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
     /** Pre-processes any substrate chain metadata required by this module ahead of time */
-    fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig, 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: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-interface BalanceModuleEvm<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
+interface BalanceModuleEvm<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
     /** Pre-processes any evm chain metadata required by this module ahead of time */
     fetchEvmChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
     /** Detects which tokens are available on a given evm chain */
     fetchEvmChainTokens(chainId: ChainId, chainMeta: TChainMeta, moduleConfig?: TModuleConfig): Promise<Record<TTokenType["id"], TTokenType>>;
 }
-interface BalanceModuleCommon<TModuleType extends string, TTokenType extends ExtendableTokenType, TTransferParams extends ExtendableTransferParams> {
+export type SubscriptionResultWithStatus = {
+    status: "initialising" | "live";
+    data: BalanceJson[];
+};
+interface BalanceModuleCommon<TModuleType extends string, TTokenType extends SelectableTokenType, TTransferParams extends ExtendableTransferParams> {
     get type(): TModuleType;
     /**
      * Subscribe to balances for this module with optional filtering.
      *
      * If subscriptions are not possible, this function should poll at some reasonable interval.
      */
-    subscribeBalances(addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
-    /** Used to provision balances in db while they are fetching for the first time */
-    getPlaceholderBalance(tokenId: TTokenType["id"], address: Address): BalanceJson;
+    subscribeBalances({ addressesByToken, initialBalances, }: {
+        addressesByToken: AddressesByToken<TTokenType>;
+        initialBalances?: BalanceJson[];
+    }, callback: SubscriptionCallback<Balances | SubscriptionResultWithStatus>): Promise<UnsubscribeFn>;
     /** Fetch balances for this module with optional filtering */
     fetchBalances(addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
     /** Prepare a tx to transfer some tokens from this module */

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

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

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

@@ -1,5 +1,4 @@
-import { Chain, ChainId, EvmNetworkId } from "@talismn/chaindata-provider";
-import { ChaindataProviderExtension } from "@talismn/chaindata-provider-extension";
+import { Chain, ChaindataProvider, ChainId } from "@talismn/chaindata-provider";
 import { ChainConnectors } from "./BalanceModule";
 import { AnyBalanceModule } from "./modules/util";
 import { MiniMetadata, MiniMetadataStatus } from "./types";
@@ -18,7 +17,7 @@ import { MiniMetadata, MiniMetadataStatus } from "./types";
  * 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 [subshape](https://github.com/paritytech/subshape) library,
+ * 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`.
@@ -30,15 +29,15 @@ import { MiniMetadata, MiniMetadataStatus } from "./types";
  */
 export declare class MiniMetadataUpdater {
     #private;
-    constructor(chainConnectors: ChainConnectors, chaindataProvider: ChaindataProviderExtension, balanceModules: Array<AnyBalanceModule>);
+    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[], evmNetworkIds: EvmNetworkId[]): Promise<void>;
+    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;
-    private updateEvmNetworks;
 }

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

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

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

@@ -1,5 +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,26 +1,19 @@
-import { BalancesConfigTokenParams, EvmChainId, EvmNetworkId, NewTokenType } from "@talismn/chaindata-provider";
+import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
 import { NewBalanceModule } from "../BalanceModule";
-import { Amount, NewBalanceType } from "../types";
+import { NewBalanceType } from "../types";
 import { erc20Abi } from "./abis/erc20";
-export { erc20Abi };
+import { erc20BalancesAggregatorAbi } from "./abis/erc20BalancesAggregator";
+export { erc20Abi, erc20BalancesAggregatorAbi };
 type ModuleType = "evm-erc20";
-export declare const evmErc20TokenId: (chainId: EvmNetworkId, tokenContractAddress: EvmErc20Token["contractAddress"]) => string;
-export type EvmErc20Token = NewTokenType<ModuleType, {
-    contractAddress: string;
-    evmNetwork: {
-        id: EvmNetworkId;
-    } | null;
+export type EvmErc20Token = Extract<Token, {
+    type: ModuleType;
+    isCustom?: true;
 }>;
-export type CustomEvmErc20Token = EvmErc20Token & {
+export type CustomEvmErc20Token = Extract<Token, {
+    type: ModuleType;
     isCustom: true;
-    image?: string;
-};
-declare module "@talismn/chaindata-provider/plugins" {
-    interface PluginTokenTypes {
-        EvmErc20Token: EvmErc20Token;
-        CustomEvmErc20Token: CustomEvmErc20Token;
-    }
-}
+}>;
+export declare const evmErc20TokenId: (chainId: EvmNetworkId, tokenContractAddress: EvmErc20Token["contractAddress"]) => string;
 export type EvmErc20ChainMeta = {
     isTestnet: boolean;
 };
@@ -31,13 +24,10 @@ export type EvmErc20ModuleConfig = {
         contractAddress?: string;
     } & BalancesConfigTokenParams>;
 };
-export type EvmErc20Balance = NewBalanceType<ModuleType, {
-    multiChainId: EvmChainId;
-    free: Amount;
-}>;
+export type EvmErc20Balance = NewBalanceType<ModuleType, "simple", "ethereum">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
-        EvmErc20Balance: EvmErc20Balance;
+        "evm-erc20": EvmErc20Balance;
     }
 }
 export declare const EvmErc20Module: NewBalanceModule<ModuleType, EvmErc20Token | CustomEvmErc20Token, EvmErc20ChainMeta, EvmErc20ModuleConfig>;

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

@@ -1,22 +1,14 @@
-import { BalancesConfigTokenParams, EvmChainId, EvmNetworkId, NewTokenType } from "@talismn/chaindata-provider";
+import { BalancesConfigTokenParams, EvmNetworkId, Token } from "@talismn/chaindata-provider";
 import { NewBalanceModule } from "../BalanceModule";
-import { Amount, NewBalanceType } from "../types";
+import { NewBalanceType } from "../types";
 type ModuleType = "evm-native";
-export declare const evmNativeTokenId: (chainId: EvmNetworkId, tokenSymbol: string) => string;
-export type EvmNativeToken = NewTokenType<ModuleType, {
-    evmNetwork: {
-        id: EvmNetworkId;
-    };
+export type EvmNativeToken = Extract<Token, {
+    type: ModuleType;
 }>;
-export type CustomEvmNativeToken = EvmNativeToken & {
-    isCustom: true;
-};
-declare module "@talismn/chaindata-provider/plugins" {
-    interface PluginTokenTypes {
-        EvmNativeToken: EvmNativeToken;
-        CustomEvmNativeToken: CustomEvmNativeToken;
-    }
-}
+export type CustomEvmNativeToken = Extract<Token, {
+    type: ModuleType;
+}>;
+export declare const evmNativeTokenId: (chainId: EvmNetworkId) => string;
 export type EvmNativeChainMeta = {
     isTestnet: boolean;
 };
@@ -24,13 +16,10 @@ export type EvmNativeModuleConfig = {
     symbol?: string;
     decimals?: number;
 } & BalancesConfigTokenParams;
-export type EvmNativeBalance = NewBalanceType<ModuleType, {
-    multiChainId: EvmChainId;
-    free: Amount;
-}>;
+export type EvmNativeBalance = NewBalanceType<ModuleType, "simple", "ethereum">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
-        EvmNativeBalance: EvmNativeBalance;
+        "evm-native": EvmNativeBalance;
     }
 }
 export declare const EvmNativeModule: NewBalanceModule<ModuleType, EvmNativeToken | CustomEvmNativeToken, EvmNativeChainMeta, EvmNativeModuleConfig>;

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

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

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

@@ -1,51 +1,38 @@
 import { TypeRegistry } from "@polkadot/types";
-import { BalancesConfigTokenParams, ChainId, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
 import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
-import { Amount, NewBalanceType } from "../types";
+import { NewBalanceType } from "../types";
 type ModuleType = "substrate-assets";
-export type SubAssetsToken = NewTokenType<ModuleType, {
-    existentialDeposit: string;
-    assetId: string;
-    isFrozen: boolean;
-    chain: {
-        id: ChainId;
-    };
+export type SubAssetsToken = Extract<Token, {
+    type: ModuleType;
 }>;
-declare module "@talismn/chaindata-provider/plugins" {
-    interface PluginTokenTypes {
-        SubAssetsToken: SubAssetsToken;
-    }
-}
+export declare const subAssetTokenId: (chainId: ChainId, assetId: string, tokenSymbol: string) => string;
 export type SubAssetsChainMeta = {
     isTestnet: boolean;
-    miniMetadata: `0x${string}` | null;
-    metadataVersion: number;
+    miniMetadata?: string;
+    metadataVersion?: number;
 };
 export type SubAssetsModuleConfig = {
     tokens?: Array<{
         assetId: string | number;
     } & BalancesConfigTokenParams>;
 };
-export type SubAssetsBalance = NewBalanceType<ModuleType, {
-    multiChainId: SubChainId;
-    free: Amount;
-    locks: Amount;
-}>;
+export type SubAssetsBalance = NewBalanceType<ModuleType, "complex", "substrate">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
-        SubAssetsBalance: SubAssetsBalance;
+        "substrate-assets": SubAssetsBalance;
     }
 }
 export type SubAssetsTransferParams = NewTransferParamsType<{
     registry: TypeRegistry;
-    metadataRpc: `0x${string}`;
     blockHash: string;
     blockNumber: number;
     nonce: number;
     specVersion: number;
     transactionVersion: number;
     tip?: string;
-    transferMethod: "transfer" | "transferKeepAlive" | "transferAll";
+    userExtensions?: ExtDef;
 }>;
 export declare const SubAssetsModule: NewBalanceModule<ModuleType, SubAssetsToken, SubAssetsChainMeta, SubAssetsModuleConfig, SubAssetsTransferParams>;
 export {};

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

@@ -1,24 +1,17 @@
 import { TypeRegistry } from "@polkadot/types";
-import { BalancesConfigTokenParams, ChainId, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import { BalancesConfigTokenParams, ChainId, Token } from "@talismn/chaindata-provider";
 import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
-import { Amount, NewBalanceType } from "../types";
+import { NewBalanceType } from "../types";
 type ModuleType = "substrate-equilibrium";
-export type SubEquilibriumToken = NewTokenType<ModuleType, {
-    existentialDeposit: string;
-    assetId: string;
-    chain: {
-        id: ChainId;
-    };
+export type SubEquilibriumToken = Extract<Token, {
+    type: ModuleType;
 }>;
-declare module "@talismn/chaindata-provider/plugins" {
-    interface PluginTokenTypes {
-        SubEquilibriumToken: SubEquilibriumToken;
-    }
-}
+export declare const subEquilibriumTokenId: (chainId: ChainId, tokenSymbol: string) => string;
 export type SubEquilibriumChainMeta = {
     isTestnet: boolean;
-    miniMetadata: `0x${string}` | null;
-    metadataVersion: number;
+    miniMetadata?: string;
+    metadataVersion?: number;
 };
 export type SubEquilibriumModuleConfig = {
     disable?: boolean;
@@ -26,25 +19,21 @@ export type SubEquilibriumModuleConfig = {
         assetId?: string;
     } & BalancesConfigTokenParams>;
 };
-export type SubEquilibriumBalance = NewBalanceType<ModuleType, {
-    multiChainId: SubChainId;
-    free: Amount;
-}>;
+export type SubEquilibriumBalance = NewBalanceType<ModuleType, "simple", "substrate">;
 declare module "@talismn/balances/plugins" {
     interface PluginBalanceTypes {
-        SubEquilibriumBalance: SubEquilibriumBalance;
+        "substrate-equilibrium": SubEquilibriumBalance;
     }
 }
 export type SubEquilibriumTransferParams = NewTransferParamsType<{
     registry: TypeRegistry;
-    metadataRpc: `0x${string}`;
     blockHash: string;
     blockNumber: number;
     nonce: number;
     specVersion: number;
     transactionVersion: number;
     tip?: string;
-    transferMethod: "transfer" | "transferKeepAlive" | "transferAll";
+    userExtensions?: ExtDef;
 }>;
 export declare const SubEquilibriumModule: NewBalanceModule<ModuleType, SubEquilibriumToken, SubEquilibriumChainMeta, SubEquilibriumModuleConfig, SubEquilibriumTransferParams>;
 export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { Balance, BalanceFormatter, LockedAmount } from "../../../types";
+export type BalanceLockType = "reserved" | "democracy" | "crowdloan" | "staking" | "nompools-staking" | "nompools-unbonding" | "subtensor-staking" | "vesting" | "dapp-staking" | `other-${string}` | "other";
+/**
+ * For converting the value of `lock?.id?.toUtf8?.()` which is retrieved from
+ * the Balances.Locks storage key into a useful classification for our UI
+ */
+export declare const getLockedType: (input?: string) => BalanceLockType;
+export declare const filterBaseLocks: (locks: Array<Omit<LockedAmount<string>, "amount"> & {
+    amount: BalanceFormatter;
+}>) => (Omit<LockedAmount<string>, "amount"> & {
+    amount: BalanceFormatter;
+})[];
+export declare const getLockTitle: (lock: Pick<LockedAmount<string>, "label" | "meta">, { balance }?: {
+    balance?: Balance;
+}) => string;

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

@@ -0,0 +1,13 @@
+import { Chain, Token } from "@talismn/chaindata-provider";
+import { AddressesByToken, MiniMetadata } from "../../../types";
+import { RpcStateQuery, StorageCoders } from "../../util";
+import { SubNativeBalance, SubNativeToken } from "../types";
+export type QueryKey = string;
+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<string, MiniMetadata>, addressesByToken: AddressesByToken<SubNativeToken>): Promise<Record<QueryKey, Array<RpcStateQuery<SubNativeBalance>>>>;