@talismn/chaindata-provider 0.7.0 → 0.8.1

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

@@ -1,18 +1,91 @@
-import { Chain, ChainId, ChainList, CustomChain, CustomEvmNetwork, EvmNetwork, EvmNetworkId, EvmNetworkList, Token, TokenId, TokenList } from "./types";
-export interface ChaindataChainProvider {
-    chainIds(): Promise<ChainId[]>;
-    chains(): Promise<ChainList>;
-    getChain(chainIdOrQuery: ChainId | Partial<Chain>): Promise<Chain | CustomChain | null>;
-}
-export interface ChaindataEvmNetworkProvider {
-    evmNetworkIds(): Promise<EvmNetworkId[]>;
-    evmNetworks(): Promise<EvmNetworkList>;
-    getEvmNetwork(evmNetworkIdOrQuery: EvmNetworkId | Partial<EvmNetwork>): Promise<EvmNetwork | CustomEvmNetwork | null>;
-}
-export interface ChaindataTokenProvider {
-    tokenIds(): Promise<TokenId[]>;
-    tokens(): Promise<TokenList>;
-    getToken(tokenIdOrQuery: TokenId | Partial<Token>): Promise<Token | null>;
-}
-export interface ChaindataProvider extends ChaindataChainProvider, ChaindataEvmNetworkProvider, ChaindataTokenProvider {
+import { Transaction, TransactionMode } from "dexie";
+import { ReplaySubject } from "rxjs";
+import { Chain, ChainId, CustomChain, CustomEvmNetwork, EvmNetwork, EvmNetworkId, IChaindataProvider, Token, TokenId } from "./types";
+export type ChaindataProviderOptions = {
+    onfinalityApiKey?: string;
+};
+export declare class ChaindataProvider implements IChaindataProvider {
+    #private;
+    constructor(options?: ChaindataProviderOptions);
+    destroy(): void;
+    setOnfinalityApiKey(apiKey: string | undefined): void;
+    chainsObservable: ReplaySubject<(Chain | CustomChain)[]>;
+    chains(): Promise<(Chain | CustomChain)[]>;
+    evmNetworksObservable: ReplaySubject<(EvmNetwork | CustomEvmNetwork)[]>;
+    evmNetworks(): Promise<(EvmNetwork | CustomEvmNetwork)[]>;
+    tokensObservable: ReplaySubject<Token[]>;
+    tokens(): Promise<Token[]>;
+    get customChainsObservable(): import("rxjs").Observable<CustomChain[]>;
+    customChains(): Promise<CustomChain[]>;
+    get customEvmNetworksObservable(): import("rxjs").Observable<CustomEvmNetwork[]>;
+    customEvmNetworks(): Promise<CustomEvmNetwork[]>;
+    get customTokensObservable(): import("rxjs").Observable<Token[]>;
+    customTokens(): Promise<Token[]>;
+    get chainIdsObservable(): import("rxjs").Observable<string[]>;
+    chainIds(): Promise<string[]>;
+    get evmNetworkIdsObservable(): import("rxjs").Observable<string[]>;
+    evmNetworkIds(): Promise<string[]>;
+    get tokenIdsObservable(): import("rxjs").Observable<string[]>;
+    tokenIds(): Promise<string[]>;
+    get chainsByIdObservable(): import("rxjs").Observable<Record<string, Chain | CustomChain>>;
+    chainsById(): Promise<Record<string, Chain | CustomChain>>;
+    get evmNetworksByIdObservable(): import("rxjs").Observable<Record<string, EvmNetwork | CustomEvmNetwork>>;
+    evmNetworksById(): Promise<Record<string, EvmNetwork | CustomEvmNetwork>>;
+    get tokensByIdObservable(): import("rxjs").Observable<Record<string, Token>>;
+    tokensById(): Promise<Record<string, Token>>;
+    tokensByIdForType<TokenType extends Token["type"]>(type: TokenType): Promise<Record<string, Token>>;
+    get chainsByGenesisHashObservable(): import("rxjs").Observable<Record<string, Chain | CustomChain>>;
+    chainsByGenesisHash(): Promise<Record<string, Chain | CustomChain>>;
+    chainById(chainId: ChainId): Promise<Chain | null>;
+    chainByGenesisHash(genesisHash: `0x${string}`): Promise<Chain | null>;
+    evmNetworkById(evmNetworkId: EvmNetworkId): Promise<EvmNetwork | null>;
+    tokenById(tokenId: TokenId): Promise<Token | null>;
+    addCustomChain(customChain: CustomChain): Promise<string | undefined>;
+    removeCustomChain(chainId: ChainId): Promise<number>;
+    setCustomChains(chains: CustomChain[]): Promise<void>;
+    resetChain(chainId: ChainId): Promise<void>;
+    addCustomEvmNetwork(customEvmNetwork: CustomEvmNetwork): Promise<string | void>;
+    removeCustomEvmNetwork(evmNetworkId: EvmNetworkId): Promise<void>;
+    setCustomEvmNetworks(networks: CustomEvmNetwork[]): Promise<void>;
+    resetEvmNetwork(evmNetworkId: EvmNetworkId): Promise<void>;
+    addCustomToken(customToken: Token): Promise<string | void>;
+    removeCustomToken(tokenId: TokenId): Promise<number>;
+    setCustomTokens(tokens: Token[]): Promise<void>;
+    removeToken(tokenId: TokenId): Promise<void>;
+    /**
+     * Hydrate the db with the latest chaindata from subsquid.
+     *
+     * @returns A promise which resolves to true if any db table has been hydrated, or false if all hydration has been skipped.
+     */
+    hydrate({ tokensArgs, }?: {
+        chainsArgs?: Parameters<ChaindataProvider["hydrateChains"]>;
+        evmNetworksArgs?: Parameters<ChaindataProvider["hydrateEvmNetworks"]>;
+        tokensArgs?: Parameters<ChaindataProvider["hydrateSubstrateTokens"]>;
+    }): Promise<boolean>;
+    /**
+     * Hydrate the db with the latest chains from subsquid.
+     * Hydration is skipped when the last successful hydration was less than minimumHydrationInterval ms ago.
+     *
+     * @returns A promise which resolves to true if the db has been hydrated, or false if the hydration was skipped.
+     */
+    hydrateChains(): Promise<boolean>;
+    /**
+     * Hydrate the db with the latest evmNetworks from subsquid.
+     * Hydration is skipped when the last successful hydration was less than minimumHydrationInterval ms ago.
+     *
+     * @returns A promise which resolves to true if the db has been hydrated, or false if the hydration was skipped.
+     */
+    hydrateEvmNetworks(): Promise<boolean>;
+    updateChainTokens(chainId: ChainId, source: string, newTokens: Token[], availableTokenLogoFilenames: string[]): Promise<void>;
+    updateEvmNetworkTokens(newTokens: Token[]): Promise<void>;
+    /**
+     * Hydrate the db with the latest tokens from subsquid.
+     * Hydration is skipped when the last successful hydration was less than minimumHydrationInterval ms ago.
+     *
+     * @returns A promise which resolves to true if the db has been hydrated, or false if the hydration was skipped.
+     */
+    hydrateSubstrateTokens(chainIdFilter?: ChainId[]): Promise<boolean>;
+    getIsBuiltInChain(chainId: ChainId): Promise<boolean>;
+    getIsBuiltInEvmNetwork(evmNetworkId: EvmNetworkId): Promise<boolean>;
+    transaction<U>(mode: TransactionMode, tables: string[], scope: (trans: Transaction) => PromiseLike<U> | U): Promise<U>;
 }

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

@@ -0,0 +1,9 @@
+import { Dexie } from "dexie";
+import { Chain, ChainId, CustomChain, CustomEvmNetwork, EvmNetwork, EvmNetworkId, Token, TokenId } from "./types";
+export declare class TalismanChaindataDatabase extends Dexie {
+    chains: Dexie.Table<Chain | CustomChain, ChainId>;
+    evmNetworks: Dexie.Table<EvmNetwork | CustomEvmNetwork, EvmNetworkId>;
+    tokens: Dexie.Table<Token, TokenId>;
+    constructor();
+}
+export declare const db: TalismanChaindataDatabase;

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

@@ -0,0 +1,26 @@
+import { ChainId, EvmNetworkId, TokenId } from "./types";
+export declare const githubApi = "https://api.github.com";
+export declare const githubCdn = "https://raw.githubusercontent.com";
+export declare const githubChaindataOrg = "TalismanSociety";
+export declare const githubChaindataRepo = "chaindata";
+export declare const githubChaindataBranch = "main";
+export declare const githubChaindataDistDir = "pub/v2";
+export declare const githubChaindataBaseUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main";
+export declare const githubChaindataDistUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2";
+export declare const githubChaindataChainsAssetsDir = "assets/chains";
+export declare const githubChaindataTokensAssetsDir = "assets/tokens";
+export declare const githubChainLogoUrl: (chainId: ChainId) => string;
+export declare const githubEvmNetworkLogoUrl: (networkId: EvmNetworkId) => string;
+export declare const githubTokenLogoUrl: (tokenId: TokenId) => string;
+export declare const githubUnknownChainLogoUrl: string;
+export declare const githubUnknownTokenLogoUrl: string;
+export declare const chaindataChainsAllUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2/chains/all.json";
+export declare const chaindataChainsSummaryUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2/chains/summary.json";
+export declare const chaindataChainByIdUrl: (chainId: string) => string;
+export declare const chaindataChainByGenesisHashUrl: (genesisHash: string) => string;
+export declare const chaindataEvmNetworksAllUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2/evmNetworks/all.json";
+export declare const chaindataEvmNetworksSummaryUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2/evmNetworks/summary.json";
+export declare const chaindataEvmNetworkByIdUrl: (evmNetworkId: string) => string;
+export declare const chaindataTokensAllUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2/tokens/all.json";
+export declare const chaindataTokenByIdUrl: (tokenId: string) => string;
+export declare const chaindataMiniMetadatasAllUrl = "https://raw.githubusercontent.com/TalismanSociety/chaindata/main/pub/v2/miniMetadatas/all.json";

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

@@ -1,3 +1,6 @@
-export * from "./ChaindataProvider";
+export * from "./constants";
+export * from "./init";
+export * from "./net";
 export * from "./types";
-export * from "./github";
+export * from "./util";
+export * from "./ChaindataProvider";

package/dist/declarations/src/init/chains.d.ts

@@ -0,0 +1,243 @@
+export declare const chains: ({
+    id: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    sortIndex: number;
+    genesisHash: string;
+    prefix: number;
+    name: string;
+    themeColor: string;
+    logo: string;
+    chainName: string;
+    chainType: string;
+    implName: string;
+    specName: string;
+    specVersion: string;
+    nativeToken: {
+        id: string;
+    };
+    tokens: {
+        id: string;
+    }[];
+    account: string;
+    subscanUrl: string;
+    chainspecQrUrl: string;
+    latestMetadataQrUrl: string;
+    isUnknownFeeToken: boolean;
+    feeToken: null;
+    rpcs: {
+        url: string;
+    }[];
+    evmNetworks: never[];
+    parathreads: {
+        id: string;
+        paraId: number;
+        name: string;
+    }[];
+    paraId: null;
+    relay: null;
+    balancesConfig: {
+        moduleType: string;
+        moduleConfig: {
+            coingeckoId: string;
+            dcentName: string;
+            logo: string;
+        };
+    }[];
+    balancesMetadata: never[];
+    hasCheckMetadataHash: boolean;
+    oldPrefix?: undefined;
+} | {
+    id: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    sortIndex: number;
+    genesisHash: string;
+    prefix: number;
+    name: string;
+    themeColor: string;
+    logo: string;
+    chainName: string;
+    chainType: string;
+    implName: string;
+    specName: string;
+    specVersion: string;
+    nativeToken: {
+        id: string;
+    };
+    tokens: {
+        id: string;
+    }[];
+    account: string;
+    subscanUrl: string;
+    chainspecQrUrl: string;
+    latestMetadataQrUrl: string;
+    isUnknownFeeToken: boolean;
+    feeToken: null;
+    rpcs: {
+        url: string;
+    }[];
+    evmNetworks: never[];
+    parathreads: {
+        id: string;
+        paraId: number;
+        name: string;
+    }[];
+    paraId: null;
+    relay: null;
+    balancesConfig: {
+        moduleType: string;
+        moduleConfig: {
+            coingeckoId: string;
+            logo: string;
+        };
+    }[];
+    balancesMetadata: never[];
+    hasCheckMetadataHash: boolean;
+    oldPrefix?: undefined;
+} | {
+    id: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    sortIndex: number;
+    genesisHash: string;
+    prefix: number;
+    name: string;
+    themeColor: string;
+    logo: string;
+    chainName: string;
+    chainType: string;
+    implName: string;
+    specName: string;
+    specVersion: string;
+    nativeToken: {
+        id: string;
+    };
+    tokens: {
+        id: string;
+    }[];
+    account: string;
+    subscanUrl: string;
+    chainspecQrUrl: string;
+    latestMetadataQrUrl: string;
+    isUnknownFeeToken: boolean;
+    feeToken: null;
+    rpcs: {
+        url: string;
+    }[];
+    evmNetworks: never[];
+    parathreads: null;
+    paraId: number;
+    relay: {
+        id: string;
+    };
+    balancesConfig: ({
+        moduleType: string;
+        moduleConfig: {
+            coingeckoId: string;
+            logo: string;
+            tokens?: undefined;
+        };
+    } | {
+        moduleType: string;
+        moduleConfig: {
+            tokens: ({
+                assetId: number;
+                symbol: string;
+                coingeckoId: string;
+                logo: string;
+            } | {
+                assetId: number;
+                symbol: string;
+                logo: string;
+                coingeckoId?: undefined;
+            })[];
+            coingeckoId?: undefined;
+            logo?: undefined;
+        };
+    })[];
+    balancesMetadata: never[];
+    hasCheckMetadataHash: boolean;
+    oldPrefix?: undefined;
+} | {
+    id: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    sortIndex: number;
+    genesisHash: string;
+    prefix: number;
+    oldPrefix: number;
+    name: string;
+    themeColor: string;
+    logo: string;
+    chainName: string;
+    chainType: string;
+    implName: string;
+    specName: string;
+    specVersion: string;
+    nativeToken: {
+        id: string;
+    };
+    tokens: {
+        id: string;
+    }[];
+    account: string;
+    subscanUrl: string;
+    chainspecQrUrl: string;
+    latestMetadataQrUrl: string;
+    isUnknownFeeToken: boolean;
+    feeToken: null;
+    rpcs: {
+        url: string;
+    }[];
+    evmNetworks: never[];
+    parathreads: null;
+    paraId: number;
+    relay: {
+        id: string;
+    };
+    balancesConfig: ({
+        moduleType: string;
+        moduleConfig: {
+            coingeckoId: string;
+            logo: string;
+            tokens?: undefined;
+        };
+    } | {
+        moduleType: string;
+        moduleConfig: {
+            tokens: ({
+                assetId: number;
+                symbol: string;
+                coingeckoId: string;
+                logo: string;
+            } | {
+                assetId: number;
+                symbol: string;
+                logo: string;
+                coingeckoId?: undefined;
+            })[];
+            coingeckoId?: undefined;
+            logo?: undefined;
+        };
+    } | {
+        moduleType: string;
+        moduleConfig: {
+            tokens: ({
+                onChainId: string;
+                symbol: string;
+                coingeckoId: string;
+                logo: string;
+            } | {
+                onChainId: string;
+                symbol: string;
+                logo: string;
+                coingeckoId?: undefined;
+            })[];
+            coingeckoId?: undefined;
+            logo?: undefined;
+        };
+    })[];
+    balancesMetadata: never[];
+    hasCheckMetadataHash: boolean;
+})[];

package/dist/declarations/src/init/evm-networks.d.ts

@@ -0,0 +1,61 @@
+export declare const evmNetworks: {
+    id: string;
+    isTestnet: boolean;
+    sortIndex: number;
+    name: string;
+    themeColor: string;
+    logo: string;
+    nativeToken: null;
+    tokens: never[];
+    explorerUrl: string;
+    rpcs: {
+        url: string;
+    }[];
+    substrateChain: null;
+    feeType: string;
+    erc20aggregator: string;
+    balancesConfig: ({
+        moduleType: string;
+        moduleConfig: {
+            coingeckoId: string;
+            dcentName: string;
+            symbol: string;
+            decimals: number;
+            logo: string;
+            tokens?: undefined;
+            pools?: undefined;
+        };
+    } | {
+        moduleType: string;
+        moduleConfig: {
+            tokens: {
+                symbol: string;
+                contractAddress: string;
+                coingeckoId: string;
+                isDefault: boolean;
+                decimals: number;
+                logo: string;
+            }[];
+            coingeckoId?: undefined;
+            dcentName?: undefined;
+            symbol?: undefined;
+            decimals?: undefined;
+            logo?: undefined;
+            pools?: undefined;
+        };
+    } | {
+        moduleType: string;
+        moduleConfig: {
+            pools: never[];
+            logo: string;
+            coingeckoId?: undefined;
+            dcentName?: undefined;
+            symbol?: undefined;
+            decimals?: undefined;
+            tokens?: undefined;
+        };
+    })[];
+    balancesMetadata: never[];
+    isDefault: boolean;
+    forceScan: boolean;
+}[];

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

@@ -0,0 +1,5 @@
+import type { Chain, EvmNetwork, Token } from "../types";
+export declare const fetchInitChains: () => Promise<Chain[]>;
+export declare const fetchInitEvmNetworks: () => Promise<EvmNetwork[]>;
+export declare const fetchInitSubstrateTokens: () => Promise<Token[]>;
+export declare const fetchInitMiniMetadatas: () => Promise<any[]>;

package/dist/declarations/src/init/mini-metadatas.d.ts

@@ -0,0 +1,21 @@
+export declare const miniMetadatas: ({
+    id: string;
+    source: string;
+    chainId: string;
+    specName: string;
+    specVersion: string;
+    balancesConfig: string;
+    extra: string;
+    version?: undefined;
+    data?: undefined;
+} | {
+    id: string;
+    source: string;
+    chainId: string;
+    specName: string;
+    specVersion: string;
+    balancesConfig: string;
+    version: number;
+    data: string;
+    extra: string;
+})[];

package/dist/declarations/src/init/tokens.d.ts

@@ -0,0 +1,103 @@
+export declare const tokens: ({
+    id: string;
+    type: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    symbol: string;
+    decimals: number;
+    logo: string;
+    existentialDeposit: string;
+    assetId: string;
+    isFrozen: boolean;
+    chain: {
+        id: string;
+    };
+    coingeckoId?: undefined;
+    onChainId?: undefined;
+    dcentName?: undefined;
+} | {
+    id: string;
+    type: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    symbol: string;
+    decimals: number;
+    logo: string;
+    existentialDeposit: string;
+    assetId: string;
+    isFrozen: boolean;
+    chain: {
+        id: string;
+    };
+    coingeckoId: string;
+    onChainId?: undefined;
+    dcentName?: undefined;
+} | {
+    id: string;
+    type: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    symbol: string;
+    decimals: number;
+    logo: string;
+    existentialDeposit: string;
+    chain: {
+        id: string;
+    };
+    coingeckoId: string;
+    assetId?: undefined;
+    isFrozen?: undefined;
+    onChainId?: undefined;
+    dcentName?: undefined;
+} | {
+    id: string;
+    type: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    symbol: string;
+    decimals: number;
+    logo: string;
+    existentialDeposit: string;
+    onChainId: string;
+    isFrozen: boolean;
+    chain: {
+        id: string;
+    };
+    coingeckoId: string;
+    assetId?: undefined;
+    dcentName?: undefined;
+} | {
+    id: string;
+    type: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    symbol: string;
+    decimals: number;
+    logo: string;
+    existentialDeposit: string;
+    onChainId: string;
+    isFrozen: boolean;
+    chain: {
+        id: string;
+    };
+    assetId?: undefined;
+    coingeckoId?: undefined;
+    dcentName?: undefined;
+} | {
+    id: string;
+    type: string;
+    isTestnet: boolean;
+    isDefault: boolean;
+    symbol: string;
+    decimals: number;
+    logo: string;
+    existentialDeposit: string;
+    chain: {
+        id: string;
+    };
+    coingeckoId: string;
+    dcentName: string;
+    assetId?: undefined;
+    isFrozen?: undefined;
+    onChainId?: undefined;
+})[];

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

@@ -0,0 +1,2 @@
+declare const _default: import("anylogger").Logger<import("anylogger").BaseLevels>;
+export default _default;

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

@@ -0,0 +1,8 @@
+export declare const fetchChains: () => Promise<any>;
+export declare const fetchChain: (chainId: string) => Promise<any>;
+export declare const fetchEvmNetworks: () => Promise<any>;
+export declare const fetchEvmNetwork: (evmNetworkId: string) => Promise<any>;
+export declare const fetchSubstrateTokens: () => Promise<any>;
+export declare const fetchSubstrateToken: (tokenId: string) => Promise<any>;
+export declare const fetchMiniMetadatas: () => Promise<any>;
+export declare const availableTokenLogoFilenames: () => Promise<string[]>;

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

@@ -1,17 +1,22 @@
 import { EvmNetworkId } from "./EvmNetwork";
 import { TokenId } from "./Token";
-export type ChainList = Record<ChainId, Chain | CustomChain>;
+export type ChainList = Record<ChainId, Chain>;
 export type ChainId = string;
 export type Chain = {
     id: ChainId;
     isTestnet: boolean;
+    isDefault: boolean;
     sortIndex: number | null;
     genesisHash: `0x${string}` | null;
     prefix: number | null;
+    oldPrefix?: number;
     name: string | null;
     themeColor: string | null;
     logo: string | null;
     chainName: string | null;
+    chainType: "Development" | "Local" | "Live" | {
+        Custom: string;
+    } | string | null;
     implName: string | null;
     specName: string | null;
     specVersion: string | null;
@@ -26,24 +31,56 @@ export type Chain = {
     chainspecQrUrl: string | null;
     latestMetadataQrUrl: string | null;
     isUnknownFeeToken: boolean;
+    feeToken: string | null;
     rpcs: Array<SubstrateRpc> | null;
-    isHealthy: boolean;
     evmNetworks: Array<{
         id: EvmNetworkId;
     }>;
     parathreads: Array<Pick<Chain, "id" | "paraId" | "name">> | null;
     paraId: number | null;
     relay: Pick<Chain, "id"> | null;
-    balanceMetadata: Array<BalanceMetadata>;
+    balancesConfig: Array<BalancesConfig>;
+    /** @deprecated has its own store now */
+    balancesMetadata: Array<BalancesMetadata>;
+    /** Indicates if the chain has the `CheckMetadataHash` extension, enabling signing with the ledger generic app */
+    hasCheckMetadataHash?: boolean;
+    /**
+     * Some chains require a 1-byte prefix on transaction signatures to indicate the signing algo used:
+     *
+     * - Ed25519:  `0x00`
+     * - Sr25519:  `0x01`
+     * - Ecdsa:    `0x02`
+     * - Ethereum: `0x03`
+     *
+     * Polkadot.js tries to auto-detect whether to add this prefix or not,
+     * as part of the `GenericExtrinsicPayload.sign` method:
+     * - https://github.com/polkadot-js/api/blob/778d79a/packages/types/src/extrinsic/v4/ExtrinsicPayload.ts#L37-L39
+     * - https://github.com/polkadot-js/api/blob/778d79a/packages/types/src/extrinsic/v4/ExtrinsicPayload.ts#L122-L129
+     *
+     * However, on some chains this auto-detection results in either a false-positive or false-negative.
+     *
+     * By leveraging the generic extrinsic sign function from `@polkadot/types/extrinsic/util`:
+     * - https://github.com/polkadot-js/api/blob/778d79a/packages/types/src/extrinsic/util.ts#L9-L15
+     *
+     * We can specify whether or not to include the signature prefix, based on the value of this `hasExtrinsicSignatureTypePrefix` property.
+     */
+    hasExtrinsicSignatureTypePrefix?: boolean;
+    /** Custom types to be registered in the TypeRegistry */
+    signedExtensions?: any;
+    /** Custom signed extensions to be registered in the Metadata object */
+    registryTypes?: any;
 };
 export type CustomChain = Chain & {
     isCustom: true;
 };
 export type SubstrateRpc = {
     url: string;
-    isHealthy: boolean;
 };
-export type BalanceMetadata = {
+export type BalancesConfig = {
+    moduleType: string;
+    moduleConfig: unknown;
+};
+export type BalancesMetadata = {
     moduleType: string;
     metadata: unknown;
 };