@talismn/balances 0.6.0 → 0.7.0

package/dist/declarations/src/modules/util/buildStorageCoders.d.ts

@@ -0,0 +1,26 @@
+import { ChainId, ChainList } from "@talismn/chaindata-provider";
+import { getDynamicBuilder } from "@talismn/scale";
+import { MiniMetadata } from "../../types";
+import { AnyNewBalanceModule, InferModuleType } from "./InferBalanceModuleTypes";
+export type StorageCoders<TCoders extends {
+    [key: string]: [string, string];
+}> = Map<string, {
+    [Property in keyof TCoders]: ReturnType<ReturnType<typeof getDynamicBuilder>["buildStorage"]> | undefined;
+}>;
+export declare const buildStorageCoders: <TBalanceModule extends AnyNewBalanceModule, TCoders extends {
+    [key: string]: [string, string] | ((params: {
+        chainId: string;
+    }) => [string, string]);
+}>({ chainIds, chains, miniMetadatas, moduleType, coders, }: {
+    chainIds: ChainId[];
+    chains: ChainList;
+    miniMetadatas: Map<string, MiniMetadata>;
+    moduleType: InferModuleType<TBalanceModule>;
+    coders: TCoders;
+}) => Map<string, { [Property in keyof TCoders]: {
+    len: number;
+    fallback: unknown;
+    enc: (...args: any[]) => string;
+    dec: import("scale-ts").Decoder<unknown>;
+    keyDecoder: (value: string) => any[];
+} | undefined; }>;

package/dist/declarations/src/modules/util/decodeOutput.d.ts

@@ -0,0 +1,13 @@
+import { Abi } from "@polkadot/api-contract";
+import { TypeRegistry } from "@polkadot/types";
+import { ContractExecResult } from "@polkadot/types/interfaces";
+/**
+ * Decodes & unwraps outputs and errors of a given result, contract, and method.
+ * Parsed error message can be found in `decodedOutput` if `isError` is true.
+ * SOURCE: https://github.com/paritytech/contracts-ui (GPL-3.0-only)
+ */
+export declare function decodeOutput({ result }: Pick<ContractExecResult, "result" | "debugMessage">, registry: TypeRegistry, abi: Abi, method: string): {
+    output: any;
+    decodedOutput: string;
+    isError: boolean;
+};

package/dist/declarations/src/modules/util/detectTransferMethod.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * Detect Balances::transfer -> Balances::transfer_allow_death migration
+ * https://github.com/paritytech/substrate/pull/12951
+ *
+ * `transfer_allow_death` is the preferred method,
+ * so if something goes wrong during detection, we should assume the chain has migrated
+ * @param metadataRpc string containing the hashed RPC metadata for the chain
+ * @returns
+ */
+export declare const detectTransferMethod: (metadataRpc: `0x${string}`) => "transfer_allow_death" | "transfer";

package/dist/declarations/src/modules/util/findChainMeta.d.ts

@@ -0,0 +1,8 @@
+import { Chain } from "@talismn/chaindata-provider";
+import { MiniMetadata } from "../../types";
+import { AnyNewBalanceModule, InferChainMeta, InferModuleType } from "./InferBalanceModuleTypes";
+/**
+ * Given a `moduleType` and a `chain` from a chaindataProvider, this function will find the chainMeta
+ * associated with the given balanceModule for the given chain.
+ */
+export declare const findChainMeta: <TBalanceModule extends AnyNewBalanceModule>(miniMetadatas: Map<string, MiniMetadata>, moduleType: InferModuleType<TBalanceModule>, chain?: Chain) => [InferChainMeta<TBalanceModule> | undefined, MiniMetadata | undefined];

package/dist/declarations/src/modules/util/getUniqueChainIds.d.ts

@@ -0,0 +1,5 @@
+import { ChainId, TokenList } from "@talismn/chaindata-provider";
+import { AddressesByToken } from "../../types";
+export declare const getUniqueChainIds: (addressesByToken: AddressesByToken<{
+    id: string;
+}>, tokens: TokenList) => ChainId[];

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

@@ -0,0 +1,10 @@
+export * from "./balances";
+export * from "./buildStorageCoders";
+export * from "./decodeOutput";
+export * from "./detectTransferMethod";
+export * from "./findChainMeta";
+export * from "./getUniqueChainIds";
+export * from "./InferBalanceModuleTypes";
+export * from "./makeContractCaller";
+export * from "./RpcStateQueryHelper";
+export * from "./storageCompression";

package/dist/declarations/src/modules/util/makeContractCaller.d.ts

@@ -0,0 +1,9 @@
+import { TypeRegistry } from "@polkadot/types";
+import { ChainConnector } from "@talismn/chain-connector";
+export declare const makeContractCaller: ({ chainConnector, chainId, registry, }: {
+    chainConnector: ChainConnector;
+    chainId: string;
+    registry: TypeRegistry;
+}) => <T extends Uint8Array | {
+    toU8a: () => Uint8Array;
+}>(callFrom: string, contractAddress: string, inputData: T) => Promise<import("@polkadot/types/interfaces").ContractExecResult>;

package/dist/declarations/src/modules/util/storageCompression.d.ts

@@ -0,0 +1,9 @@
+import { Table } from "dexie";
+import { BalanceJson } from "../../types";
+export type StoredBalanceJson = Omit<BalanceJson, "status">;
+export declare const configureStore: (dbTable?: Table) => {
+    persistData: (balances: StoredBalanceJson[]) => Promise<void>;
+    retrieveData: () => Promise<StoredBalanceJson[]>;
+};
+export declare const compress: (balances: StoredBalanceJson[]) => Uint8Array;
+export declare const decompress: (data: Uint8Array | ArrayBuffer) => StoredBalanceJson[];

package/dist/declarations/src/types/balances.d.ts

@@ -1,7 +1,13 @@
 import { ChainList, EvmNetworkList, TokenList } from "@talismn/chaindata-provider";
 import { TokenRateCurrency, TokenRates, TokenRatesList } from "@talismn/token-rates";
 import { NonFunctionProperties } from "@talismn/util";
-import { BalanceJson, BalanceJsonList, IBalance } from "./balancetypes";
+import { Amount, AmountWithLabel, BalanceJson, BalanceJsonList, BalanceStatusTypes, ExtraAmount, IBalance, LockedAmount } from "./balancetypes";
+type FormattedAmount<GenericAmount extends AmountWithLabel<TLabel>, TLabel extends string> = Omit<GenericAmount, "amount"> & {
+    amount: BalanceFormatter;
+};
+export declare function excludeFromTransferableAmount(locks: Amount | FormattedAmount<LockedAmount<string>, string> | Array<FormattedAmount<LockedAmount<string>, string>>): bigint;
+export declare function excludeFromFeePayableLocks(locks: Amount | LockedAmount<string> | Array<LockedAmount<string>>): Array<LockedAmount<string>>;
+export declare function includeInTotalExtraAmount(extra?: FormattedAmount<ExtraAmount<string>, string> | Array<FormattedAmount<ExtraAmount<string>, string>>): bigint;
 /**
  * Have the importing library define its Token and BalanceJson enums (as a sum type of all plugins) and pass them into some
  * internal global typescript context, which is then picked up on by this module.
@@ -40,7 +46,7 @@ export declare class Balances {
      *   // do something
      * }
      */
-    [Symbol.iterator]: () => IterableIterator<Balance>;
+    [Symbol.iterator]: () => ArrayIterator<Balance>;
     /**
      * Hydrates all balances in this collection.
      *
@@ -66,14 +72,10 @@ export declare class Balances {
      * and another balance exists in this collection for the token specified by the `mirrorOf` field.
      */
     filterMirrorTokens: () => Balances;
-    /**
-     * Filters this collection to only include balances which are not zero.
-     */
-    filterNonZero: (type: "total" | "free" | "reserved" | "locked" | "frozen" | "transferable" | "feePayable") => Balances;
     /**
      * Filters this collection to only include balances which are not zero AND have a fiat conversion rate.
      */
-    filterNonZeroFiat: (type: "total" | "free" | "reserved" | "locked" | "frozen" | "transferable" | "feePayable", currency: TokenRateCurrency) => Balances;
+    filterNonZeroFiat: (type: "total" | "free" | "reserved" | "locked" | "frozen" | "transferable" | "unavailable" | "feePayable", currency: TokenRateCurrency) => Balances;
     /**
      * Add some balances to this collection.
      * Added balances take priority over existing balances.
@@ -116,6 +118,7 @@ export declare class Balances {
      */
     get sum(): SumBalancesFormatter;
 }
+export declare const getBalanceId: (balance: BalanceJson) => string;
 /**
  * An individual balance.
  */
@@ -126,7 +129,7 @@ export declare class Balance {
     isSource: (source: BalanceSource) => boolean;
     hydrate: (hydrate?: HydrateDb) => void;
     get id(): string;
-    get source(): string;
+    get source(): "evm-erc20" | "evm-native" | "evm-uniswapv2" | "substrate-assets" | "substrate-equilibrium" | "substrate-foreignassets" | "substrate-native" | "substrate-psp22" | "substrate-tokens";
     get status(): import("./balancetypes").BalanceStatus;
     get address(): string;
     get chainId(): string | undefined;
@@ -134,9 +137,107 @@ export declare class Balance {
     get evmNetworkId(): string | undefined;
     get evmNetwork(): import("@talismn/chaindata-provider").EvmNetwork | null;
     get tokenId(): string;
-    get token(): import("@talismn/chaindata-provider").IToken | null;
+    get token(): (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "evm-erc20";
+    } & {
+        contractAddress: string;
+        evmNetwork: {
+            id: import("@talismn/chaindata-provider").EvmNetworkId;
+        } | null;
+        isCustom?: true;
+        image?: string;
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "evm-native";
+    } & {
+        evmNetwork: {
+            id: import("@talismn/chaindata-provider").EvmNetworkId;
+        };
+        isCustom?: true;
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "evm-uniswapv2";
+    } & {
+        contractAddress: string;
+        symbol0: string;
+        symbol1: string;
+        decimals0: number;
+        decimals1: number;
+        tokenAddress0: string;
+        tokenAddress1: string;
+        coingeckoId0?: string;
+        coingeckoId1?: string;
+        evmNetwork: {
+            id: import("@talismn/chaindata-provider").EvmNetworkId;
+        } | null;
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "substrate-assets";
+    } & {
+        existentialDeposit: string;
+        assetId: string;
+        isFrozen: boolean;
+        chain: {
+            id: import("@talismn/chaindata-provider").ChainId;
+        };
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "substrate-equilibrium";
+    } & {
+        existentialDeposit: string;
+        assetId: string;
+        chain: {
+            id: import("@talismn/chaindata-provider").ChainId;
+        };
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "substrate-foreignassets";
+    } & {
+        existentialDeposit: string;
+        onChainId: string;
+        isFrozen: boolean;
+        chain: {
+            id: import("@talismn/chaindata-provider").ChainId;
+        };
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "substrate-native";
+    } & {
+        existentialDeposit: string;
+        chain: {
+            id: import("@talismn/chaindata-provider").ChainId;
+        };
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "substrate-psp22";
+    } & {
+        existentialDeposit: string;
+        contractAddress: string;
+        chain: {
+            id: import("@talismn/chaindata-provider").ChainId;
+        };
+    }) | (import("@talismn/chaindata-provider/dist/declarations/src/types/Token/types").TokenBase & {
+        type: "substrate-tokens";
+    } & {
+        existentialDeposit: string;
+        onChainId: string | number;
+        chain: {
+            id: import("@talismn/chaindata-provider").ChainId;
+        };
+    }) | null;
     get decimals(): number | null;
     get rates(): TokenRates | null;
+    /**
+     * A general method to get formatted values matching a certain type from this balance.
+     * @param valueType - The type of value to get.
+     * @returns An array of the values matching the type with formatted amounts.
+     */
+    private getValue;
+    /**
+     * A general method to get values matching a certain type from this balance.
+     * @param valueType - The type of value to get.
+     * @returns An array of the values matching the type.
+     */
+    private getRawValue;
+    /**
+     * A general method to add a value to the array of values for this balance.
+     * @param valueType - The type of value to add.
+     * @returns A function which can be used to add a value to the array of values for this balance.
+     */
+    private addValue;
     /**
      * The total balance of this token.
      * Includes the free and the reserved amount.
@@ -147,30 +248,37 @@ export declare class Balance {
     get free(): BalanceFormatter;
     /** The reserved balance of this token. Is included in the total. */
     get reserved(): BalanceFormatter;
-    get reserves(): {
-        amount: BalanceFormatter;
-        label: string;
-        meta?: unknown;
-    }[];
+    get reserves(): FormattedAmount<AmountWithLabel<string>, string>[];
     /** The frozen balance of this token. Is included in the free amount. */
     get locked(): BalanceFormatter;
-    get locks(): {
-        amount: BalanceFormatter;
-        label: string;
-        meta?: unknown;
-        includeInTransferable?: boolean | undefined;
-        excludeFromFeePayable?: boolean | undefined;
-    }[];
+    get locks(): FormattedAmount<AmountWithLabel<string>, string>[];
+    get crowdloans(): FormattedAmount<AmountWithLabel<string>, string>[];
+    get nompools(): FormattedAmount<AmountWithLabel<string>, string>[];
+    get subtensor(): FormattedAmount<AmountWithLabel<string>, string>[];
+    /** The extra balance of this token */
+    get extra(): ExtraAmount<string>[] | undefined;
     /** @deprecated Use balance.locked */
     get frozen(): BalanceFormatter;
     /** The transferable balance of this token. Is generally the free amount - the miscFrozen amount. */
     get transferable(): BalanceFormatter;
+    /**
+     * The unavailable balance of this token.
+     * Prior to the Fungible trait, this was the locked amount + the reserved amount, i.e. `locked + reserved`.
+     * Now, it is the bigger of the locked amount and the reserved amounts, i.e. `max(locked, reserved)`.
+     */
+    get unavailable(): BalanceFormatter;
     /** The feePayable balance of this token. Is generally the free amount - the feeFrozen amount. */
     get feePayable(): BalanceFormatter;
 }
+export declare class BalanceValueGetter {
+    #private;
+    constructor(storage: BalanceJson);
+    get(valueType: BalanceStatusTypes): AmountWithLabel<string>[];
+    add(valueType: BalanceStatusTypes, amount: Omit<AmountWithLabel<string>, "type">): void;
+}
 export declare class BalanceFormatter {
     #private;
-    constructor(planck: string | bigint | undefined, decimals?: number | undefined, fiatRatios?: TokenRates);
+    constructor(planck: string | bigint | undefined, decimals?: number | undefined, fiatRatios?: TokenRates | null);
     toJSON: () => string;
     get planck(): bigint;
     get tokens(): string;
@@ -193,6 +301,8 @@ export declare class PlanckSumBalancesFormatter {
     get frozen(): bigint;
     /** The transferable balance of these tokens. Is generally the free amount - the miscFrozen amount. */
     get transferable(): bigint;
+    /** The unavailable balance of these tokens. */
+    get unavailable(): bigint;
     /** The feePayable balance of these tokens. Is generally the free amount - the feeFrozen amount. */
     get feePayable(): bigint;
 }
@@ -213,6 +323,8 @@ export declare class FiatSumBalancesFormatter {
     get frozen(): number;
     /** The transferable balance of these tokens. Is generally the free amount - the miscFrozen amount. */
     get transferable(): number;
+    /** The unavailable balance of these tokens. */
+    get unavailable(): number;
     /** The feePayable balance of these tokens. Is generally the free amount - the feeFrozen amount. */
     get feePayable(): number;
 }
@@ -221,4 +333,43 @@ export declare class SumBalancesFormatter {
     constructor(balances: Balances);
     get planck(): PlanckSumBalancesFormatter;
     fiat(currency: TokenRateCurrency): FiatSumBalancesFormatter;
+    change24h(currency: TokenRateCurrency): Change24hCurrencyFormatter;
+}
+export declare class Change24hCurrencyFormatter {
+    #private;
+    constructor(balances: Balances, currency: TokenRateCurrency);
+    get total(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get free(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get reserved(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get locked(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get frozen(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get transferable(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get unavailable(): {
+        diff: number;
+        ratio: number;
+    } | null;
+    get feePayable(): {
+        diff: number;
+        ratio: number;
+    } | null;
 }
+export declare const filterMirrorTokens: (balance: Balance, i: number, balances: Balance[]) => boolean;
+export {};

package/dist/declarations/src/types/balancetypes.d.ts

@@ -1,5 +1,5 @@
 import { PluginBalanceTypes } from "@talismn/balances/plugins";
-import { ChainId, EvmNetworkId, MultiChainId, TokenId } from "@talismn/chaindata-provider";
+import { ChainId, EvmChainId, EvmNetworkId, SubChainId, TokenId } from "@talismn/chaindata-provider";
 import { Address } from "./addresses";
 /**
  * `BalanceTypes` is an automatically determined sub-selection of `PluginBalanceTypes`.
@@ -14,60 +14,71 @@ export type BalanceTypes = {
  *
  * Each variant comes from a plugin in use by the consuming app.
  *
- * For example, in an app with the `substrate-native`, `evm-native`, `substrate-orml` and `evm-erc20` plugins:
+ * For example, in an app with the `substrate-native`, `evm-native`, `substrate-tokens` and `evm-erc20` plugins:
  *
- *     type BalanceJson = SubNativeBalance | EvmNativeBalance | SubOrmlBalance | EvmErc20Balance
+ *     type BalanceJson = SubNativeBalance | EvmNativeBalance | SubTokensBalance | EvmErc20Balance
  *
  * If `BalanceTypes` is empty then `BalanceJson` will fall back to the common `IBalance` interface, which every balance must implement.
  */
 export type BalanceJson = BalanceTypes[keyof BalanceTypes] extends never ? IBalance : BalanceTypes[keyof BalanceTypes];
 /** A collection of `BalanceJson` objects */
 export type BalanceJsonList = Record<string, BalanceJson>;
-export type BalanceStatusLive = `live-${string}`;
-export declare const BalanceStatusLive: (subscriptionId: string) => BalanceStatusLive;
-export type BalanceStatus = BalanceStatusLive | "live" | "cache" | "stale";
-/** `IBalance` is a common interface which all balance types must implement. */
-export type IBalance = {
+export type BalanceStatus = "live" | "cache" | "stale";
+type IBalanceBase = {
     /** The module that this balance was retrieved by */
     source: string;
-    /**
-     * For modules which fetch balances via module sources, this is the sub-source
-     * e.g. `staking` or `crowdloans`
-     **/
-    subSource?: string;
+    useLegacyTransferableCalculation?: boolean;
     /** Has this balance never been fetched, or is it from a cache, or is it up to date? */
     status: BalanceStatus;
     /** The address of the account which owns this balance */
     address: Address;
     /** The token this balance is for */
     tokenId: TokenId;
+};
+type IBalanceBaseEvm = {
     /** WIP, use `chainId` or `evmNetworkId` for now */
-    multiChainId: MultiChainId;
-    /** The substrate chain this balance is on */
-    chainId?: ChainId;
+    multiChainId: EvmChainId;
     /** The evm chain this balance is on */
-    evmNetworkId?: EvmNetworkId;
-} & IBalanceAmounts;
-export type IBalanceAmounts = {
-    /** The portion of a balance that is not reserved. The free balance is the only balance that matters for most operations. */
-    free?: Amount | AmountWithLabel<string> | Array<AmountWithLabel<string>>;
-    /** The portion of a balance that is owned by the account but is reserved/suspended/unavailable. Reserved balance can still be slashed, but only after all the free balance has been slashed. */
-    reserves?: Amount | AmountWithLabel<string> | Array<AmountWithLabel<string>>;
-    /** A freeze on a specified amount of an account's free balance until a specified block number. Multiple locks always operate over the same funds, so they overlay rather than stack. */
-    locks?: Amount | LockedAmount<string> | Array<LockedAmount<string>>;
-    /** Additional balances held by an account. By default these will not be included in the account total. Dapps may choose to add support for showing extra amounts on a case by case basis. */
-    extra?: ExtraAmount<string> | Array<ExtraAmount<string>>;
+    evmNetworkId: EvmNetworkId;
+};
+type IBalanceBaseSubstrate = {
+    multiChainId: SubChainId;
+    /** The substrate chain this balance is on */
+    chainId: ChainId;
 };
+type IBalanceSimpleValues = {
+    /** For balance types with a simple value, this is the value of the balance (eg, evm native token balance) */
+    value: Amount;
+    values?: Array<AmountWithLabel<string>>;
+};
+type IBalanceComplexValues = {
+    /** For balance types with multple possible states, these are the values of the balance (eg, substrate native token balance) */
+    values: Array<AmountWithLabel<string>>;
+    value?: undefined;
+};
+/** `IBalance` is a common interface which all balance types must implement. */
+export type IBalance = IBalanceBase & (IBalanceSimpleValues | IBalanceComplexValues) & (IBalanceBaseEvm | IBalanceBaseSubstrate);
+export type EvmBalance = IBalanceBase & IBalanceBaseEvm & (IBalanceSimpleValues | IBalanceComplexValues);
+export type SubstrateBalance = IBalanceBase & IBalanceBaseSubstrate & (IBalanceSimpleValues | IBalanceComplexValues);
 /** An unlabelled amount of a balance */
 export type Amount = string;
+export type BalanceStatusTypes = "free" | "reserved" | "locked" | "extra" | "crowdloan" | "nompool" | "subtensor";
 /** A labelled amount of a balance */
-export type AmountWithLabel<TLabel extends string> = {
+type BaseAmountWithLabel<TLabel extends string> = {
+    type: BalanceStatusTypes;
+    /**
+     * For modules which fetch balances via module sources, the source is equivalent to previous 'subSource' field
+     * on the parent balance object
+     * e.g. `staking` or `crowdloans`
+     **/
+    source?: string;
     label: TLabel;
     amount: Amount;
     meta?: unknown;
 };
+export declare const getValueId: (amount: AmountWithLabel<string>) => string;
 /** A labelled locked amount of a balance */
-export type LockedAmount<TLabel extends string> = AmountWithLabel<TLabel> & {
+export type LockedAmount<TLabel extends string> = BaseAmountWithLabel<TLabel> & {
     /**
      * By default, the largest locked amount is subtrated from the transferable amount of this balance.
      * If this property is set to true, this particular lock will be skipped when making this calculation.
@@ -82,15 +93,15 @@ export type LockedAmount<TLabel extends string> = AmountWithLabel<TLabel> & {
      */
     excludeFromFeePayable?: boolean;
 };
-export declare function excludeFromTransferableAmount(locks: Amount | LockedAmount<string> | Array<LockedAmount<string>>): bigint;
-export declare function excludeFromFeePayableLocks(locks: Amount | LockedAmount<string> | Array<LockedAmount<string>>): Array<LockedAmount<string>>;
+export type AmountWithLabel<TLabel extends string> = BaseAmountWithLabel<TLabel> | LockedAmount<TLabel> | ExtraAmount<TLabel>;
 /** A labelled extra amount of a balance */
-export type ExtraAmount<TLabel extends string> = AmountWithLabel<TLabel> & {
+export type ExtraAmount<TLabel extends string> = BaseAmountWithLabel<TLabel> & {
+    type: "extra";
     /** If set to true, this extra amount will be included in the calculation of the total amount of this balance. */
     includeInTotal?: boolean;
 };
-export declare function includeInTotalExtraAmount(extra?: ExtraAmount<string> | Array<ExtraAmount<string>>): bigint;
 /** Used by plugins to help define their custom `BalanceType` */
-export type NewBalanceType<TModuleType extends string, T extends IBalanceAmounts> = IBalance & {
+export type NewBalanceType<TModuleType extends string, TBalanceValueType extends "simple" | "complex", TNetworkType extends "ethereum" | "substrate"> = IBalanceBase & (TBalanceValueType extends "simple" ? IBalanceSimpleValues : IBalanceComplexValues) & (TNetworkType extends "ethereum" ? IBalanceBaseEvm : IBalanceBaseSubstrate) & {
     source: TModuleType;
-} & T;
+};
+export {};

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

@@ -1,4 +1,5 @@
 export * from "./addresses";
 export * from "./balances";
 export * from "./balancetypes";
+export * from "./minimetadatas";
 export * from "./subscriptions";

package/dist/declarations/src/types/minimetadatas.d.ts

@@ -0,0 +1,33 @@
+import { ChainId } from "@talismn/chaindata-provider";
+/** For fast db access, you can calculate the primary key for a miniMetadata using this method */
+export declare const deriveMiniMetadataId: ({ source, chainId, specName, specVersion, balancesConfig, }: Pick<MiniMetadata, "source" | "chainId" | "specName" | "specVersion" | "balancesConfig">) => string;
+export type MiniMetadataStatus = 
+/** Metadata is up to date */
+"good"
+/** Metadata exists, but needs to be updated */
+ | "outdated"
+/** Metadata doesn't exist */
+ | "none";
+export type MiniMetadata = {
+    /** The DB id for this metadata */
+    id: string;
+    /** The balance module which created this miniMetadata */
+    source: string;
+    /** The chain this miniMetadata came from */
+    chainId: ChainId;
+    /** The chain specName which this miniMetadata is valid for */
+    specName: string;
+    /** The chain specVersion which this miniMetadata is valid for */
+    specVersion: string;
+    /** The JSON-encoded chain balancesConfig which this miniMetadata is valid for */
+    balancesConfig: string;
+    /** The version of the metadata format e.g. 13, 14, 15, etc */
+    version: number;
+    /** The miniMetadata encoded as a hex string */
+    data: `0x${string}` | null;
+    /**
+     * Some balance modules need a little bit of extra data in addition to the miniMetadata.
+     * They can store that data as a JSON-encoded string here.
+     */
+    extra: string;
+};

package/dist/declarations/src/upgrades/2024-01-25-upgradeRemoveSymbolFromNativeTokenId.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from "dexie";
+export declare const upgradeRemoveSymbolFromNativeTokenId: (tx: Transaction) => Promise<void>;

package/dist/declarations/src/upgrades/2024-03-19-upgradeBalancesDataBlob.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from "dexie";
+export declare const upgradeBalancesDataBlob: (tx: Transaction) => Promise<void>;

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

@@ -0,0 +1,2 @@
+export * from "./2024-01-25-upgradeRemoveSymbolFromNativeTokenId";
+export * from "./2024-03-19-upgradeBalancesDataBlob";

package/dist/declarations/src/util/hydrateChaindata.d.ts

@@ -0,0 +1,8 @@
+import { EvmTokenFetcher, MiniMetadataUpdater } from "@talismn/balances";
+import { ChaindataProvider } from "@talismn/chaindata-provider";
+/** Pulls the latest chaindata from https://github.com/TalismanSociety/chaindata */
+export declare const hydrateChaindataAndMiniMetadata: (chaindataProvider: ChaindataProvider, miniMetadataUpdater: MiniMetadataUpdater) => Promise<void>;
+/** Builds any missing miniMetadatas (e.g. for the user's custom substrate chains) */
+export declare const updateCustomMiniMetadata: (chaindataProvider: ChaindataProvider, miniMetadataUpdater: MiniMetadataUpdater) => Promise<void>;
+/** Fetches any missing Evm Tokens */
+export declare const updateEvmTokens: (chaindataProvider: ChaindataProvider, evmTokenFetcher: EvmTokenFetcher) => Promise<void>;

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

@@ -0,0 +1 @@
+export * from "./hydrateChaindata";