@talismn/balances 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @talismn/balances
 
+## 0.6.1
+
+### Patch Changes
+
+- 771a5be: fix: incorrect cached/stale balances for evm accounts
+- d2ccdaf: fix: balance subscriptions never update registry cache with new metadata
+- 372f995: replace ethers by viem
+- c4d5967: bump typescript version
+- a916db0: docs: added @talismn/balances readme
+- a3a1bd7: feat: psp22 balances module
+- c36375f: Use Balances::transfer_allow_death as default method for substrate balance transfers
+- 620b7eb: Dependency updates
+- 5aadf99: fix: renamed renamed Unknown -> Unit for tokens with no symbol
+- 5aadf99: feat: native token balances on custom networks
+- Updated dependencies [123647e]
+- Updated dependencies [03939d5]
+- Updated dependencies [d2ccdaf]
+- Updated dependencies [123647e]
+- Updated dependencies [be0d19e]
+- Updated dependencies [e0eb84a]
+- Updated dependencies [ade2908]
+- Updated dependencies [372f995]
+- Updated dependencies [c4d5967]
+- Updated dependencies [776432e]
+- Updated dependencies [23f0d3a]
+- Updated dependencies [e0eb84a]
+- Updated dependencies [620b7eb]
+- Updated dependencies [850381a]
+- Updated dependencies [5aadf99]
+- Updated dependencies [4cace80]
+- Updated dependencies [a6c1b2a]
+- Updated dependencies [372f995]
+- Updated dependencies [9ebcd93]
+  - @talismn/token-rates@0.3.0
+  - @talismn/chaindata-provider@0.8.0
+  - @talismn/chaindata-provider-extension@0.8.0
+  - @talismn/chain-connector-evm@0.8.0
+  - @talismn/chain-connector@0.8.0
+  - @talismn/util@0.2.1
+  - @talismn/scale@0.0.2
+
 ## 0.6.0
 
 ### Minor Changes

package/README.md

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

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

@@ -2,8 +2,7 @@ import { UnsignedTransaction } from "@substrate/txwrapper-core";
 import { ChainConnector } from "@talismn/chain-connector";
 import { ChainConnectorEvm } from "@talismn/chain-connector-evm";
 import { ChainId, ChaindataProvider, IToken } from "@talismn/chaindata-provider";
-import { ethers } from "ethers";
-import { AddressesByToken, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
+import { Address, AddressesByToken, BalanceJson, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
 export type ExtendableTokenType = IToken;
 export type ExtendableChainMeta = Record<string, unknown> | undefined;
 export type DefaultChainMeta = undefined;
@@ -21,9 +20,6 @@ export type NewTransferParamsType<T extends Record<string, unknown>> = BaseTrans
 export type TransferTokenTx = {
     type: "substrate";
     tx: UnsignedTransaction;
-} | {
-    type: "evm";
-    tx: ethers.providers.TransactionRequest;
 };
 export type ChainConnectors = {
     substrate?: ChainConnector;
@@ -39,7 +35,7 @@ export interface BalanceModule<TModuleType extends string, TTokenType extends Ex
 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> {
     /** Pre-processes any substrate chain metadata required by this module ahead of time */
-    fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig): Promise<TChainMeta | null>;
+    fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig, metadataRpc?: `0x${string}`): 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>>;
 }
@@ -57,6 +53,8 @@ interface BalanceModuleCommon<TModuleType extends string, TTokenType extends Ext
      * 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;
     /** 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/MiniMetadataUpdater.d.ts

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+import { BalancesConfigTokenParams, EvmChainId, EvmNetworkId, NewTokenType } from "@talismn/chaindata-provider";
+import { NewBalanceModule } from "../BalanceModule";
+import { Amount, NewBalanceType } from "../types";
+import { erc20Abi } from "./abis/erc20";
+export { erc20Abi };
+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 CustomEvmErc20Token = EvmErc20Token & {
+    isCustom: true;
+    image?: string;
+};
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        EvmErc20Token: EvmErc20Token;
+        CustomEvmErc20Token: CustomEvmErc20Token;
+    }
+}
+export type EvmErc20ChainMeta = {
+    isTestnet: boolean;
+};
+export type EvmErc20ModuleConfig = {
+    tokens?: Array<{
+        symbol?: string;
+        decimals?: number;
+        contractAddress?: string;
+    } & BalancesConfigTokenParams>;
+};
+export type EvmErc20Balance = NewBalanceType<ModuleType, {
+    multiChainId: EvmChainId;
+    free: Amount;
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        EvmErc20Balance: EvmErc20Balance;
+    }
+}
+export declare const EvmErc20Module: NewBalanceModule<ModuleType, EvmErc20Token | CustomEvmErc20Token, EvmErc20ChainMeta, EvmErc20ModuleConfig>;

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

@@ -0,0 +1,37 @@
+import { BalancesConfigTokenParams, EvmChainId, EvmNetworkId, NewTokenType } from "@talismn/chaindata-provider";
+import { NewBalanceModule } from "../BalanceModule";
+import { Amount, 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 CustomEvmNativeToken = EvmNativeToken & {
+    isCustom: true;
+};
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        EvmNativeToken: EvmNativeToken;
+        CustomEvmNativeToken: CustomEvmNativeToken;
+    }
+}
+export type EvmNativeChainMeta = {
+    isTestnet: boolean;
+};
+export type EvmNativeModuleConfig = {
+    symbol?: string;
+    decimals?: number;
+} & BalancesConfigTokenParams;
+export type EvmNativeBalance = NewBalanceType<ModuleType, {
+    multiChainId: EvmChainId;
+    free: Amount;
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        EvmNativeBalance: EvmNativeBalance;
+    }
+}
+export declare const EvmNativeModule: NewBalanceModule<ModuleType, EvmNativeToken | CustomEvmNativeToken, EvmNativeChainMeta, EvmNativeModuleConfig>;
+export {};

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

@@ -0,0 +1,51 @@
+import { TypeRegistry } from "@polkadot/types";
+import { BalancesConfigTokenParams, ChainId, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { Amount, NewBalanceType } from "../types";
+type ModuleType = "substrate-assets";
+export type SubAssetsToken = NewTokenType<ModuleType, {
+    existentialDeposit: string;
+    assetId: string;
+    isFrozen: boolean;
+    chain: {
+        id: ChainId;
+    };
+}>;
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        SubAssetsToken: SubAssetsToken;
+    }
+}
+export type SubAssetsChainMeta = {
+    isTestnet: boolean;
+    miniMetadata: `0x${string}` | null;
+    metadataVersion: number;
+};
+export type SubAssetsModuleConfig = {
+    tokens?: Array<{
+        assetId: string | number;
+    } & BalancesConfigTokenParams>;
+};
+export type SubAssetsBalance = NewBalanceType<ModuleType, {
+    multiChainId: SubChainId;
+    free: Amount;
+    locks: Amount;
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        SubAssetsBalance: 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";
+}>;
+export declare const SubAssetsModule: NewBalanceModule<ModuleType, SubAssetsToken, SubAssetsChainMeta, SubAssetsModuleConfig, SubAssetsTransferParams>;
+export {};

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

@@ -0,0 +1,50 @@
+import { TypeRegistry } from "@polkadot/types";
+import { BalancesConfigTokenParams, ChainId, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { Amount, NewBalanceType } from "../types";
+type ModuleType = "substrate-equilibrium";
+export type SubEquilibriumToken = NewTokenType<ModuleType, {
+    existentialDeposit: string;
+    assetId: string;
+    chain: {
+        id: ChainId;
+    };
+}>;
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        SubEquilibriumToken: SubEquilibriumToken;
+    }
+}
+export type SubEquilibriumChainMeta = {
+    isTestnet: boolean;
+    miniMetadata: `0x${string}` | null;
+    metadataVersion: number;
+};
+export type SubEquilibriumModuleConfig = {
+    disable?: boolean;
+    tokens?: Array<{
+        assetId?: string;
+    } & BalancesConfigTokenParams>;
+};
+export type SubEquilibriumBalance = NewBalanceType<ModuleType, {
+    multiChainId: SubChainId;
+    free: Amount;
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        SubEquilibriumBalance: 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";
+}>;
+export declare const SubEquilibriumModule: NewBalanceModule<ModuleType, SubEquilibriumToken, SubEquilibriumChainMeta, SubEquilibriumModuleConfig, SubEquilibriumTransferParams>;
+export {};

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

@@ -0,0 +1,65 @@
+import { TypeRegistry } from "@polkadot/types";
+import { ChainConnector } from "@talismn/chain-connector";
+import { BalancesConfigTokenParams, ChainId, ChaindataProvider, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { AddressesByToken, Amount, AmountWithLabel, Balances, LockedAmount, NewBalanceType, SubscriptionCallback } from "../types";
+import { GetOrCreateTypeRegistry } from "./util";
+type ModuleType = "substrate-native";
+export declare const subNativeTokenId: (chainId: ChainId, tokenSymbol: string) => string;
+export type SubNativeToken = NewTokenType<ModuleType, {
+    existentialDeposit: string;
+    chain: {
+        id: ChainId;
+    };
+}>;
+export type CustomSubNativeToken = SubNativeToken & {
+    isCustom: true;
+};
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        SubNativeToken: SubNativeToken;
+        CustomSubNativeToken: CustomSubNativeToken;
+    }
+}
+export type SubNativeChainMeta = {
+    isTestnet: boolean;
+    symbol: string;
+    decimals: number;
+    existentialDeposit: string | null;
+    nominationPoolsPalletId: string | null;
+    crowdloanPalletId: string | null;
+    miniMetadata: `0x${string}` | null;
+    metadataVersion: number;
+};
+export type SubNativeModuleConfig = {
+    disable?: boolean;
+} & BalancesConfigTokenParams;
+export type SubNativeBalance = NewBalanceType<ModuleType, {
+    multiChainId: SubChainId;
+    free: Amount;
+    reserves: [AmountWithLabel<"reserved">, ...Array<AmountWithLabel<string>>];
+    locks: [LockedAmount<"fees">, LockedAmount<"misc">, ...Array<LockedAmount<string>>];
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        SubNativeBalance: SubNativeBalance;
+    }
+}
+export type BalancesCommonTransferMethods = "transferKeepAlive" | "transferAll";
+export type BalancesTransferMethods = "transferAllowDeath" | BalancesCommonTransferMethods;
+export type BalancesLegacyTransferMethods = "transfer" | BalancesCommonTransferMethods;
+export type BalancesAllTransferMethods = BalancesLegacyTransferMethods | BalancesTransferMethods;
+export type SubNativeTransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    metadataRpc: `0x${string}`;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    transferMethod: BalancesAllTransferMethods;
+}>;
+export declare const SubNativeModule: NewBalanceModule<ModuleType, SubNativeToken | CustomSubNativeToken, SubNativeChainMeta, SubNativeModuleConfig, SubNativeTransferParams>;
+export declare function subscribeNompoolStaking(chaindataProvider: ChaindataProvider, chainConnector: ChainConnector, getOrCreateTypeRegistry: GetOrCreateTypeRegistry, addressesByToken: AddressesByToken<SubNativeToken | CustomSubNativeToken>, callback: SubscriptionCallback<Balances>, callerUnsubscribed: Promise<unknown>): Promise<void>;
+export {};

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

@@ -0,0 +1,50 @@
+import { TypeRegistry } from "@polkadot/types";
+import { BalancesConfigTokenParams, ChainId, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { Amount, NewBalanceType } from "../types";
+type ModuleType = "substrate-psp22";
+export type SubPsp22Token = NewTokenType<ModuleType, {
+    existentialDeposit: string;
+    contractAddress: string;
+    chain: {
+        id: ChainId;
+    };
+}>;
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        SubPsp22Token: SubPsp22Token;
+    }
+}
+export type SubPsp22ChainMeta = {
+    isTestnet: boolean;
+};
+export type SubPsp22ModuleConfig = {
+    tokens?: Array<{
+        symbol?: string;
+        decimals?: number;
+        ed?: string;
+        contractAddress?: string;
+    } & BalancesConfigTokenParams>;
+};
+export type SubPsp22Balance = NewBalanceType<ModuleType, {
+    multiChainId: SubChainId;
+    free: Amount;
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        SubPsp22Balance: SubPsp22Balance;
+    }
+}
+export type SubPsp22TransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    metadataRpc: `0x${string}`;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    transferMethod: "transfer" | "transferKeepAlive" | "transferAll";
+}>;
+export declare const SubPsp22Module: NewBalanceModule<ModuleType, SubPsp22Token, SubPsp22ChainMeta, SubPsp22ModuleConfig, SubPsp22TransferParams>;
+export {};

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

@@ -0,0 +1,54 @@
+import { TypeRegistry } from "@polkadot/types";
+import { BalancesConfigTokenParams, ChainId, NewTokenType, SubChainId } from "@talismn/chaindata-provider";
+import { NewBalanceModule, NewTransferParamsType } from "../BalanceModule";
+import { Amount, NewBalanceType } from "../types";
+type ModuleType = "substrate-tokens";
+export type SubTokensToken = NewTokenType<ModuleType, {
+    existentialDeposit: string;
+    onChainId: string | number;
+    chain: {
+        id: ChainId;
+    };
+}>;
+declare module "@talismn/chaindata-provider/plugins" {
+    interface PluginTokenTypes {
+        SubTokensToken: SubTokensToken;
+    }
+}
+export type SubTokensChainMeta = {
+    isTestnet: boolean;
+    miniMetadata: `0x${string}` | null;
+    metadataVersion: number;
+};
+export type SubTokensModuleConfig = {
+    tokens?: Array<{
+        symbol?: string;
+        decimals?: number;
+        ed?: string;
+        onChainId?: string | number;
+    } & BalancesConfigTokenParams>;
+};
+export type SubTokensBalance = NewBalanceType<ModuleType, {
+    multiChainId: SubChainId;
+    free: Amount;
+    reserves: Amount;
+    locks: Amount;
+}>;
+declare module "@talismn/balances/plugins" {
+    interface PluginBalanceTypes {
+        SubTokensBalance: SubTokensBalance;
+    }
+}
+export type SubTokensTransferParams = NewTransferParamsType<{
+    registry: TypeRegistry;
+    metadataRpc: `0x${string}`;
+    blockHash: string;
+    blockNumber: number;
+    nonce: number;
+    specVersion: number;
+    transactionVersion: number;
+    tip?: string;
+    transferMethod: "transfer" | "transferKeepAlive" | "transferAll";
+}>;
+export declare const SubTokensModule: NewBalanceModule<ModuleType, SubTokensToken, SubTokensChainMeta, SubTokensModuleConfig, SubTokensTransferParams>;
+export {};