@paraspell/sdk 3.0.5 → 3.0.7

package/dist/index.d.ts

@@ -1,72 +1,79 @@
 import { ApiPromise } from '@polkadot/api';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
-import * as _polkadot_apps_config_endpoints_types from '@polkadot/apps-config/endpoints/types';
 
 declare abstract class ParachainNode {
-    private _node;
-    private _name;
-    private _type;
-    private _version;
+    private readonly _node;
+    private readonly _name;
+    private readonly _type;
+    private readonly _version;
+    protected _assetCheckEnabled: boolean;
     constructor(node: TNode, name: string, type: TRelayChainType, version: Version);
     get name(): string;
     get type(): TRelayChainType;
-    get node(): "AssetHubPolkadot" | "Acala" | "Astar" | "BifrostPolkadot" | "Bitgreen" | "Centrifuge" | "Clover" | "ComposableFinance" | "Darwinia" | "HydraDX" | "Interlay" | "Kylin" | "Litentry" | "Moonbeam" | "Parallel" | "AssetHubKusama" | "Encointer" | "Altair" | "Amplitude" | "Bajun" | "Basilisk" | "BifrostKusama" | "Pioneer" | "Calamari" | "CrustShadow" | "Crab" | "Imbue" | "Integritee" | "InvArchTinker" | "Karura" | "Kintsugi" | "Litmus" | "Mangata" | "Moonriver" | "ParallelHeiko" | "Picasso" | "Quartz" | "Robonomics" | "Shiden" | "Turing" | "Equilibrium" | "Unique" | "Crust" | "Manta" | "Genshiro" | "Nodle" | "OriginTrail" | "Pendulum" | "Polkadex" | "Zeitgeist";
+    get node(): TNode;
     get version(): Version;
-    transfer(api: ApiPromise, currencySymbol: string | undefined, currencyId: string | undefined, amount: any, to: string, destination?: TNode, serializedApiCallEnabled?: boolean): Extrinsic | TSerializedApiCall;
+    get assetCheckEnabled(): boolean;
+    transfer(api: ApiPromise, currencySymbol: string | undefined, currencyId: string | undefined, amount: string, to: string, destination?: TNode, serializedApiCallEnabled?: boolean): Extrinsic | TSerializedApiCall;
+    transferRelayToPara(options: TTransferRelayToParaOptions): TSerializedApiCall;
+    getProvider(): string;
+    createApiInstance(): Promise<ApiPromise>;
 }
 
 declare const NODE_NAMES: readonly ["AssetHubPolkadot", "Acala", "Astar", "BifrostPolkadot", "Bitgreen", "Centrifuge", "Clover", "ComposableFinance", "Darwinia", "HydraDX", "Interlay", "Kylin", "Litentry", "Moonbeam", "Parallel", "AssetHubKusama", "Encointer", "Altair", "Amplitude", "Bajun", "Basilisk", "BifrostKusama", "Pioneer", "Calamari", "CrustShadow", "Crab", "Imbue", "Integritee", "InvArchTinker", "Karura", "Kintsugi", "Litmus", "Mangata", "Moonriver", "ParallelHeiko", "Picasso", "Quartz", "Robonomics", "Shiden", "Turing", "Equilibrium", "Unique", "Crust", "Manta", "Genshiro", "Nodle", "OriginTrail", "Pendulum", "Polkadex", "Zeitgeist"];
+declare const NODES_WITH_RELAY_CHAINS: readonly ["AssetHubPolkadot", "Acala", "Astar", "BifrostPolkadot", "Bitgreen", "Centrifuge", "Clover", "ComposableFinance", "Darwinia", "HydraDX", "Interlay", "Kylin", "Litentry", "Moonbeam", "Parallel", "AssetHubKusama", "Encointer", "Altair", "Amplitude", "Bajun", "Basilisk", "BifrostKusama", "Pioneer", "Calamari", "CrustShadow", "Crab", "Imbue", "Integritee", "InvArchTinker", "Karura", "Kintsugi", "Litmus", "Mangata", "Moonriver", "ParallelHeiko", "Picasso", "Quartz", "Robonomics", "Shiden", "Turing", "Equilibrium", "Unique", "Crust", "Manta", "Genshiro", "Nodle", "OriginTrail", "Pendulum", "Polkadex", "Zeitgeist", "Polkadot", "Kusama"];
 declare const SUPPORTED_PALLETS: readonly ["XTokens", "OrmlXTokens", "PolkadotXcm", "RelayerXcm"];
 
 type UpdateFunction = (name: string, index: number) => string;
 type Extrinsic = SubmittableExtrinsic<'promise'>;
 type ExtrinsicFunction<T> = (arg: T) => Extrinsic;
 type TRelayChainType = 'polkadot' | 'kusama';
+type TRelayChainSymbol = 'DOT' | 'KSM';
 type TNode = (typeof NODE_NAMES)[number];
-type TAssetDetails = {
+type TNodeWithRelayChains = (typeof NODES_WITH_RELAY_CHAINS)[number];
+interface TAssetDetails {
     assetId: string;
     symbol?: string;
     decimals?: number;
-};
-type TNativeAssetDetails = {
+}
+interface TNativeAssetDetails {
     assetId?: string;
     symbol: string;
     decimals: number;
-};
-type TNodeAssets = {
+}
+interface TNodeAssets {
     paraId: number;
-    relayChainAssetSymbol: 'KSM' | 'DOT';
+    relayChainAssetSymbol: TRelayChainSymbol;
     nativeAssets: TNativeAssetDetails[];
     otherAssets: TAssetDetails[];
-};
+}
 type TAssetJsonMap = Record<TNode, TNodeAssets>;
 type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
 type Bool = 'Yes' | 'No';
 type TPallet = (typeof SUPPORTED_PALLETS)[number];
-type TPalletMap = {
+interface TPalletMap {
     defaultPallet: TPallet;
     supportedPallets: TPallet[];
-};
+}
 type TPalletJsonMap = Record<TNode, TPalletMap>;
-type TSerializedApiCall = {
+interface TSerializedApiCall {
     module: string;
     section: string;
     parameters: any[];
-};
-type XTokensTransferInput = {
+}
+interface XTokensTransferInput {
     api: ApiPromise;
     currency: string | undefined;
     currencyID: string | undefined;
-    amount: any;
+    amount: string;
     addressSelection: any;
     fees: number;
     scenario: TScenario;
     serializedApiCallEnabled?: boolean;
-};
+}
 interface IXTokensTransfer {
-    transferXTokens(input: XTokensTransferInput): Extrinsic | TSerializedApiCall;
+    transferXTokens: (input: XTokensTransferInput) => Extrinsic | TSerializedApiCall;
 }
-type PolkadotXCMTransferInput = {
+interface PolkadotXCMTransferInput {
     api: ApiPromise;
     header: any;
     addressSelection: any;
@@ -74,20 +81,26 @@ type PolkadotXCMTransferInput = {
     scenario: TScenario;
     currencySymbol: string | undefined;
     serializedApiCallEnabled?: boolean;
-};
+}
+interface TTransferRelayToParaOptions {
+    api: ApiPromise;
+    destination: TNode;
+    address: string;
+    amount: string;
+}
 interface IPolkadotXCMTransfer {
-    transferPolkadotXCM(input: PolkadotXCMTransferInput): Extrinsic | TSerializedApiCall;
+    transferPolkadotXCM: (input: PolkadotXCMTransferInput) => Extrinsic | TSerializedApiCall;
 }
 declare enum Version {
     V1 = "V1",
     V3 = "V3"
 }
 
-declare const sendSerializedApiCall: (api: ApiPromise, origin: TNode, currencySymbolOrId: string | number | bigint, amount: any, to: string, destination?: TNode) => TSerializedApiCall;
-declare function send(api: ApiPromise, origin: TNode, currencySymbolOrId: string | number | bigint, amount: any, to: string, destination?: TNode): Extrinsic;
-declare const transferRelayToParaCommon: (api: ApiPromise, destination: TNode, amount: any, to: string, serializedApiCallEnabled?: boolean) => Extrinsic | TSerializedApiCall | never;
-declare function transferRelayToPara(api: ApiPromise, destination: TNode, amount: any, to: string): Extrinsic | never;
-declare const transferRelayToParaSerializedApiCall: (api: ApiPromise, destination: TNode, amount: any, to: string) => TSerializedApiCall;
+declare const sendSerializedApiCall: (api: ApiPromise, origin: TNode, currencySymbolOrId: string | number | bigint, amount: string | number | bigint, to: string, destination?: TNode) => TSerializedApiCall;
+declare function send(api: ApiPromise, origin: TNode, currencySymbolOrId: string | number | bigint, amount: string | number | bigint, to: string, destination?: TNode): Extrinsic;
+declare const transferRelayToParaCommon: (api: ApiPromise, destination: TNode, amount: string, address: string, serializedApiCallEnabled?: boolean) => Extrinsic | TSerializedApiCall | never;
+declare function transferRelayToPara(api: ApiPromise, destination: TNode, amount: string | number | bigint, to: string): Extrinsic | never;
+declare const transferRelayToParaSerializedApiCall: (api: ApiPromise, destination: TNode, amount: string | number | bigint, to: string) => TSerializedApiCall;
 
 declare const index$4_send: typeof send;
 declare const index$4_sendSerializedApiCall: typeof sendSerializedApiCall;
@@ -95,13 +108,7 @@ declare const index$4_transferRelayToPara: typeof transferRelayToPara;
 declare const index$4_transferRelayToParaCommon: typeof transferRelayToParaCommon;
 declare const index$4_transferRelayToParaSerializedApiCall: typeof transferRelayToParaSerializedApiCall;
 declare namespace index$4 {
-  export {
-    index$4_send as send,
-    index$4_sendSerializedApiCall as sendSerializedApiCall,
-    index$4_transferRelayToPara as transferRelayToPara,
-    index$4_transferRelayToParaCommon as transferRelayToParaCommon,
-    index$4_transferRelayToParaSerializedApiCall as transferRelayToParaSerializedApiCall,
-  };
+  export { index$4_send as send, index$4_sendSerializedApiCall as sendSerializedApiCall, index$4_transferRelayToPara as transferRelayToPara, index$4_transferRelayToParaCommon as transferRelayToParaCommon, index$4_transferRelayToParaSerializedApiCall as transferRelayToParaSerializedApiCall };
 }
 
 declare function addLiquidity(api: ApiPromise, assetA: number, assetB: number, amountA: any, amountBMaxLimit: any): Extrinsic;
@@ -116,13 +123,7 @@ declare const index$3_createPool: typeof createPool;
 declare const index$3_removeLiquidity: typeof removeLiquidity;
 declare const index$3_sell: typeof sell;
 declare namespace index$3 {
-  export {
-    index$3_addLiquidity as addLiquidity,
-    index$3_buy as buy,
-    index$3_createPool as createPool,
-    index$3_removeLiquidity as removeLiquidity,
-    index$3_sell as sell,
-  };
+  export { index$3_addLiquidity as addLiquidity, index$3_buy as buy, index$3_createPool as createPool, index$3_removeLiquidity as removeLiquidity, index$3_sell as sell };
 }
 
 declare function openChannel(api: ApiPromise, origin: TNode, destination: TNode, maxSize: number, maxMessageSize: number): Extrinsic;
@@ -131,10 +132,7 @@ declare function openChannelSerializedApiCall(api: ApiPromise, origin: TNode, de
 declare const index$2_openChannel: typeof openChannel;
 declare const index$2_openChannelSerializedApiCall: typeof openChannelSerializedApiCall;
 declare namespace index$2 {
-  export {
-    index$2_openChannel as openChannel,
-    index$2_openChannelSerializedApiCall as openChannelSerializedApiCall,
-  };
+  export { index$2_openChannel as openChannel, index$2_openChannelSerializedApiCall as openChannelSerializedApiCall };
 }
 
 declare function closeChannel(api: ApiPromise, origin: TNode, inbound: number, outbound: number): Extrinsic;
@@ -143,22 +141,19 @@ declare function closeChannelSerializedApiCall(api: ApiPromise, origin: TNode, i
 declare const index$1_closeChannel: typeof closeChannel;
 declare const index$1_closeChannelSerializedApiCall: typeof closeChannelSerializedApiCall;
 declare namespace index$1 {
-  export {
-    index$1_closeChannel as closeChannel,
-    index$1_closeChannelSerializedApiCall as closeChannelSerializedApiCall,
-  };
+  export { index$1_closeChannel as closeChannel, index$1_closeChannelSerializedApiCall as closeChannelSerializedApiCall };
 }
 
-declare function getAssetsObject(node: TNode): TNodeAssets;
-declare function getAssetId(node: TNode, symbol: string): string | null;
-declare function getRelayChainSymbol(node: TNode): "DOT" | "KSM";
-declare function getNativeAssets(node: TNode): TNativeAssetDetails[];
-declare function getOtherAssets(node: TNode): TAssetDetails[];
-declare function getAllAssetsSymbols(node: TNode): (string | undefined)[];
-declare function hasSupportForAsset(node: TNode, symbol: string): boolean;
-declare function getAssetDecimals(node: TNode, symbol: string): number | null | undefined;
-declare function getParaId(node: TNode): number;
-declare function getTNode(nodeID: number): "AssetHubPolkadot" | "Acala" | "Astar" | "BifrostPolkadot" | "Bitgreen" | "Centrifuge" | "Clover" | "ComposableFinance" | "Darwinia" | "HydraDX" | "Interlay" | "Kylin" | "Litentry" | "Moonbeam" | "Parallel" | "AssetHubKusama" | "Encointer" | "Altair" | "Amplitude" | "Bajun" | "Basilisk" | "BifrostKusama" | "Pioneer" | "Calamari" | "CrustShadow" | "Crab" | "Imbue" | "Integritee" | "InvArchTinker" | "Karura" | "Kintsugi" | "Litmus" | "Mangata" | "Moonriver" | "ParallelHeiko" | "Picasso" | "Quartz" | "Robonomics" | "Shiden" | "Turing" | "Equilibrium" | "Unique" | "Crust" | "Manta" | "Genshiro" | "Nodle" | "OriginTrail" | "Pendulum" | "Polkadex" | "Zeitgeist" | undefined;
+declare const getAssetsObject: (node: TNode) => TNodeAssets;
+declare const getAssetId: (node: TNode, symbol: string) => string | null;
+declare const getRelayChainSymbol: (node: TNode) => TRelayChainSymbol;
+declare const getNativeAssets: (node: TNode) => TNativeAssetDetails[];
+declare const getOtherAssets: (node: TNode) => TAssetDetails[];
+declare const getAllAssetsSymbols: (node: TNode) => string[];
+declare const hasSupportForAsset: (node: TNode, symbol: string) => boolean;
+declare const getAssetDecimals: (node: TNode, symbol: string) => number | null;
+declare const getParaId: (node: TNode) => number;
+declare const getTNode: (nodeID: number) => TNode | null;
 
 declare const index_getAllAssetsSymbols: typeof getAllAssetsSymbols;
 declare const index_getAssetDecimals: typeof getAssetDecimals;
@@ -171,135 +166,124 @@ declare const index_getRelayChainSymbol: typeof getRelayChainSymbol;
 declare const index_getTNode: typeof getTNode;
 declare const index_hasSupportForAsset: typeof hasSupportForAsset;
 declare namespace index {
-  export {
-    index_getAllAssetsSymbols as getAllAssetsSymbols,
-    index_getAssetDecimals as getAssetDecimals,
-    index_getAssetId as getAssetId,
-    index_getAssetsObject as getAssetsObject,
-    index_getNativeAssets as getNativeAssets,
-    index_getOtherAssets as getOtherAssets,
-    index_getParaId as getParaId,
-    index_getRelayChainSymbol as getRelayChainSymbol,
-    index_getTNode as getTNode,
-    index_hasSupportForAsset as hasSupportForAsset,
-  };
+  export { index_getAllAssetsSymbols as getAllAssetsSymbols, index_getAssetDecimals as getAssetDecimals, index_getAssetId as getAssetId, index_getAssetsObject as getAssetsObject, index_getNativeAssets as getNativeAssets, index_getOtherAssets as getOtherAssets, index_getParaId as getParaId, index_getRelayChainSymbol as getRelayChainSymbol, index_getTNode as getTNode, index_hasSupportForAsset as hasSupportForAsset };
 }
 
-interface FinalCreatePoolBuilder {
-    build(): Extrinsic;
+interface FinalAddLiquidityBuilder {
+    build: () => Extrinsic;
 }
-interface AmountBCreatePoolBuilder {
-    amountB(amountB: number): FinalCreatePoolBuilder;
+interface AmountBMaxLimitAddLiquidityBuilder {
+    amountBMaxLimit: (amountBMaxLimit: number) => FinalAddLiquidityBuilder;
 }
-interface AssetBCreatePoolBuilder {
-    assetB(assetB: number): AmountBCreatePoolBuilder;
+interface AmountAAddLiquidityBuilder {
+    amountA: (amountA: number) => AmountBMaxLimitAddLiquidityBuilder;
 }
-interface AmountACreatePoolBuilder {
-    amountA(amountA: number): AssetBCreatePoolBuilder;
+interface AssetBAddLiquidityBuilder {
+    assetB: (assetB: number) => AmountAAddLiquidityBuilder;
 }
-interface AssetACreatePoolBuilder {
-    assetA(assetA: number): AmountACreatePoolBuilder;
+interface AssetAAddLiquidityBuilder {
+    assetA: (assetA: number) => AssetBAddLiquidityBuilder;
 }
 
-interface FinalSellBuilder {
-    build(): Extrinsic;
+interface FinalBuyBuilder {
+    build: () => Extrinsic;
 }
-interface DiscountSellBuilder {
-    discount(discount: Bool): FinalSellBuilder;
+interface DiscountBuyBuilder {
+    discount: (discount: Bool) => FinalBuyBuilder;
 }
-interface MaxLimitSellBuilder {
-    maxLimit(maxLimit: number): DiscountSellBuilder;
+interface MaxLimitBuyBuilder {
+    maxLimit: (maxLimit: number) => DiscountBuyBuilder;
 }
-interface AmountSellBuilder {
-    amount(amount: number): MaxLimitSellBuilder;
+interface AmountBuyBuilder {
+    amount: (amount: number) => MaxLimitBuyBuilder;
 }
-interface AssetOutSellBuilder {
-    assetOut(assetOut: number): AmountSellBuilder;
+interface AssetInBuyBuilder {
+    assetIn: (assetIn: number) => AmountBuyBuilder;
 }
-interface AssetInSellBuilder {
-    assetIn(assetIn: number): AssetOutSellBuilder;
+interface AssetOutBuyBuilder {
+    assetOut: (assetOut: number) => AssetInBuyBuilder;
 }
 
-interface FinalBuyBuilder {
-    build(): Extrinsic;
+interface OutboundCloseChannelBuilder {
+    outbound: (inbound: number) => FinalBuilder;
 }
-interface DiscountBuyBuilder {
-    discount(discount: Bool): FinalBuyBuilder;
+interface InboundCloseChannelBuilder {
+    inbound: (inbound: number) => OutboundCloseChannelBuilder;
 }
-interface MaxLimitBuyBuilder {
-    maxLimit(maxLimit: number): DiscountBuyBuilder;
+
+interface FinalCreatePoolBuilder {
+    build: () => Extrinsic;
 }
-interface AmountBuyBuilder {
-    amount(amount: number): MaxLimitBuyBuilder;
+interface AmountBCreatePoolBuilder {
+    amountB: (amountB: number) => FinalCreatePoolBuilder;
 }
-interface AssetInBuyBuilder {
-    assetIn(assetIn: number): AmountBuyBuilder;
+interface AssetBCreatePoolBuilder {
+    assetB: (assetB: number) => AmountBCreatePoolBuilder;
 }
-interface AssetOutBuyBuilder {
-    assetOut(assetOut: number): AssetInBuyBuilder;
+interface AmountACreatePoolBuilder {
+    amountA: (amountA: number) => AssetBCreatePoolBuilder;
+}
+interface AssetACreatePoolBuilder {
+    assetA: (assetA: number) => AmountACreatePoolBuilder;
+}
+
+interface MaxMessageSizeOpenChannelBuilder {
+    maxMessageSize: (size: number) => FinalBuilder;
+}
+interface MaxSizeOpenChannelBuilder {
+    maxSize: (size: number) => MaxMessageSizeOpenChannelBuilder;
 }
 
 interface FinalRemoveLiquidityBuilder {
-    build(): Extrinsic;
+    build: () => Extrinsic;
 }
 interface LiquidityAmountRemoveLiquidityBuilder {
-    liquidityAmount(liquidityAmount: number): FinalRemoveLiquidityBuilder;
+    liquidityAmount: (liquidityAmount: number) => FinalRemoveLiquidityBuilder;
 }
 interface AssetBRemoveLiquidityBuilder {
-    assetB(assetB: number): LiquidityAmountRemoveLiquidityBuilder;
+    assetB: (assetB: number) => LiquidityAmountRemoveLiquidityBuilder;
 }
 interface AssetARemoveLiquidityBuilder {
-    assetA(assetA: number): AssetBRemoveLiquidityBuilder;
+    assetA: (assetA: number) => AssetBRemoveLiquidityBuilder;
 }
 
-interface FinalAddLiquidityBuilder {
-    build(): Extrinsic;
-}
-interface AmountBMaxLimitAddLiquidityBuilder {
-    amountBMaxLimit(amountBMaxLimit: number): FinalAddLiquidityBuilder;
-}
-interface AmountAAddLiquidityBuilder {
-    amountA(amountA: number): AmountBMaxLimitAddLiquidityBuilder;
-}
-interface AssetBAddLiquidityBuilder {
-    assetB(assetB: number): AmountAAddLiquidityBuilder;
+interface FinalSellBuilder {
+    build: () => Extrinsic;
 }
-interface AssetAAddLiquidityBuilder {
-    assetA(assetA: number): AssetBAddLiquidityBuilder;
+interface DiscountSellBuilder {
+    discount: (discount: Bool) => FinalSellBuilder;
 }
-
-interface OutboundCloseChannelBuilder {
-    outbound(inbound: number): FinalBuilder;
+interface MaxLimitSellBuilder {
+    maxLimit: (maxLimit: number) => DiscountSellBuilder;
 }
-interface InboundCloseChannelBuilder {
-    inbound(inbound: number): OutboundCloseChannelBuilder;
+interface AmountSellBuilder {
+    amount: (amount: number) => MaxLimitSellBuilder;
 }
-
-interface MaxMessageSizeOpenChannelBuilder {
-    maxMessageSize(size: number): FinalBuilder;
+interface AssetOutSellBuilder {
+    assetOut: (assetOut: number) => AmountSellBuilder;
 }
-interface MaxSizeOpenChannelBuilder {
-    maxSize(size: number): MaxMessageSizeOpenChannelBuilder;
+interface AssetInSellBuilder {
+    assetIn: (assetIn: number) => AssetOutSellBuilder;
 }
 
 declare class ToGeneralBuilder {
-    private api;
-    private from;
-    private to;
+    private readonly api;
+    private readonly from;
+    private readonly to;
     constructor(api: ApiPromise, from: TNode, to: TNode);
     currency(currency: string | number | bigint): AmountBuilder;
     openChannel(): MaxSizeOpenChannelBuilder;
 }
 declare class FromGeneralBuilder {
-    private api;
-    private from;
+    private readonly api;
+    private readonly from;
     constructor(api: ApiPromise, from: TNode);
     to(node: TNode): ToGeneralBuilder;
-    amount(amount: any): AddressBuilder;
+    amount(amount: string | number | bigint): AddressBuilder;
     closeChannel(): InboundCloseChannelBuilder;
 }
 declare class GeneralBuilder {
-    private api;
+    private readonly api;
     constructor(api: ApiPromise);
     from(node: TNode): FromGeneralBuilder;
     to(node: TNode): AmountBuilder;
@@ -309,50 +293,33 @@ declare class GeneralBuilder {
     sell(): AssetInSellBuilder;
     createPool(): AssetACreatePoolBuilder;
 }
-declare function Builder(api: ApiPromise): GeneralBuilder;
+declare const Builder: (api: ApiPromise) => GeneralBuilder;
 interface FinalBuilder {
-    build(): Extrinsic | never;
-    buildSerializedApiCall(): TSerializedApiCall;
+    build: () => Extrinsic | never;
+    buildSerializedApiCall: () => TSerializedApiCall;
 }
 interface AddressBuilder {
-    address(address: string): FinalBuilder;
+    address: (address: string) => FinalBuilder;
 }
 interface AmountBuilder {
-    amount(amount: any): AddressBuilder;
+    amount: (amount: string | number | bigint) => AddressBuilder;
 }
 
 declare const getDefaultPallet: (node: TNode) => TPallet;
 declare const getSupportedPallets: (node: TNode) => TPallet[];
 
 declare const getNode: (node: TNode) => ParachainNode;
-declare const getNodeEndpointOption: (node: TNode) => _polkadot_apps_config_endpoints_types.EndpointOption | {
-    info: string;
-    paraId: number;
-    providers: {
-        'Imbue Network 0': string;
-        Dwellir?: undefined;
-        OnFinality?: undefined;
-        RadiumBlock?: undefined;
-    };
-} | {
-    info: string;
-    paraId: number;
-    providers: {
-        Dwellir: string;
-        OnFinality: string;
-        RadiumBlock: string;
-        'Imbue Network 0'?: undefined;
-    };
-} | undefined;
-declare const getAllNodeProviders: (node: TNode) => any[];
-declare const getNodeProvider: (node: TNode) => any;
+declare const getNodeEndpointOption: (node: TNode) => any;
+declare const getAllNodeProviders: (node: TNode) => string[];
+declare const getNodeProvider: (node: TNode) => string;
+declare const createApiInstanceForNode: (node: TNodeWithRelayChains) => Promise<ApiPromise>;
 
 declare class InvalidCurrencyError extends Error {
     constructor(message: string);
 }
 
 declare class NodeNotSupportedError extends Error {
-    constructor(message: string);
+    constructor(message?: string);
 }
 
 declare class NoXCMSupportImplementedError extends Error {
@@ -367,4 +334,4 @@ declare class IncompatibleNodesError extends Error {
     constructor();
 }
 
-export { Bool, Builder, Extrinsic, ExtrinsicFunction, IPolkadotXCMTransfer, IXTokensTransfer, IncompatibleNodesError, InvalidCurrencyError, NODE_NAMES, NoXCMSupportImplementedError, NodeNotSupportedError, PolkadotXCMTransferInput, SUPPORTED_PALLETS, ScenarioNotSupportedError, TAssetDetails, TAssetJsonMap, TNativeAssetDetails, TNode, TNodeAssets, TPallet, TPalletJsonMap, TPalletMap, TRelayChainType, TScenario, TSerializedApiCall, UpdateFunction, Version, XTokensTransferInput, index as assets, index$1 as closeChannels, getAllAssetsSymbols, getAllNodeProviders, getAssetDecimals, getAssetId, getAssetsObject, getDefaultPallet, getNativeAssets, getNode, getNodeEndpointOption, getNodeProvider, getOtherAssets, getParaId, getRelayChainSymbol, getSupportedPallets, getTNode, hasSupportForAsset, index$2 as openChannels, index$4 as xcmPallet, index$3 as xyk };
+export { type Bool, Builder, type Extrinsic, type ExtrinsicFunction, type IPolkadotXCMTransfer, type IXTokensTransfer, IncompatibleNodesError, InvalidCurrencyError, NODES_WITH_RELAY_CHAINS, NODE_NAMES, NoXCMSupportImplementedError, NodeNotSupportedError, type PolkadotXCMTransferInput, SUPPORTED_PALLETS, ScenarioNotSupportedError, type TAssetDetails, type TAssetJsonMap, type TNativeAssetDetails, type TNode, type TNodeAssets, type TNodeWithRelayChains, type TPallet, type TPalletJsonMap, type TPalletMap, type TRelayChainSymbol, type TRelayChainType, type TScenario, type TSerializedApiCall, type TTransferRelayToParaOptions, type UpdateFunction, Version, type XTokensTransferInput, index as assets, index$1 as closeChannels, createApiInstanceForNode, getAllAssetsSymbols, getAllNodeProviders, getAssetDecimals, getAssetId, getAssetsObject, getDefaultPallet, getNativeAssets, getNode, getNodeEndpointOption, getNodeProvider, getOtherAssets, getParaId, getRelayChainSymbol, getSupportedPallets, getTNode, hasSupportForAsset, index$2 as openChannels, index$4 as xcmPallet, index$3 as xyk };