@paraspell/sdk-core 12.5.0 → 12.6.0

package/dist/index.d.ts

@@ -1,14 +1,15 @@
 import * as _paraspell_sdk_common from '@paraspell/sdk-common';
-import { TChain, TSubstrateChain, TLocation, Version, TParachain, TExternalChain, TRelaychain, TJunction, Parents, TJunctions } from '@paraspell/sdk-common';
+import { TChain, TSubstrateChain, Version, TLocation, TRelaychain, TParachain, TExternalChain, TJunction, Parents, TJunctions } from '@paraspell/sdk-common';
 export * from '@paraspell/sdk-common';
-import { TAssetInfo, TCurrencyInputWithAmount, TCurrencyInput, TAsset, TAssetWithFee, WithAmount, WithComplexAmount, TCurrencyCore, TAmount, TAssetWithLocation, TAssetInfoWithId } from '@paraspell/assets';
+import * as _paraspell_assets from '@paraspell/assets';
+import { TAssetInfo, WithAmount, TAsset, TCurrencyInputWithAmount, TCurrencyInput, TAssetWithFee, WithComplexAmount, TCurrencyCore, TAmount, TAssetWithLocation, TAssetInfoWithId } from '@paraspell/assets';
 export * from '@paraspell/assets';
 import { TPallet, TAssetsPallet } from '@paraspell/pallets';
 export * from '@paraspell/pallets';
-import { WalletClient, parseUnits as parseUnits$1, formatUnits as formatUnits$1 } from 'viem';
+import { WalletClient, formatUnits as formatUnits$1, parseUnits as parseUnits$1 } from 'viem';
 
-type WithApi<TBase, TApi, TRes> = TBase & {
-    api: IPolkadotApi<TApi, TRes>;
+type WithApi<TBase, TApi, TRes, TSigner> = TBase & {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
 };
 type TUrl = string | string[];
 type TApiOrUrl<TApi> = TApi | TUrl;
@@ -35,7 +36,7 @@ type ClientCache<T> = {
     revive: (k: TClientKey, ttl: number) => void;
 };
 
-interface IPolkadotApi<TApi, TRes> {
+interface IPolkadotApi<TApi, TRes, TSigner> {
     getConfig(): TBuilderOptions<TApiOrUrl<TApi>> | undefined;
     getApi(): TApi;
     init(chain: TChain, clientTtlMs?: number): Promise<void>;
@@ -43,25 +44,29 @@ interface IPolkadotApi<TApi, TRes> {
     accountToHex(address: string, isPrefixed?: boolean): string;
     accountToUint8a(address: string): Uint8Array;
     deserializeExtrinsics(serialized: TSerializedExtrinsics): TRes;
+    txFromHex(hex: string): Promise<TRes>;
     queryState<T>(serialized: TSerializedStateQuery): Promise<T>;
     queryRuntimeApi<T>(serialized: TSerializedRuntimeApiQuery): Promise<T>;
     callBatchMethod(calls: TRes[], mode: BatchMode): TRes;
     callDispatchAsMethod(call: TRes, address: string): TRes;
-    objectToHex(obj: unknown, typeName: string): Promise<string>;
+    objectToHex(obj: unknown, typeName: string, version: Version): Promise<string>;
     hexToUint8a(hex: string): Uint8Array;
     stringToUint8a(str: string): Uint8Array;
     getMethod(tx: TRes): string;
     getTypeThenAssetCount(tx: TRes): number | undefined;
     hasMethod(pallet: TPallet, method: string): Promise<boolean>;
-    calculateTransactionFee(tx: TRes, address: string): Promise<bigint>;
+    getPaymentInfo(tx: TRes, address: string): Promise<{
+        partialFee: bigint;
+        weight: TWeight;
+    }>;
     quoteAhPrice(fromMl: TLocation, toMl: TLocation, amountIn: bigint, includeFee?: boolean): Promise<bigint | undefined>;
     getXcmWeight(xcm: any): Promise<TWeight>;
-    getXcmPaymentApiFee(chain: TSubstrateChain, localXcm: any, forwardedXcm: any, asset: TAssetInfo, transformXcm: boolean): Promise<bigint>;
+    getXcmPaymentApiFee(chain: TSubstrateChain, localXcm: any, forwardedXcm: any, asset: TAssetInfo, version: Version, transformXcm: boolean): Promise<bigint>;
     getEvmStorage(contract: string, slot: string): Promise<string>;
     getFromRpc(module: string, method: string, key: string): Promise<string>;
     blake2AsHex(data: Uint8Array): string;
-    clone(): IPolkadotApi<TApi, TRes>;
-    createApiForChain(chain: TSubstrateChain): Promise<IPolkadotApi<TApi, TRes>>;
+    clone(): IPolkadotApi<TApi, TRes, TSigner>;
+    createApiForChain(chain: TSubstrateChain): Promise<IPolkadotApi<TApi, TRes, TSigner>>;
     getDryRunCall(options: TDryRunCallBaseOptions<TRes>): Promise<TDryRunChainResult>;
     getDryRunXcm(options: TDryRunXcmBaseOptions<TRes>): Promise<TDryRunChainResult>;
     getBridgeStatus(): Promise<TBridgeStatus>;
@@ -70,2055 +75,2106 @@ interface IPolkadotApi<TApi, TRes> {
     disconnect(force?: boolean): Promise<void>;
     validateSubstrateAddress(address: string): boolean;
     deriveAddress(path: string): string;
-    signAndSubmit(tx: TRes, path: string): Promise<string>;
+    deriveAddress(sender: TSender<TSigner>): string;
+    signAndSubmit(tx: TRes, sender: TSender<TSigner>): Promise<string>;
 }
 
-type TPolkadotXCMTransferOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    chain: TSubstrateChain;
-    destLocation: TLocation;
-    beneficiaryLocation: TLocation;
-    address: TAddress;
-    asset: TAsset;
-    overriddenAsset?: TLocation | TAssetWithFee[];
-    scenario: TScenario;
-    assetInfo: WithAmount<TAssetInfo>;
-    currency: TCurrencyInputWithAmount;
-    feeAssetInfo?: TAssetInfo;
-    feeCurrency?: TCurrencyInput;
-    destination: TDestination;
-    destChain?: TChain;
-    paraIdTo?: number;
-    version: Version;
-    senderAddress?: string;
-    ahAddress?: string;
-    pallet?: string;
-    method?: string;
-};
-type TXTokensTransferOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    asset: WithAmount<TAssetInfo>;
-    address: TAddress;
-    scenario: TScenario;
-    origin: TSubstrateChain;
-    destination: TDestination;
-    paraIdTo?: number;
-    version: Version;
-    overriddenAsset?: TLocation | TAssetWithFee[];
-    pallet?: string;
-    method?: string;
-    useMultiAssetTransfer?: boolean;
-};
-type TXTransferTransferOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    asset: WithAmount<TAssetInfo>;
-    recipientAddress: TAddress;
-    origin: TSubstrateChain;
-    paraIdTo?: number;
-    destination: TDestination;
-    overriddenAsset?: TLocation | TAsset[];
-    pallet?: string;
-    method?: string;
-};
-interface IPolkadotXCMTransfer {
-    transferPolkadotXCM: <TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>) => Promise<TRes>;
+declare abstract class Chain<TApi, TRes, TSigner> {
+    private readonly _chain;
+    private readonly _info;
+    private readonly _ecosystem;
+    private readonly _version;
+    constructor(chain: TSubstrateChain, info: string, ecosystem: TRelaychain, version: Version);
+    get info(): string;
+    get ecosystem(): TRelaychain;
+    get chain(): TSubstrateChain;
+    get version(): Version;
+    transfer(sendOptions: TSendInternalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+    throwIfCantReceive(destChain: TChain | undefined): void;
+    throwIfTempDisabled(options: TSendInternalOptions<TApi, TRes, TSigner>, destChain?: TChain): void;
+    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes, TSigner>): boolean;
+    isReceivingTempDisabled(_scenario: TScenario): boolean;
+    canReceiveFrom(_origin: TChain): boolean;
+    shouldUseNativeAssetTeleport({ assetInfo: asset, to }: TSendInternalOptions<TApi, TRes, TSigner>): boolean;
+    createAsset(asset: WithAmount<TAssetInfo>, version: Version): TAsset;
+    getNativeAssetSymbol(): string;
+    transferLocal(options: TSendInternalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    protected transferToEthereum<TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, useOnlyDepositInstruction?: boolean): Promise<TRes>;
+    getBalanceNative(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+    getCustomCurrencyId(_asset: TAssetInfo): unknown;
+    getBalanceForeign<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+    getBalance(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
 }
-interface IXTokensTransfer {
-    transferXTokens: <TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>) => TRes;
+
+declare class Acala<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
+    getBalance(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
 }
-interface IXTransferTransfer {
-    transferXTransfer: <TApi, TRes>(input: TXTransferTransferOptions<TApi, TRes>) => TRes;
+
+declare class Ajuna<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
 }
-type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
-type TAddress = string | TLocation;
-type TDestination = TChain | TLocation;
-type TSendBaseOptions = {
-    /**
-     * The origin chain
-     */
-    from: TSubstrateChain;
-    /**
-     * The destination address. A SS58 or H160 format.
-     */
-    address: TAddress;
-    /**
-     * The optional sender address. A SS58 or H160 format.
-     */
-    senderAddress?: string;
-    /**
-     * The optional asset hub address. A SS58 format only.
-     */
-    ahAddress?: string;
-    /**
-     * The destination chain or XCM location
-     */
-    to: TDestination;
-    /**
-     * The currency to transfer. Either ID, symbol, location, or multi-asset
-     */
-    currency: TCurrencyInputWithAmount;
-    /**
-     * The optional fee asset. Either ID, symbol, or location
-     */
-    feeAsset?: TCurrencyInput;
-    /**
-     * The optional destination parachain ID
-     */
-    paraIdTo?: number;
-    /**
-     * The optional overrided XCM version
-     */
-    version?: Version;
-    /**
-     * The optional pallet override
-     */
-    pallet?: string;
-    /**
-     * The optional pallet method override
-     */
-    method?: string;
-};
-/**
- * Options for transferring from a parachain to another parachain or relay chain
- */
-type TSendOptions<TApi, TRes> = WithApi<TSendBaseOptions, TApi, TRes> & {
-    isAmountAll: boolean;
-};
-type WithRequiredSenderAddress<TBase> = Omit<TBase, 'senderAddress'> & {
-    /**
-     * The sender address. A SS58 or H160 format.
-     */
-    senderAddress: string;
-};
-type TSendBaseOptionsWithSenderAddress = WithRequiredSenderAddress<TSendBaseOptions>;
-type TSendInternalOptions<TApi, TRes> = Omit<TSendBaseOptions, 'from' | 'feeAsset' | 'version'> & {
-    api: IPolkadotApi<TApi, TRes>;
-    assetInfo: WithAmount<TAssetInfo>;
-    feeAsset?: TAssetInfo;
-    feeCurrency?: TCurrencyInput;
-    overriddenAsset?: TLocation | TAssetWithFee[];
-    version: Version;
-    isAmountAll: boolean;
-};
-type TSerializedExtrinsics = {
-    module: TPallet;
-    method: string;
-    params: Record<string, unknown>;
-};
-type TSerializedStateQuery = {
-    module: TAssetsPallet;
-    method: string;
-    params: unknown[];
-};
-type TSerializedRuntimeApiQuery = {
-    module: string;
-    method: string;
-    params: unknown[];
-};
-type TDestWeight = {
-    ref_time: bigint;
-    proof_size: bigint;
-};
-type TXTransferMethod = 'transfer';
-type TXTokensMethod = 'transfer' | 'transfer_multiasset' | 'transfer_multiassets';
-type TPolkadotXcmMethod = 'limited_teleport_assets' | 'limited_reserve_transfer_assets' | 'reserve_transfer_assets' | 'reserve_withdraw_assets' | 'transfer_assets' | 'transfer_assets_using_type_and_then';
-type TXcmPalletMethod = 'limited_teleport_assets' | 'limited_reserve_transfer_assets' | 'transfer_assets_using_type_and_then';
-type TWeight = {
-    refTime: bigint;
-    proofSize: bigint;
-};
-type TCreateBeneficiaryOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    address: TAddress;
-    version: Version;
-};
-type TCreateBeneficiaryXTokensOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    origin: TSubstrateChain;
-    destination: TDestination;
-    address: TAddress;
-    version: Version;
-    paraId?: number;
-};
-type TBridgeStatus = 'Normal' | 'Halted';
-type TTransferLocalOptions<TApi, TRes> = Omit<TSendInternalOptions<TApi, TRes>, 'address'> & {
-    address: string;
-    balance: bigint;
-};
-type TTransferFeeEstimates = {
-    originFee: bigint;
-    reserveFee: bigint;
-};
-type TCreateBaseTransferXcmOptions = {
-    chain: TSubstrateChain;
-    destChain: TChain;
-    assetInfo: WithAmount<TAssetInfo>;
-    feeAssetInfo?: TAssetInfo;
-    fees: TTransferFeeEstimates;
-    recipientAddress: string;
-    version: Version;
-    paraIdTo?: number;
-};
-type TCreateTransferXcmOptions<TApi, TRes> = WithApi<TCreateBaseTransferXcmOptions, TApi, TRes>;
-type TCreateBaseSwapXcmOptions = {
-    chain?: TSubstrateChain;
-    exchangeChain: TParachain;
-    destChain?: TChain;
-    assetInfoFrom: WithAmount<TAssetInfo>;
-    assetInfoTo: WithAmount<TAssetInfo>;
-    currencyTo: TCurrencyInput;
-    senderAddress: string;
-    recipientAddress: string;
-    calculateMinAmountOut: (amountIn: bigint, assetTo?: TAssetInfo) => Promise<bigint>;
-};
-type TCreateSwapXcmOptions<TApi, TRes> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes>;
-type TSwapFeeEstimates = {
-    originReserveFee: bigint;
-    exchangeFee: bigint;
-    destReserveFee: bigint;
-};
-type TCreateSwapXcmInternalOptions<TApi, TRes> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes> & {
-    version: Version;
-    fees: TSwapFeeEstimates;
-    paraIdTo?: number;
-};
 
-type TAssetClaimOptionsBase = {
-    chain: TSubstrateChain;
-    currency: WithComplexAmount<TCurrencyCore> | TAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
-    address: TAddress;
-    version?: Version;
-};
-type TAssetClaimOptions<TApi, TRes> = WithApi<TAssetClaimOptionsBase, TApi, TRes>;
-type TAssetClaimInternalOptions<TApi, TRes> = TAssetClaimOptions<TApi, TRes> & {
-    version: Version;
-    assets: TAsset<bigint>[];
-};
+declare class AjunaPaseo<TApi, TRes, TSigner> extends Ajuna<TApi, TRes, TSigner> {
+    constructor();
+}
 
-type TSetBalanceRes = {
-    assetStatusTx?: TSerializedExtrinsics;
-    balanceTx: TSerializedExtrinsics;
-};
-declare abstract class BaseAssetsPallet {
-    protected palletName: TAssetsPallet;
-    constructor(palletName: TAssetsPallet);
-    abstract mint<TApi, TRes>(address: string, assetInfo: WithAmount<TAssetInfo>, balance: bigint, chain: TSubstrateChain, api: IPolkadotApi<TApi, TRes>): Promise<TSetBalanceRes>;
-    abstract getBalance<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo, customCurrencyId?: unknown): Promise<bigint>;
+declare class Altair<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): TForeignOrNativeAsset;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
 }
 
-/**
- * Builder class for constructing asset claim transactions.
- */
-declare class AssetClaimBuilder<TApi, TRes, T extends Partial<TAssetClaimOptionsBase & TBuilderInternalOptions> = object> {
-    readonly api: IPolkadotApi<TApi, TRes>;
-    readonly _options: T;
-    constructor(api: IPolkadotApi<TApi, TRes>, options?: T);
-    /**
-     * Specifies the assets to be claimed.
-     *
-     * @param assets - An array of assets to claim in a multi-asset format.
-     * @returns An instance of Builder
-     */
-    currency(currency: TAssetClaimOptionsBase['currency']): AssetClaimBuilder<TApi, TRes, T & {
-        currency: TAssetClaimOptionsBase['currency'];
-    }>;
-    /**
-     * Sets the sender address.
-     *
-     * @param address - The sender address.
-     * @returns
-     */
-    senderAddress(addressOrPath: string): AssetClaimBuilder<TApi, TRes, T & {
-        senderAddress: string;
-    }>;
-    /**
-     * Specifies the account address on which the assets will be claimed.
-     *
-     * @param address - The destination account address.
-     * @returns An instance of Builder
-     */
-    address(address: TAddress): AssetClaimBuilder<TApi, TRes, T & {
-        address: TAddress;
-    }>;
-    /**
-     * Sets the XCM version to be used for the asset claim.
-     *
-     * @param version - The XCM version.
-     * @returns An instance of Builder
-     */
-    xcmVersion(version: Version): AssetClaimBuilder<TApi, TRes, T & {
-        version: Version;
-    }>;
-    /**
-     * Builds and returns the asset claim extrinsic.
-     *
-     * @returns A Promise that resolves to the asset claim extrinsic.
-     */
-    build(this: AssetClaimBuilder<TApi, TRes, TAssetClaimOptionsBase>): Promise<TRes>;
-    signAndSubmit(this: AssetClaimBuilder<TApi, TRes, TAssetClaimOptionsBase & TBuilderInternalOptions>): Promise<string>;
-    /**
-     * Returns the API instance used by the builder.
-     *
-     * @returns The API instance.
-     */
-    getApi(): TApi;
-    /**
-     * Disconnects the API.
-     *
-     * @returns A Promise that resolves when the API is disconnected.
-     */
-    disconnect(): Promise<void>;
+declare class AssetHubKusama<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getBalanceForeign<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
 }
 
-declare class BatchTransactionManager<TApi, TRes> {
-    transactionOptions: TBatchedSendOptions<TApi, TRes>[];
-    addTransaction(options: TBatchedSendOptions<TApi, TRes>): void;
-    isEmpty(): boolean;
-    buildBatch(api: IPolkadotApi<TApi, TRes>, from: TSubstrateChain, options?: TBatchOptions): Promise<TRes>;
+declare class AssetHubPolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    handleEthBridgeNativeTransfer<TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferPolkadotXCM(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getBalanceForeign<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
 }
 
-/**
- * A builder class for constructing Para-to-Para, Para-to-Relay, Relay-to-Para transactions and asset claims.
- */
-declare class GeneralBuilder<TApi, TRes, T extends Partial<TSendBaseOptions & TBuilderInternalOptions> = object> {
-    readonly batchManager: BatchTransactionManager<TApi, TRes>;
-    readonly api: IPolkadotApi<TApi, TRes>;
-    readonly _options: T;
-    constructor(api: IPolkadotApi<TApi, TRes>, batchManager: BatchTransactionManager<TApi, TRes>, options?: T);
-    /**
-     * Specifies the origin chain for the transaction.
-     *
-     * @param chain - The chain from which the transaction originates.
-     * @returns An instance of Builder
-     */
-    from(chain: TSubstrateChain): GeneralBuilder<TApi, TRes, T & {
-        from: TSubstrateChain;
-    }>;
-    /**
-     * Specifies the destination chain for the transaction.
-     *
-     * @param chain - The chain to which the transaction is sent.
-     * @param paraIdTo - (Optional) The parachain ID of the destination chain.
-     * @returns An instance of Builder
-     */
-    to(chain: TDestination, paraIdTo?: number): GeneralBuilder<TApi, TRes, T & {
-        to: TDestination;
-    }>;
-    /**
-     * Initiates the process to claim assets from a specified chain.
-     *
-     * @param chain - The chain from which to claim assets.
-     * @returns An instance of Builder
-     */
-    claimFrom(chain: TSubstrateChain): AssetClaimBuilder<TApi, TRes, {
-        chain: TSubstrateChain;
-    }>;
-    /**
-     * Specifies the currency to be used in the transaction. Symbol, ID, location or multi-asset.
-     *
-     * @param currency - The currency to be transferred.
-     * @returns An instance of Builder
-     */
-    currency(currency: TCurrencyInputWithAmount): GeneralBuilder<TApi, TRes, T & {
-        currency: TCurrencyInputWithAmount;
-    }>;
-    /**
-     * Sets the recipient address.
-     *
-     * @param address - The destination address.
-     * @returns An instance of Builder
-     */
-    address(address: TAddress): GeneralBuilder<TApi, TRes, T & {
-        address: TAddress;
-    }>;
-    /**
-     * Sets the sender address.
-     *
-     * @param address - The sender address.
-     * @returns
-     */
-    senderAddress(addressOrPath: string): GeneralBuilder<TApi, TRes, T & {
-        senderAddress: string;
-    }>;
-    /**
-     * Sets the asset hub address. This is used for transfers that go through the Asset Hub and originate from an EVM chain.
-     *
-     * @param address - The address to be used.
-     * @returns An instance of Builder
-     */
-    ahAddress(address: string | undefined): GeneralBuilder<TApi, TRes, T & {
-        ahAddress: string | undefined;
-    }>;
-    /**
-     * Sets the XCM version to be used for the transfer.
-     *
-     * @param version - The XCM version.
-     * @returns An instance of Builder
-     */
-    xcmVersion(version: Version): GeneralBuilder<TApi, TRes, T & {
-        version: Version;
-    }>;
-    /**
-     * Sets a custom pallet for the transaction.
-     *
-     * @param palletName - The name of the custom pallet to be used.
-     * @returns An instance of the Builder.
-     */
-    customPallet(pallet: string, method: string): GeneralBuilder<TApi, TRes, T & {
-        pallet: string;
-        method: string;
-    }>;
-    /**
-     * Optional fee asset for the transaction.
-     *
-     * @param currency - The currency to be used for the fee.
-     * @returns An instance of the Builder
-     */
-    feeAsset(currency: TCurrencyInput | undefined): GeneralBuilder<TApi, TRes, T & {
-        feeAsset: TCurrencyInput | undefined;
-    }>;
-    /**
-     * Adds the transfer transaction to the batch.
-     *
-     * @returns An instance of Builder
-     */
-    addToBatch(this: GeneralBuilder<TApi, TRes, TSendBaseOptions>): GeneralBuilder<TApi, TRes, T & {
-        from: TSubstrateChain;
-    }>;
-    /**
-     * Builds and returns the batched transaction based on the configured parameters.
-     *
-     * @param options - (Optional) Options to customize the batch transaction.
-     * @returns A Extrinsic representing the batched transactions.
-     */
-    buildBatch(this: GeneralBuilder<TApi, TRes, TSendBaseOptions>, options?: TBatchOptions): Promise<TRes>;
-    protected buildInternal<TOptions extends TSendBaseOptions>(this: GeneralBuilder<TApi, TRes, TOptions>): Promise<TBuildInternalRes<TApi, TRes, TOptions>>;
-    private prepareNormalizedOptions;
-    /**
-     * Builds and returns the transfer extrinsic.
-     *
-     * @returns A Promise that resolves to the transfer extrinsic.
-     */
-    build(this: GeneralBuilder<TApi, TRes, TSendBaseOptions>): Promise<TRes>;
-    private buildCommon;
-    private maybePerformXcmFormatCheck;
-    dryRun(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<TDryRunResult>;
-    dryRunPreview(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>, dryRunOptions?: TDryRunPreviewOptions): Promise<TDryRunResult>;
-    protected createTxFactory<TOptions extends TSendBaseOptions>(this: GeneralBuilder<TApi, TRes, TOptions>): TTxFactory<TRes>;
-    /**
-     * Returns the XCM fee for the transfer using dryRun or paymentInfo function.
-     *
-     * @returns An origin and destination fee.
-     */
-    getXcmFee<TDisableFallback extends boolean = false>(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>, options?: TGetXcmFeeBuilderOptions & {
-        disableFallback: TDisableFallback;
-    }): Promise<TGetXcmFeeResult<TDisableFallback>>;
-    /**
-     * Returns the origin XCM fee for the transfer using dryRun or paymentInfo function.
-     *
-     * @returns An origin fee.
-     */
-    getOriginXcmFee(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>, { disableFallback }?: TGetXcmFeeBuilderOptions): Promise<TXcmFeeDetail & {
-        forwardedXcms?: unknown;
-        destParaId?: number;
-    }>;
-    /**
-     * Estimates the origin and destination XCM fee using the `paymentInfo` function.
-     *
-     * @deprecated This function is deprecated and will be removed in a future version.
-     * Please use `builder.getXcmFee()` instead, where `builder` is an instance of `Builder()`.
-     * Will be removed in v13.
-     * For more details, see the documentation:
-     * {@link https://paraspell.github.io/docs/sdk/xcmPallet.html#xcm-fee-origin-and-dest}
-     *
-     * @returns An origin and destination fee estimate.
-     */
-    getXcmFeeEstimate(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<TGetXcmFeeEstimateResult>;
-    /**
-     * Estimates the origin XCM fee using paymentInfo function.
-     *
-     * @deprecated This function is deprecated and will be removed in a future version.
-     * Please use `builder.getOriginXcmFee()` instead, where `builder` is an instance of `Builder()`.
-     * Will be removed in v13.
-     * For more details, see the documentation:
-     * {@link https://paraspell.github.io/docs/sdk/xcmPallet.html#xcm-fee-origin-and-dest}
-     *
-     * @returns An origin fee estimate.
-     */
-    getOriginXcmFeeEstimate(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<TGetXcmFeeEstimateDetail>;
-    /**
-     * Returns the max transferable amount for the transfer
-     *
-     * @returns The max transferable amount.
-     */
-    getTransferableAmount(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<bigint>;
-    /**
-     * Returns the min transferable amount for the transfer
-     *
-     * @returns The min transferable amount.
-     */
-    getMinTransferableAmount(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<bigint>;
-    /**
-     * Returns the max transferable amount for the transfer
-     *
-     * @returns The max transferable amount.
-     */
-    verifyEdOnDestination(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<boolean>;
-    /**
-     * Returns the transfer info for the transfer
-     *
-     * @returns The transfer info.
-     */
-    getTransferInfo(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<TTransferInfo>;
-    /**
-     * Returns the receivable amount on the destination after the transfer
-     *
-     * @returns The computed receivable amount.
-     * @throws \{UnableToComputeError\} Thrown when the receivable amount cannot be determined.
-     */
-    getReceivableAmount(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>): Promise<bigint>;
-    signAndSubmit(this: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress & TBuilderInternalOptions>): Promise<string>;
-    /**
-     * Returns the API instance used by the builder.
-     *
-     * @returns The API instance.
-     */
-    getApi(): TApi;
-    /**
-     * Disconnects the API.
-     *
-     * @returns A Promise that resolves when the API is disconnected.
-     */
-    disconnect(): Promise<void>;
+declare class AssetHubPaseo<TApi, TRes, TSigner> extends AssetHubPolkadot<TApi, TRes, TSigner> {
+    constructor();
 }
-/**
- * Creates a new Builder instance.
- *
- * @param api - The API instance to use for building transactions. If not provided, a new instance will be created.
- * @returns A new Builder instance.
- */
-declare const Builder: <TApi, TRes>(api: IPolkadotApi<TApi, TRes>) => GeneralBuilder<TApi, TRes, object>;
 
-type TSwapConfig = {
-    currencyTo: TCurrencyCore;
-    exchangeChain: TParachain;
-};
-type TDryRunBaseOptions<TRes> = {
-    tx: TRes;
-    origin: TSubstrateChain;
-    destination: TChain;
-    senderAddress: string;
-    address: string;
-    currency: TCurrencyInputWithAmount;
-    feeAsset?: TCurrencyInput;
-    swapConfig?: TSwapConfig;
-    useRootOrigin?: boolean;
-    bypassOptions?: TBypassOptions;
-};
-type TDryRunOptions<TApi, TRes> = WithApi<TDryRunBaseOptions<TRes>, TApi, TRes>;
-type TDryRunCallBaseOptions<TRes> = {
-    /**
-     * The transaction to dry-run
-     */
-    tx: TRes;
-    /**
-     * The chain to dry-run on
-     */
-    chain: TSubstrateChain;
-    /**
-     * The destination chain
-     */
-    destination: TDestination;
-    /**
-     * The address to dry-run with (senderAddress)
-     */
-    address: string;
-    /**
-     * Whether to use the root origin
-     */
-    useRootOrigin?: boolean;
-    asset: WithAmount<TAssetInfo>;
-    bypassOptions?: TBypassOptions;
-    feeAsset?: TAssetInfo;
-};
-type TDryRunBypassOptions<TApi, TRes> = WithApi<Omit<TDryRunCallBaseOptions<TRes>, 'useRootOrigin' | 'destination'>, TApi, TRes>;
-type TDryRunCallOptions<TApi, TRes> = WithApi<TDryRunCallBaseOptions<TRes>, TApi, TRes>;
-type TDryRunXcmBaseOptions<TRes> = {
-    originLocation: any;
-    /**
-     * The XCM instructions
-     */
-    xcm: any;
-    /** The transaction to dry-run */
-    tx: TRes;
-    /**
-     * The chain to dry-run on
-     */
-    chain: TSubstrateChain;
-    /**
-     * The origin chain
-     */
-    origin: TSubstrateChain;
-    asset: TAssetInfo;
-    feeAsset?: TAssetInfo;
-    amount: bigint;
-    originFee: bigint;
-};
-type TDryRunXcmOptions<TApi, TRes> = WithApi<TDryRunXcmBaseOptions<TRes>, TApi, TRes>;
-type TDryRunResBase = {
-    asset: TAssetInfo;
-};
-type TDryRunChainSuccess = TDryRunResBase & {
-    success: true;
-    fee: bigint;
-    weight?: TWeight;
-    forwardedXcms: any;
-    destParaId?: number;
-};
-type TDryRunChainFailure = TDryRunResBase & {
-    success: false;
-    failureReason: string;
-    failureSubReason?: string;
-};
-type TDryRunChainResult = TDryRunChainSuccess | TDryRunChainFailure;
-type THopInfo = {
-    chain: TChain;
-    result: TDryRunChainResult;
-};
-type TChainEndpoint = 'origin' | 'destination' | TChain;
-type TDryRunResult = {
-    failureReason?: string;
-    failureSubReason?: string;
-    failureChain?: TChainEndpoint;
-    origin: TDryRunChainResult;
-    destination?: TDryRunChainResult;
-    hops: THopInfo[];
+declare class AssetHubWestend<TApi, TRes, TSigner> extends AssetHubPolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Astar<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Hydration<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferMoonbeamWhAsset<TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Basilisk<TApi, TRes, TSigner> extends Hydration<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class BifrostPolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    getCustomCurrencyId(asset: TAssetInfo): {
+        Native: string;
+        VToken?: undefined;
+        Token?: undefined;
+        VSToken2?: undefined;
+        VToken2?: undefined;
+        Token2?: undefined;
+    } | {
+        VToken: string;
+        Native?: undefined;
+        Token?: undefined;
+        VSToken2?: undefined;
+        VToken2?: undefined;
+        Token2?: undefined;
+    } | {
+        Token: string;
+        Native?: undefined;
+        VToken?: undefined;
+        VSToken2?: undefined;
+        VToken2?: undefined;
+        Token2?: undefined;
+    } | {
+        VSToken2: number;
+        Native?: undefined;
+        VToken?: undefined;
+        Token?: undefined;
+        VToken2?: undefined;
+        Token2?: undefined;
+    } | {
+        VToken2: number;
+        Native?: undefined;
+        VToken?: undefined;
+        Token?: undefined;
+        VSToken2?: undefined;
+        Token2?: undefined;
+    } | {
+        Token2: number;
+        Native?: undefined;
+        VToken?: undefined;
+        Token?: undefined;
+        VSToken2?: undefined;
+        VToken2?: undefined;
+    };
+    transferPolkadotXCM(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class BifrostKusama<TApi, TRes, TSigner> extends BifrostPolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class BifrostPaseo<TApi, TRes, TSigner> extends BifrostPolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class BridgeHubKusama<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class BridgeHubPolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class BridgeHubPaseo<TApi, TRes, TSigner> extends BridgeHubPolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class BridgeHubWestend<TApi, TRes, TSigner> extends BridgeHubPolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Centrifuge<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): "Native" | {
+        ForeignAsset: number;
+    };
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Collectives<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class CollectivesWestend<TApi, TRes, TSigner> extends Collectives<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class CoretimeKusama<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class CoretimePolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    canReceiveFrom(origin: TChain): boolean;
+}
+
+declare class CoretimePaseo<TApi, TRes, TSigner> extends CoretimePolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class CoretimeWestend<TApi, TRes, TSigner> extends CoretimePolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Crab<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Crust<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    private getCurrencySelection;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class CrustShadow<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    private getCurrencySelection;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Curio<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes, TSigner>): boolean;
+    isReceivingTempDisabled(_scenario: TScenario): boolean;
+}
+
+declare class Darwinia<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Encointer<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class EnergyWebX<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+    getBalanceForeign<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+}
+
+declare class EnergyWebXPaseo<TApi, TRes, TSigner> extends EnergyWebX<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Heima<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class HeimaPaseo<TApi, TRes, TSigner> extends Heima<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class HydrationPaseo<TApi, TRes, TSigner> extends Hydration<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Interlay<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getBalanceNative(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+}
+
+declare class Jamton<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): {
+        Native: number;
+        ForeignAsset?: undefined;
+    } | {
+        ForeignAsset: number;
+        Native?: undefined;
+    };
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class Karura<TApi, TRes, TSigner> extends Acala<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class KiltSpiritnet<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+}
+
+declare class KiltPaseo<TApi, TRes, TSigner> extends KiltSpiritnet<TApi, TRes, TSigner> {
+    constructor();
+    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes, TSigner>): boolean;
+    isReceivingTempDisabled(_scenario: TScenario): boolean;
+}
+
+declare class Kintsugi<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getBalanceNative(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+}
+
+declare class Polkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TSubstrateChain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class Kusama<TApi, TRes, TSigner> extends Polkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Laos<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+}
+
+declare class LaosPaseo<TApi, TRes, TSigner> extends Laos<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Manta<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    static readonly NATIVE_ASSET_ID = 1n;
+    constructor();
+    private getAssetId;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Moonbeam<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(_options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getBalanceForeign<TApi, TRes, TSigner>(_api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+}
+
+declare class Moonriver<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Mythos<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+}
+
+declare class NeuroWeb<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class NeuroWebPaseo<TApi, TRes, TSigner> extends NeuroWeb<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Nodle<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isRelayToParaEnabled(): boolean;
+}
+
+declare class Paseo<TApi, TRes, TSigner> extends Polkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class PeoplePolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class PAssetHub<TApi, TRes, TSigner> extends PeoplePolkadot<TApi, TRes, TSigner> {
+    constructor();
+    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes, TSigner>): boolean;
+    isReceivingTempDisabled(_scenario: TScenario): boolean;
+}
+
+declare class Peaq<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+    isRelayToParaEnabled(): boolean;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Pendulum<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTokensTransfer<TApi, TRes, TSigner> {
+    constructor();
+    getCustomCurrencyId(asset: TAssetInfo): TXcmAsset;
+    transferXTokens(input: TXTokensTransferOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Penpal<TApi, TRes, TSigner> extends Moonbeam<TApi, TRes, TSigner> {
+    constructor();
+    getBalanceForeign<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+}
+
+declare class PeopleKusama<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+}
+
+declare class PeoplePaseo<TApi, TRes, TSigner> extends PeoplePolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class PeopleWestend<TApi, TRes, TSigner> extends PeoplePolkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Phala<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IXTransferTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferXTransfer(input: TXTransferTransferOptions<TApi, TRes, TSigner>): TRes;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Quartz<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isSendingTempDisabled(): boolean;
+}
+
+declare class RobonomicsPolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    isReceivingTempDisabled(scenario: TScenario): boolean;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class Shiden<TApi, TRes, TSigner> extends Astar<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Unique<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    transferLocalNonNativeAsset(_options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+    getBalanceForeign<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
+}
+
+declare class Westend<TApi, TRes, TSigner> extends Polkadot<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare class Xode<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor();
+    transferPolkadotXCM(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    canReceiveFrom(origin: TChain): boolean;
+}
+
+declare class Zeitgeist<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
+    getCustomCurrencyId(asset: TAssetInfo): TZeitgeistAsset | TXcmForeignAsset;
+    transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
+    canReceiveFrom(origin: TChain): boolean;
+    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
+}
+
+declare class ZeitgeistPaseo<TApi, TRes, TSigner> extends Zeitgeist<TApi, TRes, TSigner> {
+    constructor();
+}
+
+declare const chains: <TApi, TRes, TSigner>() => {
+    Polkadot: Polkadot<TApi, TRes, TSigner>;
+    AssetHubPolkadot: AssetHubPolkadot<TApi, TRes, TSigner>;
+    Acala: Acala<TApi, TRes, TSigner>;
+    Ajuna: Ajuna<TApi, TRes, TSigner>;
+    Astar: Astar<TApi, TRes, TSigner>;
+    Unique: Unique<TApi, TRes, TSigner>;
+    Crust: Crust<TApi, TRes, TSigner>;
+    BifrostPolkadot: BifrostPolkadot<TApi, TRes, TSigner>;
+    BridgeHubPolkadot: BridgeHubPolkadot<TApi, TRes, TSigner>;
+    Centrifuge: Centrifuge<TApi, TRes, TSigner>;
+    Darwinia: Darwinia<TApi, TRes, TSigner>;
+    EnergyWebX: EnergyWebX<TApi, TRes, TSigner>;
+    Hydration: Hydration<TApi, TRes, TSigner>;
+    Interlay: Interlay<TApi, TRes, TSigner>;
+    Heima: Heima<TApi, TRes, TSigner>;
+    Jamton: Jamton<TApi, TRes, TSigner>;
+    Moonbeam: Moonbeam<TApi, TRes, TSigner>;
+    CoretimePolkadot: CoretimePolkadot<TApi, TRes, TSigner>;
+    RobonomicsPolkadot: RobonomicsPolkadot<TApi, TRes, TSigner>;
+    PeoplePolkadot: PeoplePolkadot<TApi, TRes, TSigner>;
+    Manta: Manta<TApi, TRes, TSigner>;
+    Nodle: Nodle<TApi, TRes, TSigner>;
+    NeuroWeb: NeuroWeb<TApi, TRes, TSigner>;
+    Pendulum: Pendulum<TApi, TRes, TSigner>;
+    Collectives: Collectives<TApi, TRes, TSigner>;
+    Phala: Phala<TApi, TRes, TSigner>;
+    KiltSpiritnet: KiltSpiritnet<TApi, TRes, TSigner>;
+    Curio: Curio<TApi, TRes, TSigner>;
+    Mythos: Mythos<TApi, TRes, TSigner>;
+    Peaq: Peaq<TApi, TRes, TSigner>;
+    Xode: Xode<TApi, TRes, TSigner>;
+    Kusama: Kusama<TApi, TRes, TSigner>;
+    AssetHubKusama: AssetHubKusama<TApi, TRes, TSigner>;
+    BridgeHubKusama: BridgeHubKusama<TApi, TRes, TSigner>;
+    CoretimeKusama: CoretimeKusama<TApi, TRes, TSigner>;
+    Encointer: Encointer<TApi, TRes, TSigner>;
+    Altair: Altair<TApi, TRes, TSigner>;
+    Basilisk: Basilisk<TApi, TRes, TSigner>;
+    BifrostKusama: BifrostKusama<TApi, TRes, TSigner>;
+    CrustShadow: CrustShadow<TApi, TRes, TSigner>;
+    Crab: Crab<TApi, TRes, TSigner>;
+    Karura: Karura<TApi, TRes, TSigner>;
+    Kintsugi: Kintsugi<TApi, TRes, TSigner>;
+    Moonriver: Moonriver<TApi, TRes, TSigner>;
+    Laos: Laos<TApi, TRes, TSigner>;
+    Quartz: Quartz<TApi, TRes, TSigner>;
+    PeopleKusama: PeopleKusama<TApi, TRes, TSigner>;
+    Shiden: Shiden<TApi, TRes, TSigner>;
+    Zeitgeist: Zeitgeist<TApi, TRes, TSigner>;
+    Westend: Westend<TApi, TRes, TSigner>;
+    AssetHubWestend: AssetHubWestend<TApi, TRes, TSigner>;
+    BridgeHubWestend: BridgeHubWestend<TApi, TRes, TSigner>;
+    CollectivesWestend: CollectivesWestend<TApi, TRes, TSigner>;
+    CoretimeWestend: CoretimeWestend<TApi, TRes, TSigner>;
+    PeopleWestend: PeopleWestend<TApi, TRes, TSigner>;
+    Penpal: Penpal<TApi, TRes, TSigner>;
+    Paseo: Paseo<TApi, TRes, TSigner>;
+    AssetHubPaseo: AssetHubPaseo<TApi, TRes, TSigner>;
+    BridgeHubPaseo: BridgeHubPaseo<TApi, TRes, TSigner>;
+    CoretimePaseo: CoretimePaseo<TApi, TRes, TSigner>;
+    EnergyWebXPaseo: EnergyWebXPaseo<TApi, TRes, TSigner>;
+    KiltPaseo: KiltPaseo<TApi, TRes, TSigner>;
+    PAssetHub: PAssetHub<TApi, TRes, TSigner>;
+    PeoplePaseo: PeoplePaseo<TApi, TRes, TSigner>;
+    AjunaPaseo: AjunaPaseo<TApi, TRes, TSigner>;
+    BifrostPaseo: BifrostPaseo<TApi, TRes, TSigner>;
+    HeimaPaseo: HeimaPaseo<TApi, TRes, TSigner>;
+    HydrationPaseo: HydrationPaseo<TApi, TRes, TSigner>;
+    LaosPaseo: LaosPaseo<TApi, TRes, TSigner>;
+    NeuroWebPaseo: NeuroWebPaseo<TApi, TRes, TSigner>;
+    ZeitgeistPaseo: ZeitgeistPaseo<TApi, TRes, TSigner>;
 };
-type TResolveHopParams<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    tx: TRes;
-    originChain: TSubstrateChain;
-    currentChain: TSubstrateChain;
-    destination: TDestination;
-    asset: TAssetInfo;
+
+declare const ETH_MAINNET_CHAIN_ID: bigint;
+declare const ETH_TESTNET_CHAIN_ID: bigint;
+declare const RELAY_LOCATION: TLocation;
+declare const TX_CLIENT_TIMEOUT_MS: number;
+declare const DRY_RUN_CLIENT_TIMEOUT_MS: number;
+declare const TRANSACT_ORIGINS: readonly ["Native", "SovereignAccount", "Superuser", "Xcm"];
+
+type TPolkadotXCMTransferOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    chain: TSubstrateChain;
+    beneficiaryLocation: TLocation;
+    address: TAddress;
+    asset: TAsset;
+    overriddenAsset?: TLocation | TAssetWithFee[];
+    scenario: TScenario;
+    assetInfo: WithAmount<TAssetInfo>;
     currency: TCurrencyInputWithAmount;
-    swapConfig?: TSwapConfig;
-    hasPassedExchange: boolean;
-};
-type HopProcessParams<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    currentChain: TSubstrateChain;
-    currentOrigin: TSubstrateChain;
-    currentAsset: TAssetInfo;
-    forwardedXcms: any;
-    hasPassedExchange: boolean;
-    isDestination: boolean;
+    feeAssetInfo?: TAssetInfo;
+    feeCurrency?: TCurrencyInput;
+    destination: TDestination;
+    destChain?: TChain;
+    paraIdTo?: number;
+    version: Version;
+    senderAddress?: string;
+    ahAddress?: string;
+    pallet?: string;
+    method?: string;
+    transactOptions?: TTransactOptions<TRes>;
 };
-type HopTraversalConfig<TApi, TRes, THopResult> = {
-    api: IPolkadotApi<TApi, TRes>;
+type TXTokensTransferOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    asset: WithAmount<TAssetInfo>;
+    address: TAddress;
+    scenario: TScenario;
     origin: TSubstrateChain;
-    destination: TChain;
-    currency: TCurrencyCore;
-    initialForwardedXcms: any;
-    initialDestParaId: number | undefined;
-    swapConfig?: TSwapConfig;
-    processHop: (params: HopProcessParams<TApi, TRes>) => Promise<THopResult>;
-    shouldContinue: (hopResult: THopResult) => boolean;
-    extractNextHopData: (hopResult: THopResult) => {
-        forwardedXcms: any;
-        destParaId: number | undefined;
-    };
-};
-type HopTraversalResult<THopResult> = {
-    hops: Array<{
-        chain: TSubstrateChain;
-        result: THopResult;
-    }>;
-    destination?: THopResult;
-    lastProcessedChain?: TSubstrateChain;
+    destination: TDestination;
+    paraIdTo?: number;
+    version: Version;
+    overriddenAsset?: TLocation | TAssetWithFee[];
+    pallet?: string;
+    method?: string;
+    useMultiAssetTransfer?: boolean;
 };
-type TBypassOptions = {
-    mintFeeAssets?: boolean;
-    sentAssetMintMode?: 'preview' | 'bypass';
+type TXTransferTransferOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    asset: WithAmount<TAssetInfo>;
+    recipientAddress: TAddress;
+    origin: TSubstrateChain;
+    paraIdTo?: number;
+    destination: TDestination;
+    overriddenAsset?: TLocation | TAsset[];
+    pallet?: string;
+    method?: string;
 };
-declare enum XTokensError {
-    AssetHasNoReserve = "AssetHasNoReserve",
-    NotCrossChainTransfer = "NotCrossChainTransfer",
-    InvalidDest = "InvalidDest",
-    NotCrossChainTransferableCurrency = "NotCrossChainTransferableCurrency",
-    UnweighableMessage = "UnweighableMessage",
-    XcmExecutionFailed = "XcmExecutionFailed",
-    CannotReanchor = "CannotReanchor",
-    InvalidAncestry = "InvalidAncestry",
-    InvalidAsset = "InvalidAsset",
-    DestinationNotInvertible = "DestinationNotInvertible",
-    BadVersion = "BadVersion",
-    DistinctReserveForAssetAndFee = "DistinctReserveForAssetAndFee",
-    ZeroFee = "ZeroFee",
-    ZeroAmount = "ZeroAmount",
-    TooManyAssetsBeingSent = "TooManyAssetsBeingSent",
-    AssetIndexNonExistent = "AssetIndexNonExistent",
-    FeeNotEnough = "FeeNotEnough",
-    NotSupportedLocation = "NotSupportedLocation",
-    MinXcmFeeNotDefined = "MinXcmFeeNotDefined",
-    RateLimited = "RateLimited"
+interface IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    transferPolkadotXCM: (input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 }
-declare enum PolkadotXcmError {
-    Unreachable = "Unreachable",
-    SendFailure = "SendFailure",
-    Filtered = "Filtered",
-    UnweighableMessage = "UnweighableMessage",
-    DestinationNotInvertible = "DestinationNotInvertible",
-    Empty = "Empty",
-    CannotReanchor = "CannotReanchor",
-    TooManyAssets = "TooManyAssets",
-    InvalidOrigin = "InvalidOrigin",
-    BadVersion = "BadVersion",
-    BadLocation = "BadLocation",
-    NoSubscription = "NoSubscription",
-    AlreadySubscribed = "AlreadySubscribed",
-    CannotCheckOutTeleport = "CannotCheckOutTeleport",
-    LowBalance = "LowBalance",
-    TooManyLocks = "TooManyLocks",
-    AccountNotSovereign = "AccountNotSovereign",
-    FeesNotMet = "FeesNotMet",
-    LockNotFound = "LockNotFound",
-    InUse = "InUse",
-    REMOVED = "REMOVED",
-    InvalidAssetUnknownReserve = "InvalidAssetUnknownReserve",
-    InvalidAssetUnsupportedReserve = "InvalidAssetUnsupportedReserve",
-    TooManyReserves = "TooManyReserves",
-    LocalExecutionIncomplete = "LocalExecutionIncomplete",
-    TooManyAuthorizedAliases = "TooManyAuthorizedAliases",
-    ExpiresInPast = "ExpiresInPast",
-    AliasNotFound = "AliasNotFound",
-    LocalExecutionIncompleteWithError = "LocalExecutionIncompleteWithError"
+interface IXTokensTransfer<TApi, TRes, TSigner> {
+    transferXTokens: (input: TXTokensTransferOptions<TApi, TRes, TSigner>) => TRes;
 }
-declare enum PolkadotXcmExecutionError {
-    Overflow = "Overflow",
-    Unimplemented = "Unimplemented",
-    UntrustedReserveLocation = "UntrustedReserveLocation",
-    UntrustedTeleportLocation = "UntrustedTeleportLocation",
-    LocationFull = "LocationFull",
-    LocationNotInvertible = "LocationNotInvertible",
-    BadOrigin = "BadOrigin",
-    InvalidLocation = "InvalidLocation",
-    AssetNotFound = "AssetNotFound",
-    FailedToTransactAsset = "FailedToTransactAsset",
-    NotWithdrawable = "NotWithdrawable",
-    LocationCannotHold = "LocationCannotHold",
-    ExceedsMaxMessageSize = "ExceedsMaxMessageSize",
-    DestinationUnsupported = "DestinationUnsupported",
-    Transport = "Transport",
-    Unroutable = "Unroutable",
-    UnknownClaim = "UnknownClaim",
-    FailedToDecode = "FailedToDecode",
-    MaxWeightInvalid = "MaxWeightInvalid",
-    NotHoldingFees = "NotHoldingFees",
-    TooExpensive = "TooExpensive",
-    Trap = "Trap",
-    ExpectationFalse = "ExpectationFalse",
-    PalletNotFound = "PalletNotFound",
-    NameMismatch = "NameMismatch",
-    VersionIncompatible = "VersionIncompatible",
-    HoldingWouldOverflow = "HoldingWouldOverflow",
-    ExportError = "ExportError",
-    ReanchorFailed = "ReanchorFailed",
-    NoDeal = "NoDeal",
-    FeesNotMet = "FeesNotMet",
-    LockError = "LockError",
-    NoPermission = "NoPermission",
-    Unanchored = "Unanchored",
-    NotDepositable = "NotDepositable",
-    TooManyAssets = "TooManyAssets",
-    UnhandledXcmVersion = "UnhandledXcmVersion",
-    WeightLimitReached = "WeightLimitReached",
-    Barrier = "Barrier",
-    WeightNotComputable = "WeightNotComputable",
-    ExceedsStackLimit = "ExceedsStackLimit"
+interface IXTransferTransfer<TApi, TRes, TSigner> {
+    transferXTransfer: (input: TXTransferTransferOptions<TApi, TRes, TSigner>) => TRes;
 }
-type TModuleError = {
-    index: string;
-    error: string;
-};
-type TDryRunError = {
-    failureReason: string;
-    failureSubReason?: string;
-};
-
-type TXcmFeeSwapConfig = TSwapConfig & {
-    amountOut: bigint;
-};
-type TTxFactory<TRes> = (amount?: string, relative?: boolean) => Promise<TRes>;
-type TGetXcmFeeBaseOptions<TRes, TDisableFallback extends boolean = boolean> = {
+type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
+type TAddress = string | TLocation;
+type TDestination = TChain | TLocation;
+type TSendBaseOptions<TRes> = {
     /**
-     * The transaction factory
+     * The origin chain
      */
-    buildTx: TTxFactory<TRes>;
+    from: TSubstrateChain;
     /**
-     * The origin chain
+     * The destination address. A SS58 or H160 format.
      */
-    origin: TSubstrateChain;
+    address: TAddress;
     /**
-     * The destination chain
+     * The optional sender address. A SS58 or H160 format.
      */
-    destination: TChain;
+    senderAddress?: string;
     /**
-     * The sender address
+     * The optional asset hub address. A SS58 format only.
+     */
+    ahAddress?: string;
+    /**
+     * The destination chain or XCM location
+     */
+    to: TDestination;
+    /**
+     * The currency to transfer. Either ID, symbol, location, or multi-asset
+     */
+    currency: TCurrencyInputWithAmount;
+    /**
+     * The optional fee asset. Either ID, symbol, or location
      */
-    senderAddress: string;
-    address: string;
-    currency: WithAmount<TCurrencyCore>;
     feeAsset?: TCurrencyInput;
-    disableFallback: TDisableFallback;
-    swapConfig?: TXcmFeeSwapConfig;
-    skipReverseFeeCalculation?: boolean;
-};
-type TGetXcmFeeOptions<TApi, TRes, TDisableFallback extends boolean = boolean> = WithApi<TGetXcmFeeBaseOptions<TRes, TDisableFallback>, TApi, TRes>;
-type TGetXcmFeeInternalOptions<TApi, TRes, TDisableFallback extends boolean = boolean> = Omit<TGetXcmFeeOptions<TApi, TRes, TDisableFallback>, 'buildTx'> & {
-    tx: TRes;
-    useRootOrigin: boolean;
+    /**
+     * The optional destination parachain ID
+     */
+    paraIdTo?: number;
+    /**
+     * The optional overrided XCM version
+     */
+    version?: Version;
+    /**
+     * The optional pallet override
+     */
+    pallet?: string;
+    /**
+     * Whether to keep the account alive after the transfer.
+     */
+    keepAlive?: boolean;
+    /**
+     * The optional pallet method override
+     */
+    method?: string;
+    /**
+     * Hex of the encoded transaction call to apply on the destination chain
+     */
+    transactOptions?: TTransactOptions<TRes>;
 };
-type TGetXcmFeeEstimateOptions<TApi, TRes> = Omit<TGetXcmFeeInternalOptions<TApi, TRes>, 'disableFallback' | 'useRootOrigin' | 'buildTx'>;
-type TGetOriginXcmFeeEstimateOptions<TApi, TRes> = Omit<TGetXcmFeeInternalOptions<TApi, TRes>, 'disableFallback' | 'address' | 'useRootOrigin' | 'buildTx'>;
-type TGetXcmFeeBuilderOptions = {
-    disableFallback: boolean;
+/**
+ * Options for transferring from a parachain to another parachain or relay chain
+ */
+type TSendOptions<TApi, TRes, TSigner> = WithApi<TSendBaseOptions<TRes>, TApi, TRes, TSigner> & {
+    isAmountAll: boolean;
 };
-type TGetOriginXcmFeeBaseOptions<TRes> = {
-    buildTx: TTxFactory<TRes>;
-    origin: TSubstrateChain;
-    destination: TChain;
+type WithRequiredSenderAddress<TBase> = Omit<TBase, 'senderAddress'> & {
+    /**
+     * The sender address. A SS58 or H160 format.
+     */
     senderAddress: string;
-    currency: WithAmount<TCurrencyCore>;
-    feeAsset?: TCurrencyInput;
-    disableFallback: boolean;
-    useRootOrigin?: boolean;
 };
-type TGetOriginXcmFeeOptions<TApi, TRes> = WithApi<TGetOriginXcmFeeBaseOptions<TRes>, TApi, TRes>;
-type TGetOriginXcmFeeInternalOptions<TApi, TRes> = Omit<TGetOriginXcmFeeOptions<TApi, TRes>, 'buildTx'> & {
-    tx: TRes;
+type TSendBaseOptionsWithSenderAddress<TRes> = WithRequiredSenderAddress<TSendBaseOptions<TRes>>;
+type TSendInternalOptions<TApi, TRes, TSigner> = Omit<TSendBaseOptions<TRes>, 'from' | 'feeAsset' | 'version'> & {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    assetInfo: WithAmount<TAssetInfo>;
+    feeAsset?: TAssetInfo;
+    feeCurrency?: TCurrencyInput;
+    overriddenAsset?: TLocation | TAssetWithFee[];
+    version: Version;
+    isAmountAll: boolean;
 };
-type TGetFeeForDestChainBaseOptions<TRes> = {
-    prevChain: TSubstrateChain;
-    origin: TSubstrateChain;
-    destination: TChain;
-    senderAddress: string;
-    address: string;
-    currency: WithAmount<TCurrencyCore>;
-    forwardedXcms: any;
-    tx: TRes;
-    asset: TAssetInfo;
-    originFee: bigint;
-    feeAsset?: TCurrencyInput;
-    disableFallback: boolean;
-    hasPassedExchange?: boolean;
-    swapConfig?: TXcmFeeSwapConfig;
-    skipReverseFeeCalculation?: boolean;
+type TTransactOrigin = (typeof TRANSACT_ORIGINS)[number];
+type TTransactOptions<TRes, TWeightType = bigint> = {
+    call: string | TRes;
+    originKind?: TTransactOrigin;
+    maxWeight?: TWeight<TWeightType>;
+};
+type TSerializedExtrinsics = {
+    module: TPallet;
+    method: string;
+    params: Record<string, unknown>;
+};
+type TSerializedStateQuery = {
+    module: TAssetsPallet;
+    method: string;
+    params: unknown[];
 };
-type TGetFeeForDestChainOptions<TApi, TRes> = WithApi<TGetFeeForDestChainBaseOptions<TRes>, TApi, TRes>;
-type TGetReverseTxFeeOptions<TApi, TRes> = Omit<TGetFeeForDestChainOptions<TApi, TRes>, 'destination' | 'disableFallback' | 'forwardedXcms' | 'asset' | 'originFee' | 'prevChain'> & {
-    destination: TSubstrateChain;
+type TSerializedRuntimeApiQuery = {
+    module: string;
+    method: string;
+    params: unknown[];
 };
-type TFeeType = 'dryRun' | 'paymentInfo' | 'noFeeRequired';
-type TXcmFeeBase$1 = {
-    asset: TAssetInfo;
-    weight?: TWeight;
-    sufficient?: boolean;
+type TDestWeight = {
+    ref_time: bigint;
+    proof_size: bigint;
 };
-type TXcmFeeDetailSuccess = TXcmFeeBase$1 & {
-    fee: bigint;
-    feeType: TFeeType;
-    dryRunError?: string;
-    dryRunSubError?: string;
+type TXTransferMethod = 'transfer';
+type TXTokensMethod = 'transfer' | 'transfer_multiasset' | 'transfer_multiassets';
+type TPolkadotXcmMethod = 'limited_teleport_assets' | 'limited_reserve_transfer_assets' | 'reserve_transfer_assets' | 'reserve_withdraw_assets' | 'transfer_assets' | 'transfer_assets_using_type_and_then';
+type TXcmPalletMethod = 'limited_teleport_assets' | 'limited_reserve_transfer_assets' | 'transfer_assets_using_type_and_then';
+type TWeight<TWeightType = bigint> = {
+    refTime: TWeightType;
+    proofSize: TWeightType;
 };
-type TXcmFeeDetailWithFallback = TXcmFeeDetailSuccess;
-type TXcmFeeDetailError = TXcmFeeBase$1 & {
-    fee?: bigint;
-    feeType?: TFeeType;
-    dryRunError: string;
-    dryRunSubError?: string;
+type TCreateBeneficiaryOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    address: TAddress;
+    version: Version;
 };
-type TXcmFeeDetail = TXcmFeeDetailSuccess | TXcmFeeDetailError;
-type TXcmFeeHopResult = {
-    fee?: bigint;
-    feeType?: TFeeType;
-    sufficient?: boolean;
-    dryRunError?: string;
-    dryRunSubError?: string;
-    forwardedXcms?: any;
-    destParaId?: number;
-    asset: TAssetInfo;
+type TCreateBeneficiaryXTokensOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
+    destination: TDestination;
+    address: TAddress;
+    version: Version;
+    paraId?: number;
 };
-type TConditionalXcmFeeDetail<TDisableFallback extends boolean> = TDisableFallback extends false ? TXcmFeeDetailWithFallback : TXcmFeeDetail;
-type TDestXcmFeeDetail<TDisableFallback extends boolean> = TConditionalXcmFeeDetail<TDisableFallback> & {
-    forwardedXcms?: any;
-    destParaId?: number;
+type TBridgeStatus = 'Normal' | 'Halted';
+type TTransferLocalOptions<TApi, TRes, TSigner> = Omit<TSendInternalOptions<TApi, TRes, TSigner>, 'address'> & {
+    address: string;
+    balance: bigint;
 };
-type TConditionalXcmFeeHopInfo<TDisableFallback extends boolean> = {
-    chain: TChain;
-    result: TConditionalXcmFeeDetail<TDisableFallback>;
+type TTransferFeeEstimates = {
+    originFee: bigint;
+    reserveFee: bigint;
 };
-type TXcmFeeHopInfo = {
-    chain: TChain;
-    result: TXcmFeeDetail;
+type TCreateBaseTransferXcmOptions<TRes> = {
+    chain: TSubstrateChain;
+    destChain: TChain;
+    assetInfo: WithAmount<TAssetInfo>;
+    feeAssetInfo?: TAssetInfo;
+    fees: TTransferFeeEstimates;
+    recipientAddress: string;
+    version: Version;
+    paraIdTo?: number;
+    transactOptions?: TTransactOptions<TRes>;
 };
-type TGetXcmFeeResult<TDisableFallback extends boolean = boolean> = {
-    failureReason?: string;
-    failureChain?: TChainEndpoint;
-    origin: TConditionalXcmFeeDetail<TDisableFallback>;
-    destination: TConditionalXcmFeeDetail<TDisableFallback>;
-    hops: TConditionalXcmFeeHopInfo<TDisableFallback>[];
+type TCreateTransferXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseTransferXcmOptions<TRes>, TApi, TRes, TSigner>;
+type TCreateBaseSwapXcmOptions = {
+    chain?: TSubstrateChain;
+    exchangeChain: TParachain;
+    destChain?: TChain;
+    assetInfoFrom: WithAmount<TAssetInfo>;
+    assetInfoTo: WithAmount<TAssetInfo>;
+    currencyTo: TCurrencyInput;
+    senderAddress: string;
+    recipientAddress: string;
+    calculateMinAmountOut: (amountIn: bigint, assetTo?: TAssetInfo) => Promise<bigint>;
 };
-type TGetXcmFeeEstimateDetail = {
-    fee: bigint;
-    asset: TAssetInfo;
-    sufficient?: boolean;
+type TCreateSwapXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner>;
+type TSwapFeeEstimates = {
+    originReserveFee: bigint;
+    exchangeFee: bigint;
+    destReserveFee: bigint;
 };
-type TGetXcmFeeEstimateResult = {
-    origin: TGetXcmFeeEstimateDetail;
-    destination: TGetXcmFeeEstimateDetail;
+type TCreateSwapXcmInternalOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner> & {
+    version: Version;
+    fees: TSwapFeeEstimates;
+    paraIdTo?: number;
 };
 
-type TGetBalanceCommonOptions = {
+type TAssetClaimOptionsBase = {
+    chain: TSubstrateChain;
+    currency: WithComplexAmount<TCurrencyCore> | TAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
+    address: TAddress;
+    version?: Version;
+};
+type TAssetClaimOptions<TApi, TRes, TSigner> = WithApi<TAssetClaimOptionsBase, TApi, TRes, TSigner>;
+type TAssetClaimInternalOptions<TApi, TRes, TSigner> = TAssetClaimOptions<TApi, TRes, TSigner> & {
+    version: Version;
+    assets: TAsset<bigint>[];
+};
+
+type TSetBalanceRes = {
+    assetStatusTx?: TSerializedExtrinsics;
+    balanceTx: TSerializedExtrinsics;
+};
+declare abstract class BaseAssetsPallet {
+    protected palletName: TAssetsPallet;
+    constructor(palletName: TAssetsPallet);
+    abstract mint<TApi, TRes, TSigner>(address: string, assetInfo: WithAmount<TAssetInfo>, balance: bigint, chain: TSubstrateChain, api: IPolkadotApi<TApi, TRes, TSigner>): Promise<TSetBalanceRes>;
+    abstract getBalance<TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo, customCurrencyId?: unknown): Promise<bigint>;
+}
+
+/**
+ * Builder class for constructing asset claim transactions.
+ */
+declare class AssetClaimBuilder<TApi, TRes, TSigner, T extends Partial<TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>> = object> {
+    readonly api: IPolkadotApi<TApi, TRes, TSigner>;
+    readonly _options: T;
+    constructor(api: IPolkadotApi<TApi, TRes, TSigner>, options?: T);
     /**
-     * The address of the account.
+     * Specifies the assets to be claimed.
+     *
+     * @param assets - An array of assets to claim in a multi-asset format.
+     * @returns An instance of Builder
      */
-    address: string;
+    currency(currency: TAssetClaimOptionsBase['currency']): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        currency: TAssetClaimOptionsBase['currency'];
+    }>;
     /**
-     * The chain on which to query the balance.
+     * Sets the sender address.
+     *
+     * @param address - The sender address.
+     * @returns
      */
-    chain: TChain;
-};
-/**
- * Retrieves the asset balance for a given account on a specified chain.
- */
-type TGetAssetBalanceOptionsBase = TGetBalanceCommonOptions & {
+    senderAddress(sender: TSender<TSigner>): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        senderAddress: string;
+    }>;
     /**
-     * The resolved asset to query balance for.
+     * Specifies the account address on which the assets will be claimed.
+     *
+     * @param address - The destination account address.
+     * @returns An instance of Builder
      */
-    asset: TAssetInfo;
-};
+    address(address: TAddress): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        address: TAddress;
+    }>;
+    /**
+     * Sets the XCM version to be used for the asset claim.
+     *
+     * @param version - The XCM version.
+     * @returns An instance of Builder
+     */
+    xcmVersion(version: Version): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        version: Version;
+    }>;
+    /**
+     * Builds and returns the asset claim extrinsic.
+     *
+     * @returns A Promise that resolves to the asset claim extrinsic.
+     */
+    build(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase>): Promise<TRes>;
+    signAndSubmit(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>>): Promise<string>;
+    /**
+     * Returns the API instance used by the builder.
+     *
+     * @returns The API instance.
+     */
+    getApi(): TApi;
+    /**
+     * Disconnects the API.
+     *
+     * @returns A Promise that resolves when the API is disconnected.
+     */
+    disconnect(): Promise<void>;
+}
+
+declare class BatchTransactionManager<TApi, TRes, TSigner> {
+    transactionOptions: TBatchedSendOptions<TApi, TRes, TSigner>[];
+    addTransaction(options: TBatchedSendOptions<TApi, TRes, TSigner>): void;
+    isEmpty(): boolean;
+    buildBatch(api: IPolkadotApi<TApi, TRes, TSigner>, from: TSubstrateChain, options?: TBatchOptions): Promise<TRes>;
+}
+
 /**
- * Retrieves the currency balance for a given account on a specified chain.
+ * A builder class for constructing Para-to-Para, Para-to-Relay, Relay-to-Para transactions and asset claims.
  */
-type TGetBalanceOptionsBase = TGetBalanceCommonOptions & {
+declare class GeneralBuilder<TApi, TRes, TSigner, T extends Partial<TSendBaseOptions<TRes> & TBuilderInternalOptions<TSigner>> = object> {
+    readonly batchManager: BatchTransactionManager<TApi, TRes, TSigner>;
+    readonly api: IPolkadotApi<TApi, TRes, TSigner>;
+    readonly _options: T;
+    constructor(api: IPolkadotApi<TApi, TRes, TSigner>, batchManager: BatchTransactionManager<TApi, TRes, TSigner>, options?: T);
     /**
-     * The currency to query.
+     * Specifies the origin chain for the transaction.
+     *
+     * @param chain - The chain from which the transaction originates.
+     * @returns An instance of Builder
      */
-    currency?: TCurrencyCore;
-};
-type TGetBalanceOptions<TApi, TRes> = WithApi<TGetBalanceOptionsBase, TApi, TRes>;
-type TGetAssetBalanceOptions<TApi, TRes> = WithApi<TGetAssetBalanceOptionsBase, TApi, TRes>;
-type TGetTransferableAmountOptionsBase<TRes> = {
+    from(chain: TSubstrateChain): GeneralBuilder<TApi, TRes, TSigner, T & {
+        from: TSubstrateChain;
+    }>;
     /**
-     * The sender address of the account.
+     * Specifies the destination chain for the transaction.
+     *
+     * @param chain - The chain to which the transaction is sent.
+     * @param paraIdTo - (Optional) The parachain ID of the destination chain.
+     * @returns An instance of Builder
      */
-    senderAddress: string;
+    to(chain: TDestination, paraIdTo?: number): GeneralBuilder<TApi, TRes, TSigner, T & {
+        to: TDestination;
+    }>;
     /**
-     * The chain on which to query the balance.
+     * Initiates the process to claim assets from a specified chain.
+     *
+     * @param chain - The chain from which to claim assets.
+     * @returns An instance of Builder
      */
-    origin: TSubstrateChain;
+    claimFrom(chain: TSubstrateChain): AssetClaimBuilder<TApi, TRes, TSigner, {
+        chain: TSubstrateChain;
+    }>;
     /**
-     * The destination chain.
+     * Specifies the currency to be used in the transaction. Symbol, ID, location or multi-asset.
+     *
+     * @param currency - The currency to be transferred.
+     * @returns An instance of Builder
      */
-    destination: TChain;
+    currency(currency: TCurrencyInputWithAmount): GeneralBuilder<TApi, TRes, TSigner, T & {
+        currency: TCurrencyInputWithAmount;
+    }>;
     /**
-     * The currency to query.
+     * Sets the recipient address.
+     *
+     * @param address - The destination address.
+     * @returns An instance of Builder
      */
-    currency: WithAmount<TCurrencyCore>;
+    address(address: TAddress): GeneralBuilder<TApi, TRes, TSigner, T & {
+        address: TAddress;
+    }>;
     /**
-     * The transactions
+     * Sets the sender address.
+     *
+     * @param address - The sender address.
+     * @returns
      */
-    buildTx: TTxFactory<TRes>;
-    feeAsset?: TCurrencyInput;
-};
-type TGetTransferableAmountOptions<TApi, TRes> = WithApi<TGetTransferableAmountOptionsBase<TRes>, TApi, TRes>;
-type TGetMinTransferableAmountOptions<TApi, TRes> = WithApi<TGetTransferableAmountOptionsBase<TRes> & {
-    address: string;
-    builder: GeneralBuilder<TApi, TRes, TSendBaseOptionsWithSenderAddress>;
-}, TApi, TRes>;
-type TVerifyEdOnDestinationOptionsBase<TRes> = {
+    senderAddress(sender: TSender<TSigner>): GeneralBuilder<TApi, TRes, TSigner, T & {
+        senderAddress: string;
+    }>;
     /**
-     * The origin chain.
+     * Sets the asset hub address. This is used for transfers that go through the Asset Hub and originate from an EVM chain.
+     *
+     * @param address - The address to be used.
+     * @returns An instance of Builder
+     */
+    ahAddress(address: string | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
+        ahAddress: string | undefined;
+    }>;
+    /**
+     * Sets the XCM version to be used for the transfer.
+     *
+     * @param version - The XCM version.
+     * @returns An instance of Builder
      */
-    origin: TSubstrateChain;
+    xcmVersion(version: Version): GeneralBuilder<TApi, TRes, TSigner, T & {
+        version: Version;
+    }>;
     /**
-     * The destination chain.
+     * Whether to keep the account alive after the transfer.
+     *
+     * @param value - A boolean indicating whether to keep the account alive.
+     * @returns An instance of Builder
      */
-    destination: TChain;
+    keepAlive(keepAlive: boolean): GeneralBuilder<TApi, TRes, TSigner, T & {
+        keepAlive: boolean;
+    }>;
     /**
-     * The address of the account.
+     * Sets a custom pallet for the transaction.
+     *
+     * @param palletName - The name of the custom pallet to be used.
+     * @returns An instance of the Builder.
      */
-    address: string;
+    customPallet(pallet: string, method: string): GeneralBuilder<TApi, TRes, TSigner, T & {
+        pallet: string;
+        method: string;
+    }>;
     /**
-     * The account of the sender.
+     * Optional fee asset for the transaction.
+     *
+     * @param currency - The currency to be used for the fee.
+     * @returns An instance of the Builder
      */
-    senderAddress: string;
+    feeAsset(currency: TCurrencyInput | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
+        feeAsset: TCurrencyInput | undefined;
+    }>;
     /**
-     * The currency to query.
+     * Sets the hex of the encoded transaction call to apply on the destination chain
+     *
+     * @param hex - The encoded call hex or extrinsics.
+     * @param originKind - (Optional) The means of expressing the message origin as a dispatch origin.
+     * @param maxWeight - (Optional) The weight of the call. If not provided, the weight will be estimated.
+     * @returns An instance of the Builder.
      */
-    currency: WithAmount<TCurrencyCore>;
+    transact(call: string | TRes, originKind?: TTransactOrigin, maxWeight?: TWeight): GeneralBuilder<TApi, TRes, TSigner, T & {
+        transactOptions: {
+            call: string | TRes;
+            originKind: "Native" | "SovereignAccount" | "Superuser" | "Xcm" | undefined;
+            maxWeight: TWeight | undefined;
+        };
+    }>;
     /**
-     * The transactions
+     * Adds the transfer transaction to the batch.
+     *
+     * @returns An instance of Builder
      */
-    buildTx: TTxFactory<TRes>;
-    feeAsset?: TCurrencyInput;
-};
-type TVerifyEdOnDestinationOptions<TApi, TRes> = WithApi<TVerifyEdOnDestinationOptionsBase<TRes>, TApi, TRes>;
-
-type TEvmChainFrom = Extract<TChain, 'Ethereum' | 'Moonbeam' | 'Moonriver' | 'Darwinia'>;
-/**
- * The options for the Ethereum to Polkadot transfer builder.
- */
-type TEvmBuilderOptionsBase = {
+    addToBatch(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptions<TRes>>): GeneralBuilder<TApi, TRes, TSigner, T & {
+        from: TSubstrateChain;
+    }>;
     /**
-     * The source chain. Can be either 'Ethereum', 'Moonbeam', 'Moonriver', or 'Darwinia'.
+     * Builds and returns the batched transaction based on the configured parameters.
+     *
+     * @param options - (Optional) Options to customize the batch transaction.
+     * @returns A Extrinsic representing the batched transactions.
      */
-    from: TEvmChainFrom;
+    buildBatch(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptions<TRes>>, options?: TBatchOptions): Promise<TRes>;
+    protected buildInternal<TOptions extends TSendBaseOptions<TRes>>(this: GeneralBuilder<TApi, TRes, TSigner, TOptions>): Promise<TBuildInternalRes<TApi, TRes, TSigner, TOptions>>;
+    private prepareNormalizedOptions;
     /**
-     * The destination chain on Polkadot network.
+     * Builds and returns the transfer extrinsic.
+     *
+     * @returns A Promise that resolves to the transfer extrinsic.
      */
-    to: TChain;
+    build(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptions<TRes>>): Promise<TRes>;
+    private buildCommon;
+    private maybePerformXcmFormatCheck;
+    dryRun(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<TDryRunResult>;
+    dryRunPreview(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>, dryRunOptions?: TDryRunPreviewOptions): Promise<TDryRunResult>;
+    protected createTxFactory<TOptions extends TSendBaseOptions<TRes>>(this: GeneralBuilder<TApi, TRes, TSigner, TOptions>): TTxFactory<TRes>;
     /**
-     * The currency to transfer. Symbol or ID.
+     * Returns the XCM fee for the transfer using dryRun or paymentInfo function.
+     *
+     * @returns An origin and destination fee.
      */
-    currency: TCurrencyInputWithAmount;
+    getXcmFee<TDisableFallback extends boolean = false>(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>, options?: TGetXcmFeeBuilderOptions & {
+        disableFallback: TDisableFallback;
+    }): Promise<TGetXcmFeeResult<TDisableFallback>>;
     /**
-     * The Polkadot destination address.
+     * Returns the origin XCM fee for the transfer using dryRun or paymentInfo function.
+     *
+     * @returns An origin fee.
      */
-    address: string;
+    getOriginXcmFee(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>, { disableFallback }?: TGetXcmFeeBuilderOptions): Promise<TXcmFeeDetail & {
+        forwardedXcms?: unknown;
+        destParaId?: number;
+    }>;
     /**
-     * The AssetHub address
+     * Estimates the origin and destination XCM fee using the `paymentInfo` function.
+     *
+     * @deprecated This function is deprecated and will be removed in a future version.
+     * Please use `builder.getXcmFee()` instead, where `builder` is an instance of `Builder()`.
+     * Will be removed in v13.
+     * For more details, see the documentation:
+     * {@link https://paraspell.github.io/docs/sdk/xcmPallet.html#xcm-fee-origin-and-dest}
+     *
+     * @returns An origin and destination fee estimate.
      */
-    ahAddress?: string;
+    getXcmFeeEstimate(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<TGetXcmFeeEstimateResult>;
     /**
-     * The Ethereum signer.
+     * Estimates the origin XCM fee using paymentInfo function.
+     *
+     * @deprecated This function is deprecated and will be removed in a future version.
+     * Please use `builder.getOriginXcmFee()` instead, where `builder` is an instance of `Builder()`.
+     * Will be removed in v13.
+     * For more details, see the documentation:
+     * {@link https://paraspell.github.io/docs/sdk/xcmPallet.html#xcm-fee-origin-and-dest}
+     *
+     * @returns An origin fee estimate.
      */
-    signer: WalletClient;
-};
-type TEvmBuilderOptions<TApi, TRes> = WithApi<TEvmBuilderOptionsBase, TApi, TRes>;
-type TSerializeEthTransferOptions = Omit<TEvmBuilderOptionsBase, 'signer'> & {
-    destAddress: string;
-};
-type TSerializedEthTransfer = {
-    token: string;
-    destinationParaId: number;
-    destinationFee: bigint;
-    amount: bigint;
-    fee: bigint;
-};
-/**
- * The options for the batch builder.
- */
-declare enum BatchMode {
+    getOriginXcmFeeEstimate(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<TGetXcmFeeEstimateDetail>;
     /**
-     * Does not commit if one of the calls in the batch fails.
+     * Returns the max transferable amount for the transfer
+     *
+     * @returns The max transferable amount.
      */
-    BATCH_ALL = "BATCH_ALL",
+    getTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<bigint>;
     /**
-     * Commits each successful call regardless if a call fails.
+     * Returns the min transferable amount for the transfer
+     *
+     * @returns The min transferable amount.
      */
-    BATCH = "BATCH"
-}
-/**
- * The options for the batch builder.
- */
-type TBatchOptions = {
+    getMinTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<bigint>;
     /**
-     * The batch mode. Can be either:
-     * `BATCH_ALL` - does not commit if one of the calls in the batch fails.
-     * `BATCH` - commits each successful call regardless if a call fails.
+     * Returns the max transferable amount for the transfer
+     *
+     * @returns The max transferable amount.
      */
-    mode: BatchMode;
-};
-type TDryRunPreviewOptions = {
-    mintFeeAssets?: boolean;
-};
-type TBuilderOptions<TApi> = TApi | TBuilderConfig<TApi>;
-type TBuilderConfig<TApi> = Partial<{
-    apiOverrides: Partial<Record<TChain, TApi>>;
-    development: boolean;
-    abstractDecimals: boolean;
-    xcmFormatCheck: boolean;
-}>;
-type TCreateTxsOptions<TApi, TRes> = Pick<TSendOptions<TApi, TRes>, 'api' | 'from' | 'to' | 'currency'>;
-type TBatchedSendOptions<TApi, TRes> = Omit<TSendOptions<TApi, TRes>, 'isAmountAll'> & {
-    builder: GeneralBuilder<TApi, TRes, TSendBaseOptions>;
-};
-type TBuildInternalRes<TApi, TRes, TOptions extends TSendBaseOptions = TSendBaseOptions> = {
-    tx: TRes;
-    options: TSendOptions<TApi, TRes> & TOptions;
-};
-type TBuilderInternalOptions = {
-    path?: string;
-};
-
-type TProviderEntry = {
-    name: string;
-    endpoint: string;
-};
-type TChainConfig = {
-    name: string;
-    info: string;
-    paraId: number;
-    providers: TProviderEntry[];
-};
-type TChainConfigMap = Record<TSubstrateChain, TChainConfig>;
-
-type OneKey<K extends string, V = unknown> = {
-    [P in K]: Record<P, V> & Partial<Record<Exclude<K, P>, never>> extends infer O ? {
-        [Q in keyof O]: O[Q];
-    } : never;
-}[K];
-type TXcmVersioned<T> = OneKey<Version, T>;
-type TXcmForeignAsset = {
-    ForeignAsset: string | number | bigint | undefined;
-};
-type TForeignAssetId = {
-    ForeignAssetId: bigint | undefined;
-};
-type TForeignOrTokenAsset = TXcmForeignAsset | {
-    Token: string | undefined;
-};
-type TForeignOrNativeAsset = TXcmForeignAsset | 'Native';
-type TXcmAsset = {
-    XCM: number | undefined;
-} | {
-    Native: null;
-};
-type TMantaAsset = {
-    MantaCurrency: bigint | undefined;
-};
-type TNativeTokenAsset = 'NativeToken';
-type TNodleAsset = 'NodleNative';
-type TZeitgeistAsset = 'Ztg';
-type TOtherReserveAsset = {
-    OtherReserve: string | bigint | undefined;
-};
-type TSelfReserveAsset = 'SelfReserve';
-type TReserveAsset = TOtherReserveAsset | TSelfReserveAsset;
-type TBifrostToken = {
-    Native: string | number;
-} | {
-    VToken: string;
-} | {
-    Token: string;
-} | {
-    VSToken2: number;
-} | {
-    VToken2: number;
-} | {
-    Token2: number;
-};
-type TXTokensCurrencySelection = TXcmVersioned<TLocation | TAsset | TAsset[]> | TXcmForeignAsset | TForeignAssetId | TForeignOrTokenAsset | TXcmAsset | TMantaAsset | TOtherReserveAsset | TBifrostToken | string | bigint | number | undefined;
-
-declare class AmountTooLowError extends Error {
-    constructor(message?: string);
-}
-
-/**
- * Error thrown when a batch operation is invalid or cannot be executed.
- */
-declare class BatchValidationError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when the Ethereum bridge is halted.
- */
-declare class BridgeHaltedError extends Error {
+    verifyEdOnDestination(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<boolean>;
     /**
-     * Constructs a new BridgeHaltedError.
+     * Returns the transfer info for the transfer
      *
-     * @param message - Optional custom error message.
+     * @returns The transfer info.
      */
-    constructor();
-}
-
-/**
- * Error thrown when the Dry Run fails.
- */
-declare class DryRunFailedError extends Error {
-    readonly reason: string;
-    readonly dryRunType?: TChainEndpoint;
+    getTransferInfo(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<TTransferInfo>;
     /**
-     * Constructs a new DryRunFailedError.
+     * Returns the receivable amount on the destination after the transfer
      *
-     * @param reason - The reason why the dry run failed.
-     * @param dryRunType - Optional. Specifies if the error is related to the 'origin' or 'destination' dry run.
+     * @returns The computed receivable amount.
+     * @throws \{UnableToComputeError\} Thrown when the receivable amount cannot be determined.
      */
-    constructor(reason: string, dryRunType?: TChainEndpoint);
-}
-
-/**
- * Error thrown when a feature or route is temporarily disabled via configuration or governance.
- */
-declare class FeatureTemporarilyDisabledError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when an invalid address is provided.
- */
-declare class InvalidAddressError extends Error {
+    getReceivableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>): Promise<bigint>;
+    signAndSubmit(this: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes> & TBuilderInternalOptions<TSigner>>): Promise<string>;
     /**
-     * Constructs a new InvalidAddressError.
+     * Returns the API instance used by the builder.
      *
-     * @param message - The error message.
+     * @returns The API instance.
      */
-    constructor(message: string);
-}
-
-/**
- * Error development mode is on and no API override is provided for a specific chain.
- */
-declare class MissingChainApiError extends Error {
+    getApi(): TApi;
     /**
-     * Constructs a new MissingChainApiError.
+     * Disconnects the API.
      *
-     * @param chain - The chain for which the API is missing.
+     * @returns A Promise that resolves when the API is disconnected.
      */
-    constructor(chain: TChain);
+    disconnect(): Promise<void>;
 }
-
 /**
- * Error thrown when a required parameter is missing.
+ * Creates a new Builder instance.
+ *
+ * @param api - The API instance to use for building transactions. If not provided, a new instance will be created.
+ * @returns A new Builder instance.
  */
-declare class MissingParameterError extends Error {
-    constructor(parameter: string | string[], message?: string);
-}
+declare const Builder: <TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>) => GeneralBuilder<TApi, TRes, TSigner, object>;
 
-/**
- * Used to inform user, that Parachain they wish to use has not yet implemented full XCM Support
- */
-declare class NoXCMSupportImplementedError extends Error {
+type TSwapConfig = {
+    currencyTo: TCurrencyCore;
+    exchangeChain: TParachain;
+};
+type TDryRunBaseOptions<TRes> = {
+    tx: TRes;
+    origin: TSubstrateChain;
+    destination: TChain;
+    senderAddress: string;
+    address: string;
+    currency: TCurrencyInputWithAmount;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    swapConfig?: TSwapConfig;
+    useRootOrigin?: boolean;
+    bypassOptions?: TBypassOptions;
+};
+type TDryRunOptions<TApi, TRes, TSigner> = WithApi<TDryRunBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunCallBaseOptions<TRes> = {
     /**
-     * Constructs a new NoXCMSupportImplementedError.
-     *
-     * @param chain - The chain for which XCM support is not implemented.
+     * The transaction to dry-run
      */
-    constructor(chain: TChain);
-}
-
-/**
- * Error thrown when numeric input is invalid or cannot be parsed.
- */
-declare class NumberFormatError extends Error {
-    constructor(message?: string);
-}
-
-/**
- * Error thrown when asset or currency overrides are invalid or conflicting.
- */
-declare class OverrideConflictError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when no provider or RPC endpoint is available for the requested chain.
- */
-declare class ProviderUnavailableError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when routing or path resolution fails.
- */
-declare class RoutingResolutionError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when a required runtime API is not available on the target chain.
- */
-declare class RuntimeApiUnavailableError extends Error {
-    constructor(chain: string, apiName: string);
-}
-
-type TScenarioNotSupportedContext = {
+    tx: TRes;
+    /**
+     * The chain to dry-run on
+     */
+    chain: TSubstrateChain;
+    /**
+     * The destination chain
+     */
+    destination: TDestination;
+    /**
+     * The address to dry-run with (senderAddress)
+     */
+    address: string;
+    /**
+     * Whether to use the root origin
+     */
+    useRootOrigin?: boolean;
+    /**
+     * XCM version to use for the dry-run parameters
+     */
+    version: Version;
+    asset: WithAmount<TAssetInfo>;
+    bypassOptions?: TBypassOptions;
+    feeAsset?: TAssetInfo;
+};
+type TDryRunBypassOptions<TApi, TRes, TSigner> = WithApi<Omit<TDryRunCallBaseOptions<TRes>, 'useRootOrigin' | 'destination'>, TApi, TRes, TSigner>;
+type TDryRunCallOptions<TApi, TRes, TSigner> = WithApi<TDryRunCallBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunXcmBaseOptions<TRes> = {
+    originLocation: any;
+    /**
+     * The XCM instructions
+     */
+    xcm: any;
+    /** The transaction to dry-run */
+    tx: TRes;
+    /**
+     * The chain to dry-run on
+     */
+    chain: TSubstrateChain;
+    /**
+     * The origin chain
+     */
+    origin: TSubstrateChain;
+    asset: TAssetInfo;
+    version: Version;
+    feeAsset?: TAssetInfo;
+    amount: bigint;
+    originFee: bigint;
+};
+type TDryRunXcmOptions<TApi, TRes, TSigner> = WithApi<TDryRunXcmBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunResBase = {
+    asset: TAssetInfo;
+};
+type TDryRunChainSuccess = TDryRunResBase & {
+    success: true;
+    fee: bigint;
+    weight?: TWeight;
+    forwardedXcms: any;
+    destParaId?: number;
+};
+type TDryRunChainFailure = TDryRunResBase & {
+    success: false;
+    failureReason: string;
+    failureSubReason?: string;
+};
+type TDryRunChainResult = TDryRunChainSuccess | TDryRunChainFailure;
+type THopInfo = {
     chain: TChain;
-    scenario: TScenario;
+    result: TDryRunChainResult;
 };
-/**
- * Error thrown when a scenario, route, or chain capability is not supported.
- */
-declare class ScenarioNotSupportedError extends Error {
-    constructor(message: string);
-    constructor({ chain, scenario }: TScenarioNotSupportedContext);
+type TChainEndpoint = 'origin' | 'destination' | TChain;
+type TDryRunResult = {
+    failureReason?: string;
+    failureSubReason?: string;
+    failureChain?: TChainEndpoint;
+    origin: TDryRunChainResult;
+    destination?: TDryRunChainResult;
+    hops: THopInfo[];
+};
+type TResolveHopParams<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    tx: TRes;
+    originChain: TSubstrateChain;
+    currentChain: TSubstrateChain;
+    destination: TDestination;
+    asset: TAssetInfo;
+    currency: TCurrencyInputWithAmount;
+    swapConfig?: TSwapConfig;
+    hasPassedExchange: boolean;
+};
+type HopProcessParams<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    currentChain: TSubstrateChain;
+    currentOrigin: TSubstrateChain;
+    currentAsset: TAssetInfo;
+    forwardedXcms: any;
+    hasPassedExchange: boolean;
+    isDestination: boolean;
+};
+type HopTraversalConfig<TApi, TRes, TSigner, THopResult> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    currency: TCurrencyCore;
+    initialForwardedXcms: any;
+    initialDestParaId: number | undefined;
+    swapConfig?: TSwapConfig;
+    processHop: (params: HopProcessParams<TApi, TRes, TSigner>) => Promise<THopResult>;
+    shouldContinue: (hopResult: THopResult) => boolean;
+    extractNextHopData: (hopResult: THopResult) => {
+        forwardedXcms: any;
+        destParaId: number | undefined;
+    };
+};
+type HopTraversalResult<THopResult> = {
+    hops: Array<{
+        chain: TSubstrateChain;
+        result: THopResult;
+    }>;
+    destination?: THopResult;
+    lastProcessedChain?: TSubstrateChain;
+};
+type TBypassOptions = {
+    mintFeeAssets?: boolean;
+    sentAssetMintMode?: 'preview' | 'bypass';
+};
+declare enum XTokensError {
+    AssetHasNoReserve = "AssetHasNoReserve",
+    NotCrossChainTransfer = "NotCrossChainTransfer",
+    InvalidDest = "InvalidDest",
+    NotCrossChainTransferableCurrency = "NotCrossChainTransferableCurrency",
+    UnweighableMessage = "UnweighableMessage",
+    XcmExecutionFailed = "XcmExecutionFailed",
+    CannotReanchor = "CannotReanchor",
+    InvalidAncestry = "InvalidAncestry",
+    InvalidAsset = "InvalidAsset",
+    DestinationNotInvertible = "DestinationNotInvertible",
+    BadVersion = "BadVersion",
+    DistinctReserveForAssetAndFee = "DistinctReserveForAssetAndFee",
+    ZeroFee = "ZeroFee",
+    ZeroAmount = "ZeroAmount",
+    TooManyAssetsBeingSent = "TooManyAssetsBeingSent",
+    AssetIndexNonExistent = "AssetIndexNonExistent",
+    FeeNotEnough = "FeeNotEnough",
+    NotSupportedLocation = "NotSupportedLocation",
+    MinXcmFeeNotDefined = "MinXcmFeeNotDefined",
+    RateLimited = "RateLimited"
 }
-
-declare class TransferToAhNotSupported extends Error {
-    constructor(message?: string);
+declare enum PolkadotXcmError {
+    Unreachable = "Unreachable",
+    SendFailure = "SendFailure",
+    Filtered = "Filtered",
+    UnweighableMessage = "UnweighableMessage",
+    DestinationNotInvertible = "DestinationNotInvertible",
+    Empty = "Empty",
+    CannotReanchor = "CannotReanchor",
+    TooManyAssets = "TooManyAssets",
+    InvalidOrigin = "InvalidOrigin",
+    BadVersion = "BadVersion",
+    BadLocation = "BadLocation",
+    NoSubscription = "NoSubscription",
+    AlreadySubscribed = "AlreadySubscribed",
+    CannotCheckOutTeleport = "CannotCheckOutTeleport",
+    LowBalance = "LowBalance",
+    TooManyLocks = "TooManyLocks",
+    AccountNotSovereign = "AccountNotSovereign",
+    FeesNotMet = "FeesNotMet",
+    LockNotFound = "LockNotFound",
+    InUse = "InUse",
+    REMOVED = "REMOVED",
+    InvalidAssetUnknownReserve = "InvalidAssetUnknownReserve",
+    InvalidAssetUnsupportedReserve = "InvalidAssetUnsupportedReserve",
+    TooManyReserves = "TooManyReserves",
+    LocalExecutionIncomplete = "LocalExecutionIncomplete",
+    TooManyAuthorizedAliases = "TooManyAuthorizedAliases",
+    ExpiresInPast = "ExpiresInPast",
+    AliasNotFound = "AliasNotFound",
+    LocalExecutionIncompleteWithError = "LocalExecutionIncompleteWithError"
 }
-
-declare class TypeAndThenUnavailableError extends Error {
-    constructor(message: string);
+declare enum PolkadotXcmExecutionError {
+    Overflow = "Overflow",
+    Unimplemented = "Unimplemented",
+    UntrustedReserveLocation = "UntrustedReserveLocation",
+    UntrustedTeleportLocation = "UntrustedTeleportLocation",
+    LocationFull = "LocationFull",
+    LocationNotInvertible = "LocationNotInvertible",
+    BadOrigin = "BadOrigin",
+    InvalidLocation = "InvalidLocation",
+    AssetNotFound = "AssetNotFound",
+    FailedToTransactAsset = "FailedToTransactAsset",
+    NotWithdrawable = "NotWithdrawable",
+    LocationCannotHold = "LocationCannotHold",
+    ExceedsMaxMessageSize = "ExceedsMaxMessageSize",
+    DestinationUnsupported = "DestinationUnsupported",
+    Transport = "Transport",
+    Unroutable = "Unroutable",
+    UnknownClaim = "UnknownClaim",
+    FailedToDecode = "FailedToDecode",
+    MaxWeightInvalid = "MaxWeightInvalid",
+    NotHoldingFees = "NotHoldingFees",
+    TooExpensive = "TooExpensive",
+    Trap = "Trap",
+    ExpectationFalse = "ExpectationFalse",
+    PalletNotFound = "PalletNotFound",
+    NameMismatch = "NameMismatch",
+    VersionIncompatible = "VersionIncompatible",
+    HoldingWouldOverflow = "HoldingWouldOverflow",
+    ExportError = "ExportError",
+    ReanchorFailed = "ReanchorFailed",
+    NoDeal = "NoDeal",
+    FeesNotMet = "FeesNotMet",
+    LockError = "LockError",
+    NoPermission = "NoPermission",
+    Unanchored = "Unanchored",
+    NotDepositable = "NotDepositable",
+    TooManyAssets = "TooManyAssets",
+    UnhandledXcmVersion = "UnhandledXcmVersion",
+    WeightLimitReached = "WeightLimitReached",
+    Barrier = "Barrier",
+    WeightNotComputable = "WeightNotComputable",
+    ExceedsStackLimit = "ExceedsStackLimit"
 }
+type TModuleError = {
+    index: string;
+    error: string;
+};
+type TDryRunError = {
+    failureReason: string;
+    failureSubReason?: string;
+};
 
-/**
- * UnableToComputeError is thrown when a computation cannot be performed.
- */
-declare class UnableToComputeError extends Error {
+type TXcmFeeSwapConfig = TSwapConfig & {
+    amountOut: bigint;
+};
+type TTxFactory<TRes> = (amount?: string, relative?: boolean) => Promise<TRes>;
+type TGetXcmFeeBaseOptions<TRes, TDisableFallback extends boolean = boolean> = {
     /**
-     * Constructs a new UnableToComputeError.
-     *
-     * @param message - Required error message.
+     * The transaction factory
      */
-    constructor(message: string);
-}
-
-/**
- * Error thrown when an operation or parameter combination is not supported.
- */
-declare class UnsupportedOperationError extends Error {
-    constructor(message: string);
-}
-
-type THopTransferInfo = {
-    chain: TChain;
-    result: {
-        xcmFee: TXcmFeeBase;
-        asset: TAssetInfo;
-    };
-};
-type TXcmFeeBase = {
-    fee: bigint;
-    asset: TAssetInfo;
+    buildTx: TTxFactory<TRes>;
+    /**
+     * The origin chain
+     */
+    origin: TSubstrateChain;
+    /**
+     * The destination chain
+     */
+    destination: TChain;
+    /**
+     * The sender address
+     */
+    senderAddress: string;
+    address: string;
+    currency: WithAmount<TCurrencyCore>;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    disableFallback: TDisableFallback;
+    swapConfig?: TXcmFeeSwapConfig;
+    skipReverseFeeCalculation?: boolean;
 };
-type TTransferInfo = {
-    chain: {
-        origin: TChain;
-        destination: TChain;
-        ecosystem: string;
-    };
-    origin: {
-        selectedCurrency: {
-            sufficient: boolean;
-            balance: bigint;
-            balanceAfter: bigint;
-            asset: TAssetInfo;
-        };
-        xcmFee: TXcmFeeBase & {
-            sufficient: boolean;
-            balance: bigint;
-            balanceAfter: bigint;
-        };
-    };
-    hops: THopTransferInfo[];
-    destination: {
-        receivedCurrency: {
-            sufficient: boolean | UnableToComputeError;
-            receivedAmount: bigint | UnableToComputeError;
-            balance: bigint;
-            balanceAfter: bigint | UnableToComputeError;
-            asset: TAssetInfo;
-        };
-        xcmFee: TXcmFeeBase & {
-            balanceAfter: bigint | UnableToComputeError;
-        };
-    };
+type TGetXcmFeeOptions<TApi, TRes, TSigner, TDisableFallback extends boolean = boolean> = WithApi<TGetXcmFeeBaseOptions<TRes, TDisableFallback>, TApi, TRes, TSigner>;
+type TGetXcmFeeInternalOptions<TApi, TRes, TSigner, TDisableFallback extends boolean = boolean> = Omit<TGetXcmFeeOptions<TApi, TRes, TSigner, TDisableFallback>, 'buildTx'> & {
+    tx: TRes;
+    useRootOrigin: boolean;
 };
-type BuildHopInfoOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
-    chain: TSubstrateChain;
-    fee: bigint;
-    originChain: TSubstrateChain;
-    currency: TCurrencyCore;
-    asset: TAssetInfo;
-    senderAddress: string;
-    ahAddress?: string;
+type TGetXcmFeeEstimateOptions<TApi, TRes, TSigner> = Omit<TGetXcmFeeInternalOptions<TApi, TRes, TSigner>, 'disableFallback' | 'useRootOrigin' | 'buildTx' | 'version'>;
+type TGetOriginXcmFeeEstimateOptions<TApi, TRes, TSigner> = Omit<TGetXcmFeeInternalOptions<TApi, TRes, TSigner>, 'disableFallback' | 'address' | 'useRootOrigin' | 'buildTx' | 'version'>;
+type TGetXcmFeeBuilderOptions = {
+    disableFallback: boolean;
 };
-type TBuildDestInfoOptions<TApi, TRes> = {
-    api: IPolkadotApi<TApi, TRes>;
+type TGetOriginXcmFeeBaseOptions<TRes> = {
+    buildTx: TTxFactory<TRes>;
     origin: TSubstrateChain;
     destination: TChain;
-    address: string;
+    senderAddress: string;
     currency: WithAmount<TCurrencyCore>;
-    originFee: bigint;
-    isFeeAssetAh: boolean;
-    destFeeDetail: TXcmFeeDetail;
-    totalHopFee: bigint;
-    bridgeFee?: bigint;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    disableFallback: boolean;
+    useRootOrigin?: boolean;
 };
-type TOriginFeeDetails = {
-    sufficientForXCM: boolean;
-    xcmFee: bigint;
+type TGetOriginXcmFeeOptions<TApi, TRes, TSigner> = WithApi<TGetOriginXcmFeeBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TGetOriginXcmFeeInternalOptions<TApi, TRes, TSigner> = Omit<TGetOriginXcmFeeOptions<TApi, TRes, TSigner>, 'buildTx'> & {
+    tx: TRes;
 };
-type TGetTransferInfoOptionsBase<TRes> = {
-    buildTx: TTxFactory<TRes>;
+type TGetFeeForDestChainBaseOptions<TRes> = {
+    prevChain: TSubstrateChain;
     origin: TSubstrateChain;
     destination: TChain;
     senderAddress: string;
-    ahAddress?: string;
     address: string;
     currency: WithAmount<TCurrencyCore>;
-    feeAsset?: TCurrencyCore;
+    forwardedXcms: any;
+    tx: TRes;
+    asset: TAssetInfo;
+    version: Version;
+    originFee: bigint;
+    feeAsset?: TCurrencyInput;
+    disableFallback: boolean;
+    hasPassedExchange?: boolean;
+    swapConfig?: TXcmFeeSwapConfig;
+    skipReverseFeeCalculation?: boolean;
 };
-type TGetTransferInfoOptions<TApi, TRes> = WithApi<TGetTransferInfoOptionsBase<TRes>, TApi, TRes>;
-
-type TChainWithApi<TApi, TRes, T = TSubstrateChain> = {
-    api: IPolkadotApi<TApi, TRes>;
-    chain: T;
+type TGetFeeForDestChainOptions<TApi, TRes, TSigner> = WithApi<TGetFeeForDestChainBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TGetReverseTxFeeOptions<TApi, TRes, TSigner> = Omit<TGetFeeForDestChainOptions<TApi, TRes, TSigner>, 'destination' | 'disableFallback' | 'forwardedXcms' | 'asset' | 'originFee' | 'prevChain' | 'version'> & {
+    destination: TSubstrateChain;
 };
-type TTypeAndThenCallContext<TApi, TRes> = {
-    origin: TChainWithApi<TApi, TRes>;
-    dest: TChainWithApi<TApi, TRes>;
-    reserve: TChainWithApi<TApi, TRes, TChain>;
-    isSubBridge: boolean;
-    isSnowbridge: boolean;
-    isRelayAsset: boolean;
-    assetInfo: WithAmount<TAssetWithLocation>;
-    systemAsset: TAssetInfo;
-    options: TPolkadotXCMTransferOptions<TApi, TRes>;
+type TFeeType = 'dryRun' | 'paymentInfo' | 'noFeeRequired';
+type TXcmFeeBase$1 = {
+    asset: TAssetInfo;
+    weight?: TWeight;
+    sufficient?: boolean;
 };
-type TTypeAndThenFees = {
-    hopFees: bigint;
-    destFee: bigint;
+type TXcmFeeDetailSuccess = TXcmFeeBase$1 & {
+    fee: bigint;
+    feeType: TFeeType;
+    dryRunError?: string;
+    dryRunSubError?: string;
+};
+type TXcmFeeDetailWithFallback = TXcmFeeDetailSuccess;
+type TXcmFeeDetailError = TXcmFeeBase$1 & {
+    fee?: bigint;
+    feeType?: TFeeType;
+    dryRunError: string;
+    dryRunSubError?: string;
+};
+type TXcmFeeDetail = TXcmFeeDetailSuccess | TXcmFeeDetailError;
+type TXcmFeeHopResult = {
+    fee?: bigint;
+    feeType?: TFeeType;
+    sufficient?: boolean;
+    dryRunError?: string;
+    dryRunSubError?: string;
+    forwardedXcms?: any;
+    destParaId?: number;
+    asset: TAssetInfo;
+};
+type TConditionalXcmFeeDetail<TDisableFallback extends boolean> = TDisableFallback extends false ? TXcmFeeDetailWithFallback : TXcmFeeDetail;
+type TDestXcmFeeDetail<TDisableFallback extends boolean> = TConditionalXcmFeeDetail<TDisableFallback> & {
+    forwardedXcms?: any;
+    destParaId?: number;
+};
+type TConditionalXcmFeeHopInfo<TDisableFallback extends boolean> = {
+    chain: TChain;
+    result: TConditionalXcmFeeDetail<TDisableFallback>;
+};
+type TXcmFeeHopInfo = {
+    chain: TChain;
+    result: TXcmFeeDetail;
+};
+type TGetXcmFeeResult<TDisableFallback extends boolean = boolean> = {
+    failureReason?: string;
+    failureChain?: TChainEndpoint;
+    origin: TConditionalXcmFeeDetail<TDisableFallback>;
+    destination: TConditionalXcmFeeDetail<TDisableFallback>;
+    hops: TConditionalXcmFeeHopInfo<TDisableFallback>[];
+};
+type TGetXcmFeeEstimateDetail = {
+    fee: bigint;
+    asset: TAssetInfo;
+    sufficient?: boolean;
 };
-type TTypeAndThenOverrides = {
-    reserveChain?: TSubstrateChain;
-    noFeeAsset?: boolean;
+type TGetXcmFeeEstimateResult = {
+    origin: TGetXcmFeeEstimateDetail;
+    destination: TGetXcmFeeEstimateDetail;
 };
-
-declare const keyFromWs: (ws: TUrl) => TClientKey;
-declare const createClientPoolHelpers: <TClient>(clientPool: ClientCache<TClient>, createClient: (ws: TUrl, useLegacy: boolean) => TClient | Promise<TClient>) => {
-    leaseClient: (ws: TUrl, ttlMs: number, useLegacy: boolean) => Promise<TClient>;
-    releaseClient: (ws: TUrl) => void;
+type TPaymentInfo = {
+    partialFee: bigint;
+    weight: TWeight;
 };
 
-declare const createClientCache: <T>(maxSize: number, pingClient: (client: T) => Promise<void>, onEviction?: (key: TClientKey, value: TClientEntry<T>) => void, extensionMs?: number) => ClientCache<T>;
-
-declare const blake2b256: (msg: Uint8Array) => Uint8Array<ArrayBufferLike>;
-declare const blake2b512: (msg: Uint8Array) => Uint8Array<ArrayBufferLike>;
-declare const deriveAccountId: (raw: Uint8Array) => Uint8Array;
-declare const encodeSs58: (payload: Uint8Array, network: number) => string;
-declare const convertSs58: <TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, chain: TSubstrateChain) => string;
-
-declare const getAssetBalanceInternal: <TApi, TRes>({ api, address, chain, asset }: TGetAssetBalanceOptions<TApi, TRes>) => Promise<bigint>;
-declare const getBalanceInternal: <TApi, TRes>(options: TGetBalanceOptions<TApi, TRes>) => Promise<bigint>;
-declare const getBalance: <TApi, TRes>(options: TGetBalanceOptions<TApi, TRes>) => Promise<bigint>;
-
-declare const getEthErc20Balance: (chain: TExternalChain, asset: TAssetInfo, address: string) => Promise<bigint>;
-
-declare const getMoonbeamErc20Balance: (chain: TSubstrateChain, assetId: string, address: string) => Promise<bigint>;
-
-declare const getChainConfig: (chain: TSubstrateChain) => TChainConfig;
-
-declare const getChainProviders: (chain: TSubstrateChain) => string[];
-
-/**
- * Retrieves the parachain ID for a specified chain.
- *
- * @param chain - The chain for which to get the paraId.
- * @returns The parachain ID of the chain.
- */
-declare const getParaId: (chain: TChain) => number;
-
+type TGetBalanceCommonOptions = {
+    /**
+     * The address of the account.
+     */
+    address: string;
+    /**
+     * The chain on which to query the balance.
+     */
+    chain: TChain;
+};
 /**
- * Retrieves the chain name corresponding to a specified parachain ID.
- *
- * @param paraId - The parachain ID.
- * @returns The chain name if found; otherwise, null.
+ * Retrieves the asset balance for a given account on a specified chain.
  */
-declare const getTChain: (paraId: number, ecosystem: TRelaychain | TExternalChain) => TChain | null;
-
-declare abstract class Chain<TApi, TRes> {
-    private readonly _chain;
-    private readonly _info;
-    private readonly _ecosystem;
-    private readonly _version;
-    constructor(chain: TSubstrateChain, info: string, ecosystem: TRelaychain, version: Version);
-    get info(): string;
-    get ecosystem(): TRelaychain;
-    get chain(): TSubstrateChain;
-    get version(): Version;
-    canUseXTokens(options: TSendInternalOptions<TApi, TRes>): boolean;
-    isRelayToParaEnabled(): boolean;
-    transfer(sendOptions: TSendInternalOptions<TApi, TRes>): Promise<TRes>;
-    throwIfCantReceive(destChain: TChain | undefined): void;
-    throwIfTempDisabled(options: TSendInternalOptions<TApi, TRes>, destChain?: TChain): void;
-    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes>): boolean;
-    isReceivingTempDisabled(_scenario: TScenario): boolean;
-    canReceiveFrom(_origin: TChain): boolean;
-    shouldUseNativeAssetTeleport({ assetInfo: asset, to }: TSendInternalOptions<TApi, TRes>): boolean;
-    createAsset(asset: WithAmount<TAssetInfo>, version: Version): TAsset;
-    getNativeAssetSymbol(): string;
-    transferLocal(options: TSendInternalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-    protected transferToEthereum<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>, useOnlyDepositInstruction?: boolean): Promise<TRes>;
-    getBalanceNative(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-    getCustomCurrencyId(_asset: TAssetInfo): unknown;
-    getBalanceForeign<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-    getBalance(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
-
-declare class Acala<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
-    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
-    getBalance(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
-
-declare class Ajuna<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class AjunaPaseo<TApi, TRes> extends Ajuna<TApi, TRes> {
-    constructor();
-}
-
-declare class Altair<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): TForeignOrNativeAsset;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Amplitude<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): TXcmAsset;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-}
-
-declare class AssetHubKusama<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getBalanceForeign<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
-
-declare class AssetHubPolkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    handleEthBridgeNativeTransfer<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferPolkadotXCM<TApi, TRes>(options: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getBalanceForeign<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
-
-declare class AssetHubPaseo<TApi, TRes> extends AssetHubPolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class AssetHubWestend<TApi, TRes> extends AssetHubPolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class Astar<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Hydration<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferMoonbeamWhAsset<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Basilisk<TApi, TRes> extends Hydration<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class BifrostPolkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    getCustomCurrencyId(asset: TAssetInfo): {
-        Native: string;
-        VToken?: undefined;
-        Token?: undefined;
-        VSToken2?: undefined;
-        VToken2?: undefined;
-        Token2?: undefined;
-    } | {
-        VToken: string;
-        Native?: undefined;
-        Token?: undefined;
-        VSToken2?: undefined;
-        VToken2?: undefined;
-        Token2?: undefined;
-    } | {
-        Token: string;
-        Native?: undefined;
-        VToken?: undefined;
-        VSToken2?: undefined;
-        VToken2?: undefined;
-        Token2?: undefined;
-    } | {
-        VSToken2: number;
-        Native?: undefined;
-        VToken?: undefined;
-        Token?: undefined;
-        VToken2?: undefined;
-        Token2?: undefined;
-    } | {
-        VToken2: number;
-        Native?: undefined;
-        VToken?: undefined;
-        Token?: undefined;
-        VSToken2?: undefined;
-        Token2?: undefined;
-    } | {
-        Token2: number;
-        Native?: undefined;
-        VToken?: undefined;
-        Token?: undefined;
-        VSToken2?: undefined;
-        VToken2?: undefined;
-    };
-    transferPolkadotXCM<TApi, TRes>(options: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class BifrostKusama<TApi, TRes> extends BifrostPolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class BifrostPaseo<TApi, TRes> extends BifrostPolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class BridgeHubKusama<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class BridgeHubPolkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class BridgeHubPaseo<TApi, TRes> extends BridgeHubPolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class BridgeHubWestend<TApi, TRes> extends BridgeHubPolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class Centrifuge<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): "Native" | {
-        ForeignAsset: number;
-    };
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Collectives<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class CollectivesWestend<TApi, TRes> extends Collectives<TApi, TRes> {
-    constructor();
-}
-
-declare class CoretimeKusama<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class CoretimePolkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    canReceiveFrom(origin: TChain): boolean;
-}
-
-declare class CoretimePaseo<TApi, TRes> extends CoretimePolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class CoretimeWestend<TApi, TRes> extends CoretimePolkadot<TApi, TRes> {
-    constructor();
-}
-
-declare class Crab<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Crust<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    private getCurrencySelection;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class CrustShadow<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    private getCurrencySelection;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Curio<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes>): boolean;
-    isReceivingTempDisabled(_scenario: TScenario): boolean;
-}
-
-declare class Darwinia<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
-
-declare class Encointer<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class EnergyWebX<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
-    getBalanceForeign<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
-
-declare class EnergyWebXPaseo<TApi, TRes> extends EnergyWebX<TApi, TRes> {
-    constructor();
-}
-
-declare class Heima<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
-
-declare class HeimaPaseo<TApi, TRes> extends Heima<TApi, TRes> {
-    constructor();
-}
-
-declare class HydrationPaseo<TApi, TRes> extends Hydration<TApi, TRes> {
-    constructor();
-}
-
-declare class Interlay<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getBalanceNative(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
-
-declare class Jamton<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): {
-        Native: number;
-        ForeignAsset?: undefined;
-    } | {
-        ForeignAsset: number;
-        Native?: undefined;
-    };
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-}
+type TGetAssetBalanceOptionsBase = TGetBalanceCommonOptions & {
+    /**
+     * The resolved asset to query balance for.
+     */
+    asset: TAssetInfo;
+};
+/**
+ * Retrieves the currency balance for a given account on a specified chain.
+ */
+type TGetBalanceOptionsBase = TGetBalanceCommonOptions & {
+    /**
+     * The currency to query.
+     */
+    currency?: TCurrencyCore;
+};
+type TGetBalanceOptions<TApi, TRes, TSigner> = WithApi<TGetBalanceOptionsBase, TApi, TRes, TSigner>;
+type TGetAssetBalanceOptions<TApi, TRes, TSigner> = WithApi<TGetAssetBalanceOptionsBase, TApi, TRes, TSigner>;
+type TGetTransferableAmountOptionsBase<TRes> = {
+    /**
+     * The sender address of the account.
+     */
+    senderAddress: string;
+    /**
+     * The chain on which to query the balance.
+     */
+    origin: TSubstrateChain;
+    /**
+     * The destination chain.
+     */
+    destination: TChain;
+    /**
+     * The currency to query.
+     */
+    currency: WithAmount<TCurrencyCore>;
+    version: Version | undefined;
+    buildTx: TTxFactory<TRes>;
+    feeAsset?: TCurrencyInput;
+};
+type TGetTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes>, TApi, TRes, TSigner>;
+type TGetMinTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes> & {
+    address: string;
+    builder: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptionsWithSenderAddress<TRes>>;
+}, TApi, TRes, TSigner>;
+type TVerifyEdOnDestinationOptionsBase<TRes> = {
+    /**
+     * The origin chain.
+     */
+    origin: TSubstrateChain;
+    /**
+     * The destination chain.
+     */
+    destination: TChain;
+    /**
+     * The address of the account.
+     */
+    address: string;
+    /**
+     * The account of the sender.
+     */
+    senderAddress: string;
+    /**
+     * The currency to query.
+     */
+    currency: WithAmount<TCurrencyCore>;
+    version: Version | undefined;
+    buildTx: TTxFactory<TRes>;
+    feeAsset?: TCurrencyInput;
+};
+type TVerifyEdOnDestinationOptions<TApi, TRes, TSigner> = WithApi<TVerifyEdOnDestinationOptionsBase<TRes>, TApi, TRes, TSigner>;
 
-declare class Karura<TApi, TRes> extends Acala<TApi, TRes> {
-    constructor();
+type TEvmChainFrom = Extract<TChain, 'Ethereum' | 'Moonbeam' | 'Moonriver' | 'Darwinia'>;
+/**
+ * The options for the Ethereum to Polkadot transfer builder.
+ */
+type TEvmBuilderOptionsBase = {
+    /**
+     * The source chain. Can be either 'Ethereum', 'Moonbeam', 'Moonriver', or 'Darwinia'.
+     */
+    from: TEvmChainFrom;
+    /**
+     * The destination chain on Polkadot network.
+     */
+    to: TChain;
+    /**
+     * The currency to transfer. Symbol or ID.
+     */
+    currency: TCurrencyInputWithAmount;
+    /**
+     * The Polkadot destination address.
+     */
+    address: string;
+    /**
+     * The AssetHub address
+     */
+    ahAddress?: string;
+    /**
+     * The Ethereum signer.
+     */
+    signer: WalletClient;
+};
+type TEvmBuilderOptions<TApi, TRes, TSigner> = WithApi<TEvmBuilderOptionsBase, TApi, TRes, TSigner>;
+type TSerializeEthTransferOptions = Omit<TEvmBuilderOptionsBase, 'signer'> & {
+    destAddress: string;
+};
+type TSerializedEthTransfer = {
+    token: string;
+    destinationParaId: number;
+    destinationFee: bigint;
+    amount: bigint;
+    fee: bigint;
+};
+/**
+ * The options for the batch builder.
+ */
+declare enum BatchMode {
+    /**
+     * Does not commit if one of the calls in the batch fails.
+     */
+    BATCH_ALL = "BATCH_ALL",
+    /**
+     * Commits each successful call regardless if a call fails.
+     */
+    BATCH = "BATCH"
 }
+/**
+ * The options for the batch builder.
+ */
+type TBatchOptions = {
+    /**
+     * The batch mode. Can be either:
+     * `BATCH_ALL` - does not commit if one of the calls in the batch fails.
+     * `BATCH` - commits each successful call regardless if a call fails.
+     */
+    mode: BatchMode;
+};
+type TDryRunPreviewOptions = {
+    mintFeeAssets?: boolean;
+};
+type TBuilderOptions<TApi> = TApi | TBuilderConfig<TApi>;
+type TBuilderConfig<TApi> = Partial<{
+    apiOverrides: Partial<Record<TChain, TApi>>;
+    development: boolean;
+    abstractDecimals: boolean;
+    xcmFormatCheck: boolean;
+}>;
+type TCreateTxsOptions<TApi, TRes, TSigner> = Pick<TSendOptions<TApi, TRes, TSigner>, 'api' | 'from' | 'to' | 'currency'>;
+type TBatchedSendOptions<TApi, TRes, TSigner> = Omit<TSendOptions<TApi, TRes, TSigner>, 'isAmountAll'> & {
+    builder: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptions<TRes>>;
+};
+type TBuildInternalRes<TApi, TRes, TSigner, TOptions extends TSendBaseOptions<TRes> = TSendBaseOptions<TRes>> = {
+    tx: TRes;
+    options: TSendOptions<TApi, TRes, TSigner> & TOptions;
+};
+type TSender<TSigner> = string | TSigner;
+type TBuilderInternalOptions<TSigner> = {
+    sender?: TSender<TSigner>;
+};
 
-declare class KiltSpiritnet<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
-}
+type TProviderEntry = {
+    name: string;
+    endpoint: string;
+};
+type TChainConfig = {
+    name: string;
+    info: string;
+    paraId: number;
+    providers: TProviderEntry[];
+};
+type TChainConfigMap = Record<TSubstrateChain, TChainConfig>;
 
-declare class KiltPaseo<TApi, TRes> extends KiltSpiritnet<TApi, TRes> {
-    constructor();
-    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes>): boolean;
-    isReceivingTempDisabled(_scenario: TScenario): boolean;
-}
+type OneKey<K extends string, V = unknown> = {
+    [P in K]: Record<P, V> & Partial<Record<Exclude<K, P>, never>> extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+type TXcmVersioned<T> = OneKey<Version, T>;
+type TXcmForeignAsset = {
+    ForeignAsset: string | number | bigint | undefined;
+};
+type TForeignAssetId = {
+    ForeignAssetId: bigint | undefined;
+};
+type TForeignOrTokenAsset = TXcmForeignAsset | {
+    Token: string | undefined;
+};
+type TForeignOrNativeAsset = TXcmForeignAsset | 'Native';
+type TXcmAsset = {
+    XCM: number | undefined;
+} | {
+    Native: null;
+};
+type TMantaAsset = {
+    MantaCurrency: bigint | undefined;
+};
+type TNativeTokenAsset = 'NativeToken';
+type TNodleAsset = 'NodleNative';
+type TZeitgeistAsset = 'Ztg';
+type TOtherReserveAsset = {
+    OtherReserve: string | bigint | undefined;
+};
+type TSelfReserveAsset = 'SelfReserve';
+type TReserveAsset = TOtherReserveAsset | TSelfReserveAsset;
+type TBifrostToken = {
+    Native: string | number;
+} | {
+    VToken: string;
+} | {
+    Token: string;
+} | {
+    VSToken2: number;
+} | {
+    VToken2: number;
+} | {
+    Token2: number;
+};
+type TXTokensCurrencySelection = TXcmVersioned<TLocation | TAsset | TAsset[]> | TXcmForeignAsset | TForeignAssetId | TForeignOrTokenAsset | TXcmAsset | TMantaAsset | TOtherReserveAsset | TBifrostToken | string | bigint | number | undefined;
 
-declare class Kintsugi<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): TForeignOrTokenAsset;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getBalanceNative(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
+declare class AmountTooLowError extends Error {
+    constructor(message?: string);
 }
 
-declare class Polkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TSubstrateChain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
+/**
+ * Error thrown when a batch operation is invalid or cannot be executed.
+ */
+declare class BatchValidationError extends Error {
+    constructor(message: string);
 }
 
-declare class Kusama<TApi, TRes> extends Polkadot<TApi, TRes> {
+/**
+ * Error thrown when the Ethereum bridge is halted.
+ */
+declare class BridgeHaltedError extends Error {
+    /**
+     * Constructs a new BridgeHaltedError.
+     *
+     * @param message - Optional custom error message.
+     */
     constructor();
 }
 
-declare class Laos<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
+/**
+ * Error thrown when the Dry Run fails.
+ */
+declare class DryRunFailedError extends Error {
+    readonly reason: string;
+    readonly dryRunType?: TChainEndpoint;
+    /**
+     * Constructs a new DryRunFailedError.
+     *
+     * @param reason - The reason why the dry run failed.
+     * @param dryRunType - Optional. Specifies if the error is related to the 'origin' or 'destination' dry run.
+     */
+    constructor(reason: string, dryRunType?: TChainEndpoint);
 }
 
-declare class LaosPaseo<TApi, TRes> extends Laos<TApi, TRes> {
-    constructor();
+/**
+ * Error thrown when a feature or route is temporarily disabled via configuration or governance.
+ */
+declare class FeatureTemporarilyDisabledError extends Error {
+    constructor(message: string);
 }
 
-declare class Manta<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    static readonly NATIVE_ASSET_ID = 1n;
-    constructor();
-    private getAssetId;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
+/**
+ * Error thrown when an invalid address is provided.
+ */
+declare class InvalidAddressError extends Error {
+    /**
+     * Constructs a new InvalidAddressError.
+     *
+     * @param message - The error message.
+     */
+    constructor(message: string);
 }
 
-declare class Moonbeam<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(options: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(_options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getBalanceForeign<TApi, TRes>(_api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
+/**
+ * Error development mode is on and no API override is provided for a specific chain.
+ */
+declare class MissingChainApiError extends Error {
+    /**
+     * Constructs a new MissingChainApiError.
+     *
+     * @param chain - The chain for which the API is missing.
+     */
+    constructor(chain: TChain);
 }
 
-declare class Moonriver<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(options: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
+/**
+ * Error thrown when a required parameter is missing.
+ */
+declare class MissingParameterError extends Error {
+    constructor(parameter: string | string[], message?: string);
 }
 
-declare class Mythos<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
+/**
+ * Used to inform user, that Parachain they wish to use has not yet implemented full XCM Support
+ */
+declare class NoXCMSupportImplementedError extends Error {
+    /**
+     * Constructs a new NoXCMSupportImplementedError.
+     *
+     * @param chain - The chain for which XCM support is not implemented.
+     */
+    constructor(chain: TChain);
 }
 
-declare class NeuroWeb<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
+/**
+ * Error thrown when numeric input is invalid or cannot be parsed.
+ */
+declare class NumberFormatError extends Error {
+    constructor(message?: string);
 }
 
-declare class NeuroWebPaseo<TApi, TRes> extends NeuroWeb<TApi, TRes> {
-    constructor();
+/**
+ * Error thrown when asset or currency overrides are invalid or conflicting.
+ */
+declare class OverrideConflictError extends Error {
+    constructor(message: string);
 }
 
-declare class Nodle<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isRelayToParaEnabled(): boolean;
+/**
+ * Error thrown when no provider or RPC endpoint is available for the requested chain.
+ */
+declare class ProviderUnavailableError extends Error {
+    constructor(message: string);
 }
 
-declare class Paseo<TApi, TRes> extends Polkadot<TApi, TRes> {
-    constructor();
+/**
+ * Error thrown when routing or path resolution fails.
+ */
+declare class RoutingResolutionError extends Error {
+    constructor(message: string);
 }
 
-declare class PeoplePolkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
+/**
+ * Error thrown when a required runtime API is not available on the target chain.
+ */
+declare class RuntimeApiUnavailableError extends Error {
+    constructor(chain: string, apiName: string);
 }
 
-declare class PAssetHub<TApi, TRes> extends PeoplePolkadot<TApi, TRes> {
-    constructor();
-    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes>): boolean;
-    isReceivingTempDisabled(_scenario: TScenario): boolean;
+type TScenarioNotSupportedContext = {
+    chain: TChain;
+    scenario: TScenario;
+};
+/**
+ * Error thrown when a scenario, route, or chain capability is not supported.
+ */
+declare class ScenarioNotSupportedError extends Error {
+    constructor(message: string);
+    constructor({ chain, scenario }: TScenarioNotSupportedContext);
 }
 
-declare class Peaq<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
-    isRelayToParaEnabled(): boolean;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
+declare class TransferToAhNotSupported extends Error {
+    constructor(message?: string);
 }
 
-declare class Pendulum<TApi, TRes> extends Chain<TApi, TRes> implements IXTokensTransfer {
-    constructor();
-    getCustomCurrencyId(asset: TAssetInfo): TXcmAsset;
-    transferXTokens<TApi, TRes>(input: TXTokensTransferOptions<TApi, TRes>): TRes;
+declare class TypeAndThenUnavailableError extends Error {
+    constructor(message: string);
 }
 
-declare class Penpal<TApi, TRes> extends Moonbeam<TApi, TRes> {
-    constructor();
-    getBalanceForeign<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
+/**
+ * UnableToComputeError is thrown when a computation cannot be performed.
+ */
+declare class UnableToComputeError extends Error {
+    /**
+     * Constructs a new UnableToComputeError.
+     *
+     * @param message - Required error message.
+     */
+    constructor(message: string);
 }
 
-declare class PeopleKusama<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
+/**
+ * Error thrown when an operation or parameter combination is not supported.
+ */
+declare class UnsupportedOperationError extends Error {
+    constructor(message: string);
 }
 
-declare class PeoplePaseo<TApi, TRes> extends PeoplePolkadot<TApi, TRes> {
-    constructor();
+/**
+ * Thrown when a validation check fails.
+ */
+declare class ValidationError extends Error {
+    constructor(message: string);
 }
 
-declare class PeopleWestend<TApi, TRes> extends PeoplePolkadot<TApi, TRes> {
-    constructor();
-}
+type THopTransferInfo = {
+    chain: TChain;
+    result: {
+        xcmFee: TXcmFeeBase;
+        asset: TAssetInfo;
+    };
+};
+type TXcmFeeBase = {
+    fee: bigint;
+    asset: TAssetInfo;
+};
+type TTransferInfo = {
+    chain: {
+        origin: TChain;
+        destination: TChain;
+        ecosystem: string;
+    };
+    origin: {
+        selectedCurrency: {
+            sufficient: boolean;
+            balance: bigint;
+            balanceAfter: bigint;
+            asset: TAssetInfo;
+        };
+        xcmFee: TXcmFeeBase & {
+            sufficient: boolean;
+            balance: bigint;
+            balanceAfter: bigint;
+        };
+    };
+    hops: THopTransferInfo[];
+    destination: {
+        receivedCurrency: {
+            sufficient: boolean | UnableToComputeError;
+            receivedAmount: bigint | UnableToComputeError;
+            balance: bigint;
+            balanceAfter: bigint | UnableToComputeError;
+            asset: TAssetInfo;
+        };
+        xcmFee: TXcmFeeBase & {
+            balanceAfter: bigint | UnableToComputeError;
+        };
+    };
+};
+type BuildHopInfoOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    chain: TSubstrateChain;
+    fee: bigint;
+    originChain: TSubstrateChain;
+    currency: TCurrencyCore;
+    asset: TAssetInfo;
+    senderAddress: string;
+    ahAddress?: string;
+};
+type TBuildDestInfoOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    address: string;
+    currency: WithAmount<TCurrencyCore>;
+    originFee: bigint;
+    isFeeAssetAh: boolean;
+    destFeeDetail: TXcmFeeDetail;
+    totalHopFee: bigint;
+    bridgeFee?: bigint;
+};
+type TOriginFeeDetails = {
+    sufficientForXCM: boolean;
+    xcmFee: bigint;
+};
+type TGetTransferInfoOptionsBase<TRes> = {
+    buildTx: TTxFactory<TRes>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    senderAddress: string;
+    ahAddress?: string;
+    address: string;
+    currency: WithAmount<TCurrencyCore>;
+    version: Version | undefined;
+    feeAsset?: TCurrencyCore;
+};
+type TGetTransferInfoOptions<TApi, TRes, TSigner> = WithApi<TGetTransferInfoOptionsBase<TRes>, TApi, TRes, TSigner>;
 
-declare class Phala<TApi, TRes> extends Chain<TApi, TRes> implements IXTransferTransfer {
-    constructor();
-    transferXTransfer<TApi, TRes>(input: TXTransferTransferOptions<TApi, TRes>): TRes;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
+type TChainWithApi<TApi, TRes, TSigner, T = TSubstrateChain> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    chain: T;
+};
+type TTypeAndThenCallContext<TApi, TRes, TSigner> = {
+    origin: TChainWithApi<TApi, TRes, TSigner>;
+    dest: TChainWithApi<TApi, TRes, TSigner>;
+    reserve: TChainWithApi<TApi, TRes, TSigner, TChain>;
+    isSubBridge: boolean;
+    isSnowbridge: boolean;
+    isRelayAsset: boolean;
+    assetInfo: WithAmount<TAssetWithLocation>;
+    systemAsset: TAssetInfo;
+    options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>;
+};
+type TTypeAndThenFees = {
+    hopFees: bigint;
+    destFee: bigint;
+};
+type TTypeAndThenOverrides = {
+    reserveChain?: TSubstrateChain;
+    noFeeAsset?: boolean;
+};
 
-declare class Quartz<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isSendingTempDisabled(_options: TSendInternalOptions<TApi, TRes>): boolean;
-}
+declare const keyFromWs: (ws: TUrl) => TClientKey;
+declare const createClientPoolHelpers: <TClient>(clientPool: ClientCache<TClient>, createClient: (ws: TUrl, useLegacy: boolean) => TClient | Promise<TClient>) => {
+    leaseClient: (ws: TUrl, ttlMs: number, useLegacy: boolean) => Promise<TClient>;
+    releaseClient: (ws: TUrl) => void;
+};
 
-declare class RobonomicsPolkadot<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    isReceivingTempDisabled(scenario: TScenario): boolean;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
+declare const createClientCache: <T>(maxSize: number, pingClient: (client: T) => Promise<void>, onEviction?: (key: TClientKey, value: TClientEntry<T>) => void, extensionMs?: number) => ClientCache<T>;
 
-declare class Shiden<TApi, TRes> extends Astar<TApi, TRes> {
-    constructor();
-}
+declare const blake2b256: (msg: Uint8Array) => Uint8Array<ArrayBufferLike>;
+declare const blake2b512: (msg: Uint8Array) => Uint8Array<ArrayBufferLike>;
+declare const deriveAccountId: (raw: Uint8Array) => Uint8Array;
+declare const encodeSs58: (payload: Uint8Array, network: number) => string;
+declare const convertSs58: <TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: string, chain: TSubstrateChain) => string;
 
-declare class Unique<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    transferLocalNonNativeAsset(_options: TTransferLocalOptions<TApi, TRes>): TRes;
-    getBalanceForeign<TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: string, asset: TAssetInfo): Promise<bigint>;
-}
+declare const getAssetBalanceInternal: <TApi, TRes, TSigner>({ api, address, chain, asset }: TGetAssetBalanceOptions<TApi, TRes, TSigner>) => Promise<bigint>;
+declare const getBalanceInternal: <TApi, TRes, TSigner>(options: TGetBalanceOptions<TApi, TRes, TSigner>) => Promise<bigint>;
+declare const getBalance: <TApi, TRes, TSigner>(options: TGetBalanceOptions<TApi, TRes, TSigner>) => Promise<bigint>;
 
-declare class Westend<TApi, TRes> extends Polkadot<TApi, TRes> {
-    constructor();
-}
+declare const getEthErc20Balance: (chain: TExternalChain, asset: TAssetInfo, address: string) => Promise<bigint>;
 
-declare class Xode<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor();
-    transferPolkadotXCM<TApi, TRes>(options: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    canReceiveFrom(origin: TChain): boolean;
-}
+declare const getMoonbeamErc20Balance: (chain: TSubstrateChain, assetId: string, address: string) => Promise<bigint>;
 
-declare class Zeitgeist<TApi, TRes> extends Chain<TApi, TRes> implements IPolkadotXCMTransfer {
-    constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    getCustomCurrencyId(asset: TAssetInfo): TZeitgeistAsset | TXcmForeignAsset;
-    transferPolkadotXCM<TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>): Promise<TRes>;
-    canReceiveFrom(origin: TChain): boolean;
-    transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes>): TRes;
-}
+declare const getChainConfig: (chain: TSubstrateChain) => TChainConfig;
 
-declare class ZeitgeistPaseo<TApi, TRes> extends Zeitgeist<TApi, TRes> {
-    constructor();
-}
+declare const getChainProviders: (chain: TSubstrateChain) => string[];
 
-declare const chains: <TApi, TRes>() => {
-    Polkadot: Polkadot<TApi, TRes>;
-    AssetHubPolkadot: AssetHubPolkadot<TApi, TRes>;
-    Acala: Acala<TApi, TRes>;
-    Ajuna: Ajuna<TApi, TRes>;
-    Astar: Astar<TApi, TRes>;
-    Unique: Unique<TApi, TRes>;
-    Crust: Crust<TApi, TRes>;
-    BifrostPolkadot: BifrostPolkadot<TApi, TRes>;
-    BridgeHubPolkadot: BridgeHubPolkadot<TApi, TRes>;
-    Centrifuge: Centrifuge<TApi, TRes>;
-    Darwinia: Darwinia<TApi, TRes>;
-    EnergyWebX: EnergyWebX<TApi, TRes>;
-    Hydration: Hydration<TApi, TRes>;
-    Interlay: Interlay<TApi, TRes>;
-    Heima: Heima<TApi, TRes>;
-    Jamton: Jamton<TApi, TRes>;
-    Moonbeam: Moonbeam<TApi, TRes>;
-    CoretimePolkadot: CoretimePolkadot<TApi, TRes>;
-    RobonomicsPolkadot: RobonomicsPolkadot<TApi, TRes>;
-    PeoplePolkadot: PeoplePolkadot<TApi, TRes>;
-    Manta: Manta<TApi, TRes>;
-    Nodle: Nodle<TApi, TRes>;
-    NeuroWeb: NeuroWeb<TApi, TRes>;
-    Pendulum: Pendulum<TApi, TRes>;
-    Collectives: Collectives<TApi, TRes>;
-    Phala: Phala<TApi, TRes>;
-    KiltSpiritnet: KiltSpiritnet<TApi, TRes>;
-    Curio: Curio<TApi, TRes>;
-    Mythos: Mythos<TApi, TRes>;
-    Peaq: Peaq<TApi, TRes>;
-    Xode: Xode<TApi, TRes>;
-    Kusama: Kusama<TApi, TRes>;
-    AssetHubKusama: AssetHubKusama<TApi, TRes>;
-    BridgeHubKusama: BridgeHubKusama<TApi, TRes>;
-    CoretimeKusama: CoretimeKusama<TApi, TRes>;
-    Encointer: Encointer<TApi, TRes>;
-    Altair: Altair<TApi, TRes>;
-    Amplitude: Amplitude<TApi, TRes>;
-    Basilisk: Basilisk<TApi, TRes>;
-    BifrostKusama: BifrostKusama<TApi, TRes>;
-    CrustShadow: CrustShadow<TApi, TRes>;
-    Crab: Crab<TApi, TRes>;
-    Karura: Karura<TApi, TRes>;
-    Kintsugi: Kintsugi<TApi, TRes>;
-    Moonriver: Moonriver<TApi, TRes>;
-    Laos: Laos<TApi, TRes>;
-    Quartz: Quartz<TApi, TRes>;
-    PeopleKusama: PeopleKusama<TApi, TRes>;
-    Shiden: Shiden<TApi, TRes>;
-    Zeitgeist: Zeitgeist<TApi, TRes>;
-    Westend: Westend<TApi, TRes>;
-    AssetHubWestend: AssetHubWestend<TApi, TRes>;
-    BridgeHubWestend: BridgeHubWestend<TApi, TRes>;
-    CollectivesWestend: CollectivesWestend<TApi, TRes>;
-    CoretimeWestend: CoretimeWestend<TApi, TRes>;
-    PeopleWestend: PeopleWestend<TApi, TRes>;
-    Penpal: Penpal<TApi, TRes>;
-    Paseo: Paseo<TApi, TRes>;
-    AssetHubPaseo: AssetHubPaseo<TApi, TRes>;
-    BridgeHubPaseo: BridgeHubPaseo<TApi, TRes>;
-    CoretimePaseo: CoretimePaseo<TApi, TRes>;
-    EnergyWebXPaseo: EnergyWebXPaseo<TApi, TRes>;
-    KiltPaseo: KiltPaseo<TApi, TRes>;
-    PAssetHub: PAssetHub<TApi, TRes>;
-    PeoplePaseo: PeoplePaseo<TApi, TRes>;
-    AjunaPaseo: AjunaPaseo<TApi, TRes>;
-    BifrostPaseo: BifrostPaseo<TApi, TRes>;
-    HeimaPaseo: HeimaPaseo<TApi, TRes>;
-    HydrationPaseo: HydrationPaseo<TApi, TRes>;
-    LaosPaseo: LaosPaseo<TApi, TRes>;
-    NeuroWebPaseo: NeuroWebPaseo<TApi, TRes>;
-    ZeitgeistPaseo: ZeitgeistPaseo<TApi, TRes>;
-};
+/**
+ * Retrieves the parachain ID for a specified chain.
+ *
+ * @param chain - The chain for which to get the paraId.
+ * @returns The parachain ID of the chain.
+ */
+declare const getParaId: (chain: TChain) => number;
 
-declare const ETH_MAINNET_CHAIN_ID: bigint;
-declare const ETH_TESTNET_CHAIN_ID: bigint;
-declare const RELAY_LOCATION: TLocation;
-declare const TX_CLIENT_TIMEOUT_MS: number;
-declare const DRY_RUN_CLIENT_TIMEOUT_MS: number;
+/**
+ * Retrieves the chain name corresponding to a specified parachain ID.
+ *
+ * @param paraId - The parachain ID.
+ * @returns The chain name if found; otherwise, null.
+ */
+declare const getTChain: (paraId: number, ecosystem: TRelaychain | TExternalChain) => TChain | null;
 
-declare const claimAssets: <TApi, TRes>(options: TAssetClaimOptions<TApi, TRes>) => Promise<TRes>;
+declare const claimAssets: <TApi, TRes, TSigner>(options: TAssetClaimOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 
-declare const dryRun: <TApi, TRes>(options: TDryRunOptions<TApi, TRes>) => Promise<TDryRunResult>;
+declare const dryRun: <TApi, TRes, TSigner>(options: TDryRunOptions<TApi, TRes, TSigner>) => Promise<TDryRunResult>;
 
-declare const dryRunInternal: <TApi, TRes>(options: TDryRunOptions<TApi, TRes>) => Promise<TDryRunResult>;
+declare const dryRunInternal: <TApi, TRes, TSigner>(options: TDryRunOptions<TApi, TRes, TSigner>) => Promise<TDryRunResult>;
 
-declare const dryRunOrigin: <TApi, TRes>(options: TDryRunCallOptions<TApi, TRes>) => Promise<TDryRunChainResult>;
+declare const dryRunOrigin: <TApi, TRes, TSigner>(options: TDryRunCallOptions<TApi, TRes, TSigner>) => Promise<TDryRunChainResult>;
 
 declare const getFailureInfo: (result: TDryRunResult) => Pick<TDryRunResult, "failureReason" | "failureSubReason" | "failureChain">;
 
-declare const traverseXcmHops: <TApi, TRes, THopResult>(config: HopTraversalConfig<TApi, TRes, THopResult>) => Promise<HopTraversalResult<THopResult>>;
-declare const addEthereumBridgeFees: <TApi, TRes, TResult extends {
+declare const traverseXcmHops: <TApi, TRes, TSigner, THopResult>(config: HopTraversalConfig<TApi, TRes, TSigner, THopResult>) => Promise<HopTraversalResult<THopResult>>;
+declare const addEthereumBridgeFees: <TApi, TRes, TSigner, TResult extends {
     fee?: bigint;
-}>(api: IPolkadotApi<TApi, TRes>, bridgeHubResult: TResult | undefined, destination: TChain, assetHubChain: TSubstrateChain) => Promise<TResult | undefined>;
+}>(api: IPolkadotApi<TApi, TRes, TSigner>, bridgeHubResult: TResult | undefined, destination: TChain, assetHubChain: TSubstrateChain) => Promise<TResult | undefined>;
 
 declare const calcPreviewMintAmount: (balance: bigint, desired: bigint) => bigint | null;
-declare const wrapTxBypass: <TApi, TRes>(dryRunOptions: TDryRunBypassOptions<TApi, TRes>, options?: TBypassOptions) => Promise<TRes>;
+declare const wrapTxBypass: <TApi, TRes, TSigner>(dryRunOptions: TDryRunBypassOptions<TApi, TRes, TSigner>, options?: TBypassOptions) => Promise<TRes>;
 
-declare const getParaEthTransferFees: <TApi, TRes>(ahApi: IPolkadotApi<TApi, TRes>, shouldDisconnect?: boolean) => Promise<[bigint, bigint]>;
+declare const getParaEthTransferFees: <TApi, TRes, TSigner>(ahApi: IPolkadotApi<TApi, TRes, TSigner>, shouldDisconnect?: boolean) => Promise<[bigint, bigint]>;
 
-declare const transferMoonbeamEvm: <TApi, TRes>({ api, from, to, signer, address, currency }: TEvmBuilderOptions<TApi, TRes>) => Promise<string>;
+declare const transferMoonbeamEvm: <TApi, TRes, TSigner>({ api, from, to, signer, address, currency }: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<string>;
 
-declare const transferMoonbeamToEth: <TApi, TRes>(from: TSubstrateChain, { api, to, signer, address, ahAddress, currency }: TEvmBuilderOptions<TApi, TRes>) => Promise<`0x${string}`>;
+declare const transferMoonbeamToEth: <TApi, TRes, TSigner>(from: TSubstrateChain, { api, to, signer, address, ahAddress, currency }: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<`0x${string}`>;
 
-declare const getOriginXcmFee: <TApi, TRes>(options: TGetOriginXcmFeeOptions<TApi, TRes>) => Promise<TXcmFeeDetail & {
+declare const getOriginXcmFee: <TApi, TRes, TSigner>(options: TGetOriginXcmFeeOptions<TApi, TRes, TSigner>) => Promise<TXcmFeeDetail & {
     forwardedXcms?: unknown;
     destParaId?: number;
 }>;
@@ -2130,15 +2186,15 @@ declare const getOriginXcmFee: <TApi, TRes>(options: TGetOriginXcmFeeOptions<TAp
  * For more details, see the documentation:
  * {@link https://paraspell.github.io/docs/sdk/xcmPallet.html#xcm-fee-origin-and-dest}
  */
-declare const getOriginXcmFeeEstimate: <TApi, TRes>({ api, tx, origin, destination, currency, senderAddress, feeAsset }: TGetOriginXcmFeeEstimateOptions<TApi, TRes>) => Promise<TGetXcmFeeEstimateDetail>;
+declare const getOriginXcmFeeEstimate: <TApi, TRes, TSigner>({ api, tx, origin, destination, currency, senderAddress, feeAsset }: TGetOriginXcmFeeEstimateOptions<TApi, TRes, TSigner>) => Promise<TGetXcmFeeEstimateDetail>;
 
-declare const getOriginXcmFeeInternal: <TApi, TRes>({ api, tx, origin, destination, senderAddress, disableFallback, feeAsset, currency, useRootOrigin }: TGetOriginXcmFeeInternalOptions<TApi, TRes>) => Promise<TXcmFeeDetail & {
+declare const getOriginXcmFeeInternal: <TApi, TRes, TSigner>({ api, tx, origin, destination, senderAddress, disableFallback, feeAsset, currency, version, useRootOrigin }: TGetOriginXcmFeeInternalOptions<TApi, TRes, TSigner>) => Promise<TXcmFeeDetail & {
     forwardedXcms?: any;
     destParaId?: number;
 }>;
 
-declare const getXcmFeeInternal: <TApi, TRes, TDisableFallback extends boolean>(options: TGetXcmFeeOptions<TApi, TRes, TDisableFallback>) => Promise<TGetXcmFeeResult<TDisableFallback>>;
-declare const getXcmFee: <TApi, TRes, TDisableFallback extends boolean>(options: TGetXcmFeeOptions<TApi, TRes, TDisableFallback>) => Promise<TGetXcmFeeResult<TDisableFallback>>;
+declare const getXcmFeeInternal: <TApi, TRes, TSigner, TDisableFallback extends boolean>(options: TGetXcmFeeOptions<TApi, TRes, TSigner, TDisableFallback>) => Promise<TGetXcmFeeResult<TDisableFallback>>;
+declare const getXcmFee: <TApi, TRes, TSigner, TDisableFallback extends boolean>(options: TGetXcmFeeOptions<TApi, TRes, TSigner, TDisableFallback>) => Promise<TGetXcmFeeResult<TDisableFallback>>;
 
 /**
  * @deprecated This function is deprecated and will be removed in a future version.
@@ -2147,49 +2203,71 @@ declare const getXcmFee: <TApi, TRes, TDisableFallback extends boolean>(options:
  * For more details, see the documentation:
  * {@link https://paraspell.github.io/docs/sdk/xcmPallet.html#xcm-fee-origin-and-dest}
  */
-declare const getXcmFeeEstimate: <TApi, TRes>(options: TGetXcmFeeEstimateOptions<TApi, TRes>) => Promise<TGetXcmFeeEstimateResult>;
-
-declare const getXcmFeeOnce: <TApi, TRes, TDisableFallback extends boolean>({ api, tx, origin, destination, senderAddress, address, currency, feeAsset, disableFallback, swapConfig, useRootOrigin, skipReverseFeeCalculation }: TGetXcmFeeInternalOptions<TApi, TRes, TDisableFallback>) => Promise<TGetXcmFeeResult<TDisableFallback>>;
-
-declare const getBridgeStatus: <TApi, TRes>(api: IPolkadotApi<TApi, TRes>) => Promise<TBridgeStatus>;
-
-declare const send: <TApi, TRes>(options: TSendOptions<TApi, TRes>) => Promise<TRes>;
+declare const getXcmFeeEstimate: <TApi, TRes, TSigner>(options: TGetXcmFeeEstimateOptions<TApi, TRes, TSigner>) => Promise<TGetXcmFeeEstimateResult>;
+
+declare const getXcmFeeOnce: <TApi, TRes, TSigner, TDisableFallback extends boolean>({ api, tx, origin, destination, senderAddress, address, currency, feeAsset, version, disableFallback, swapConfig, useRootOrigin, skipReverseFeeCalculation }: TGetXcmFeeInternalOptions<TApi, TRes, TSigner, TDisableFallback>) => Promise<TGetXcmFeeResult<TDisableFallback>>;
+
+declare const getBridgeStatus: <TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>) => Promise<TBridgeStatus>;
+
+declare const resolveSendParams: <TApi, TRes, TSigner>(options: TSendOptions<TApi, TRes, TSigner>) => {
+    resolvedFeeAsset: TAssetInfo | undefined;
+    resolvedVersion: _paraspell_sdk_common.Version;
+    overriddenAsset: _paraspell_sdk_common.TLocation | _paraspell_assets.TAssetWithFee[] | undefined;
+    normalizedAsset: {
+        amount: bigint;
+        decimals: number;
+        symbol: string;
+        isNative?: boolean;
+        assetId?: string;
+        location?: _paraspell_sdk_common.TLocation;
+        existentialDeposit?: string;
+        isFeeAsset?: boolean;
+        alias?: string;
+    };
+};
+declare const send: <TApi, TRes, TSigner>(options: TSendOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 
-declare const getTransferInfo: <TApi, TRes>({ api, buildTx, origin, destination, senderAddress, ahAddress, address, currency, feeAsset }: TGetTransferInfoOptions<TApi, TRes>) => Promise<TTransferInfo>;
+declare const getTransferInfo: <TApi, TRes, TSigner>({ api, buildTx, origin, destination, senderAddress, ahAddress, address, currency, feeAsset, version }: TGetTransferInfoOptions<TApi, TRes, TSigner>) => Promise<TTransferInfo>;
 
-declare const getMinTransferableAmountInternal: <TApi, TRes>({ api, origin, senderAddress, address, origin: chain, destination, currency, feeAsset, buildTx, builder }: TGetMinTransferableAmountOptions<TApi, TRes>) => Promise<bigint>;
-declare const getMinTransferableAmount: <TApi, TRes>(options: TGetMinTransferableAmountOptions<TApi, TRes>) => Promise<bigint>;
+declare const getMinTransferableAmountInternal: <TApi, TRes, TSigner>({ api, origin, senderAddress, address, origin: chain, destination, currency, feeAsset, buildTx, builder, version }: TGetMinTransferableAmountOptions<TApi, TRes, TSigner>) => Promise<bigint>;
+declare const getMinTransferableAmount: <TApi, TRes, TSigner>(options: TGetMinTransferableAmountOptions<TApi, TRes, TSigner>) => Promise<bigint>;
 
-declare const getTransferableAmountInternal: <TApi, TRes>({ api, senderAddress, origin: chain, destination, currency, buildTx, feeAsset }: TGetTransferableAmountOptions<TApi, TRes>) => Promise<bigint>;
-declare const getTransferableAmount: <TApi, TRes>(options: TGetTransferableAmountOptions<TApi, TRes>) => Promise<bigint>;
+declare const getTransferableAmountInternal: <TApi, TRes, TSigner>({ api, senderAddress, origin: chain, destination, currency, buildTx, feeAsset, version }: TGetTransferableAmountOptions<TApi, TRes, TSigner>) => Promise<bigint>;
+declare const getTransferableAmount: <TApi, TRes, TSigner>(options: TGetTransferableAmountOptions<TApi, TRes, TSigner>) => Promise<bigint>;
 
-declare const constructTypeAndThenCall: <TApi, TRes>(context: TTypeAndThenCallContext<TApi, TRes>, fees?: TTypeAndThenFees | null) => Promise<TSerializedExtrinsics>;
+declare const constructTypeAndThenCall: <TApi, TRes, TSigner>(context: TTypeAndThenCallContext<TApi, TRes, TSigner>, fees?: TTypeAndThenFees | null) => Promise<TSerializedExtrinsics>;
 /**
  * Creates a type and then call for transferring assets using XCM. Works only for DOT and snowbridge assets so far.
  */
-declare const createTypeAndThenCall: <TApi, TRes>(options: TPolkadotXCMTransferOptions<TApi, TRes>, overrides?: TTypeAndThenOverrides) => Promise<TSerializedExtrinsics>;
+declare const createTypeAndThenCall: <TApi, TRes, TSigner>(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, overrides?: TTypeAndThenOverrides) => Promise<TSerializedExtrinsics>;
 
 /**
  * Creates a type-and-then call but auto-selects the asset reserve between AssetHub and the Relay chain
  * by dry-running both variants and preferring the one that succeeds. If both fail, returns the
  * AssetHub variant. Supports only relaychain assets.
  */
-declare const createTypeThenAutoReserve: <TApi, TRes>(chain: TSubstrateChain, options: TPolkadotXCMTransferOptions<TApi, TRes>) => Promise<TSerializedExtrinsics>;
+declare const createTypeThenAutoReserve: <TApi, TRes, TSigner>(chain: TSubstrateChain, options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TSerializedExtrinsics>;
 
 declare const validateCurrency: (currency: TCurrencyInput, feeAsset?: TCurrencyInput) => void;
 declare const validateDestination: (origin: TSubstrateChain, destination: TDestination) => void;
 declare const validateAssetSpecifiers: (assetCheckEnabled: boolean, currency: TCurrencyInput) => void;
+declare const validateTransact: <TApi, TRes, TSigner>({ api, from, to, senderAddress, address, transactOptions }: TSendOptions<TApi, TRes, TSigner>) => ValidationError | undefined;
 
-declare const verifyEdOnDestination: <TApi, TRes>(options: TVerifyEdOnDestinationOptions<TApi, TRes>) => Promise<boolean>;
+declare const verifyEdOnDestination: <TApi, TRes, TSigner>(options: TVerifyEdOnDestinationOptions<TApi, TRes, TSigner>) => Promise<boolean>;
 
-declare const addXcmVersionHeader: <T, V extends Version>(obj: T, version: V) => OneKey<V, T>;
+declare const compareAddresses: <TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, addr1: string, addr2: string) => boolean;
+
+declare const validateAddress: <TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, address: TAddress, chain: TChain, isDestination?: boolean) => void;
+
+declare const validateDestinationAddress: <TApi, TRes, TSigner>(address: TAddress, destination: TDestination, api: IPolkadotApi<TApi, TRes, TSigner>) => void;
 
 declare const assertToIsString: (to: TDestination, overrideMsg?: string) => asserts to is Exclude<TDestination, TLocation>;
 declare const assertAddressIsString: (address: TAddress) => asserts address is Exclude<TAddress, TLocation>;
 declare const assertSenderAddress: (address: string | undefined) => asserts address is string;
 declare const assertHasLocation: (asset: TAssetInfo) => asserts asset is TAssetWithLocation;
 declare const assertHasId: (asset: TAssetInfo) => asserts asset is TAssetInfoWithId;
-declare const assertDerivationPath: (path: string | undefined) => asserts path is string;
+declare const assertSender: <TSigner>(sender?: TSender<TSigner>) => asserts sender is TSender<TSigner>;
+declare const isSenderSigner: <TSigner>(sender: TSender<TSigner>) => sender is TSigner;
 
 declare const createId: (version: Version, location: TLocation) => TLocation | {
     Concrete: TLocation;
@@ -2204,15 +2282,15 @@ declare const maybeOverrideAsset: (version: Version, amount: bigint, asset: TAss
 
 declare const sortAssets: (assets: TAsset[]) => TAsset[];
 
-declare const computeOverridenAmount: <TApi, TRes>(options: TCreateTxsOptions<TApi, TRes>, increaseAmount: string, relative?: boolean) => number | bigint;
-declare const overrideTxAmount: <TApi, TRes>(options: TCreateTxsOptions<TApi, TRes>, builder: GeneralBuilder<TApi, TRes, TSendBaseOptions>, amount: string, relative?: boolean) => Promise<TRes>;
-declare const createTx: <TApi, TRes>(options: TCreateTxsOptions<TApi, TRes>, builder: GeneralBuilder<TApi, TRes, TSendBaseOptions>, amount?: string, relative?: boolean) => Promise<TRes>;
+declare const computeOverridenAmount: <TApi, TRes, TSigner>(options: TCreateTxsOptions<TApi, TRes, TSigner>, increaseAmount: string, relative?: boolean) => number | bigint;
+declare const overrideTxAmount: <TApi, TRes, TSigner>(options: TCreateTxsOptions<TApi, TRes, TSigner>, builder: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptions<TRes>>, amount: string, relative?: boolean) => Promise<TRes>;
+declare const createTx: <TApi, TRes, TSigner>(options: TCreateTxsOptions<TApi, TRes, TSigner>, builder: GeneralBuilder<TApi, TRes, TSigner, TSendBaseOptions<TRes>>, amount?: string, relative?: boolean) => Promise<TRes>;
 
 declare const isConfig: <TApi>(value: any) => value is TBuilderConfig<TApi>;
 
 declare const getAssetReserveChain: (chain: TSubstrateChain, assetLocation: TLocation) => TSubstrateChain;
 
-declare const getChainVersion: <TApi, TRes>(chain: TChain) => Version;
+declare const getChainVersion: <TApi, TRes, TSigner>(chain: TChain) => Version;
 
 /**
  * Gets the relay chain (Polkadot, Kusama, Westend, or Paseo) of a given chain.
@@ -2222,7 +2300,7 @@ declare const getChainVersion: <TApi, TRes>(chain: TChain) => Version;
  */
 declare const getRelayChainOf: (chain: TSubstrateChain) => TRelaychain;
 
-declare const createChainClient: <TApi, TRes>(api: IPolkadotApi<TApi, TRes>, chain: TSubstrateChain) => Promise<TApi>;
+declare const createChainClient: <TApi, TRes, TSigner>(api: IPolkadotApi<TApi, TRes, TSigner>, chain: TSubstrateChain) => Promise<TApi>;
 
 declare const computeFeeFromDryRun: (dryRun: any, chain: TSubstrateChain, executionFee: bigint, isFeeAsset?: boolean) => bigint;
 
@@ -2239,12 +2317,12 @@ declare const padValueBy: (amount: bigint, percent: number) => bigint;
  * @param chain - The chain identifier.
  * @returns The chain instance
  */
-declare const getChain: <TApi, TRes, T extends keyof ReturnType<typeof chains>>(chain: T) => ReturnType<typeof chains<TApi, TRes>>[T];
+declare const getChain: <TApi, TRes, TSigner, T extends keyof ReturnType<typeof chains>>(chain: T) => ReturnType<typeof chains<TApi, TRes, TSigner>>[T];
 
 declare const getEvmPrivateKeyHex: (path: string) => "0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133" | "0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b" | "0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b" | "0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68" | "0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4" | "0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df" | undefined;
 
-declare const createBeneficiaryLocXTokens: <TApi, TRes>({ api, address: recipientAddress, origin, destination, version, paraId }: TCreateBeneficiaryXTokensOptions<TApi, TRes>) => TLocation;
-declare const createBeneficiaryLocation: <TApi, TRes>({ api, address, version }: TCreateBeneficiaryOptions<TApi, TRes>) => TLocation;
+declare const createBeneficiaryLocXTokens: <TApi, TRes, TSigner>({ api, address: recipientAddress, origin, destination, version, paraId }: TCreateBeneficiaryXTokensOptions<TApi, TRes, TSigner>) => TLocation;
+declare const createBeneficiaryLocation: <TApi, TRes, TSigner>({ api, address, version }: TCreateBeneficiaryOptions<TApi, TRes, TSigner>) => TLocation;
 
 declare const createDestination: (version: Version, origin: TSubstrateChain, destination: TDestination, chainId?: number, junction?: TJunction, parents?: Parents) => TLocation;
 declare const createVersionedDestination: (version: Version, origin: TSubstrateChain, destination: TDestination, chainId?: number, junction?: TJunction, parents?: Parents) => TXcmVersioned<TLocation>;
@@ -2268,11 +2346,11 @@ declare const reverseTransformLocation: (location: TLocation) => TLocation;
 
 declare const normalizeAmount: (amount: bigint) => bigint;
 
-declare const resolveDestChain: (originChain: TSubstrateChain, paraId: number | undefined) => "AssetHubPolkadot" | "Acala" | "Ajuna" | "Astar" | "BifrostPolkadot" | "BridgeHubPolkadot" | "Centrifuge" | "Darwinia" | "EnergyWebX" | "Hydration" | "Interlay" | "Heima" | "Jamton" | "Moonbeam" | "CoretimePolkadot" | "Collectives" | "Crust" | "Manta" | "Nodle" | "NeuroWeb" | "Pendulum" | "Phala" | "KiltSpiritnet" | "Curio" | "Mythos" | "Peaq" | "RobonomicsPolkadot" | "PeoplePolkadot" | "Unique" | "Xode" | "AssetHubKusama" | "BridgeHubKusama" | "Karura" | "Kintsugi" | "Moonriver" | "CoretimeKusama" | "Encointer" | "Altair" | "Amplitude" | "Basilisk" | "BifrostKusama" | "CrustShadow" | "Crab" | "Laos" | "Quartz" | "PeopleKusama" | "Shiden" | "Zeitgeist" | "AssetHubWestend" | "BridgeHubWestend" | "CollectivesWestend" | "CoretimeWestend" | "Penpal" | "PeopleWestend" | "AjunaPaseo" | "AssetHubPaseo" | "BifrostPaseo" | "BridgeHubPaseo" | "CoretimePaseo" | "EnergyWebXPaseo" | "HeimaPaseo" | "HydrationPaseo" | "KiltPaseo" | "LaosPaseo" | "NeuroWebPaseo" | "PAssetHub" | "PeoplePaseo" | "ZeitgeistPaseo" | undefined;
+declare const resolveDestChain: (originChain: TSubstrateChain, paraId: number | undefined) => "AssetHubPolkadot" | "Acala" | "Ajuna" | "Astar" | "BifrostPolkadot" | "BridgeHubPolkadot" | "Centrifuge" | "Darwinia" | "EnergyWebX" | "Hydration" | "Interlay" | "Heima" | "Jamton" | "Moonbeam" | "CoretimePolkadot" | "Collectives" | "Crust" | "Manta" | "Nodle" | "NeuroWeb" | "Pendulum" | "Phala" | "KiltSpiritnet" | "Curio" | "Mythos" | "Peaq" | "RobonomicsPolkadot" | "PeoplePolkadot" | "Unique" | "Xode" | "AssetHubKusama" | "BridgeHubKusama" | "Karura" | "Kintsugi" | "Moonriver" | "CoretimeKusama" | "Encointer" | "Altair" | "Basilisk" | "BifrostKusama" | "CrustShadow" | "Crab" | "Laos" | "Quartz" | "PeopleKusama" | "Shiden" | "Zeitgeist" | "AssetHubWestend" | "BridgeHubWestend" | "CollectivesWestend" | "CoretimeWestend" | "Penpal" | "PeopleWestend" | "AjunaPaseo" | "AssetHubPaseo" | "BifrostPaseo" | "BridgeHubPaseo" | "CoretimePaseo" | "EnergyWebXPaseo" | "HeimaPaseo" | "HydrationPaseo" | "KiltPaseo" | "LaosPaseo" | "NeuroWebPaseo" | "PAssetHub" | "PeoplePaseo" | "ZeitgeistPaseo" | undefined;
 
 declare const resolveParaId: (paraId: number | undefined, destination: TDestination) => number | undefined;
 
-declare const abstractDecimals: <TApi, TRes>(amount: TAmount, decimals: number | undefined, api: IPolkadotApi<TApi, TRes>) => bigint;
+declare const abstractDecimals: <TApi, TRes, TSigner>(amount: TAmount, decimals: number | undefined, api: IPolkadotApi<TApi, TRes, TSigner>) => bigint;
 declare const applyDecimalAbstraction: (amount: TAmount, decimals: number | undefined, shouldAbstract: boolean) => bigint;
 
 declare const createAssetsFilter: (asset: TAsset, version: Version) => {
@@ -2286,21 +2364,23 @@ declare const createAssetsFilter: (asset: TAsset, version: Version) => {
     };
 };
 
-declare const createBaseExecuteXcm: (options: TCreateBaseTransferXcmOptions & {
+declare const createBaseExecuteXcm: <TRes>(options: TCreateBaseTransferXcmOptions<TRes> & {
     suffixXcm?: unknown[];
 }) => unknown[];
 
 declare const createExecuteCall: (chain: TSubstrateChain, xcm: TXcmVersioned<any>, maxWeight: TWeight) => TSerializedExtrinsics;
 
-declare const createExecuteExchangeXcm: <TApi, TRes>(input: TPolkadotXCMTransferOptions<TApi, TRes>, origin: TSubstrateChain, weight: TWeight, originExecutionFee: bigint, destExecutionFee: bigint) => TRes;
+declare const createExecuteExchangeXcm: <TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, origin: TSubstrateChain, weight: TWeight, originExecutionFee: bigint, destExecutionFee: bigint) => TRes;
 
-declare const createDirectExecuteXcm: <TApi, TRes>(options: TCreateTransferXcmOptions<TApi, TRes>) => OneKey<_paraspell_sdk_common.Version, unknown[]>;
+declare const createDirectExecuteXcm: <TApi, TRes, TSigner>(options: TCreateTransferXcmOptions<TApi, TRes, TSigner>) => Promise<OneKey<_paraspell_sdk_common.Version, unknown[]>>;
 
-declare const handleExecuteTransfer: <TApi, TRes>(chain: TSubstrateChain, options: TPolkadotXCMTransferOptions<TApi, TRes>) => Promise<TSerializedExtrinsics>;
+declare const handleExecuteTransfer: <TApi, TRes, TSigner>(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TSerializedExtrinsics>;
 
-declare const handleSwapExecuteTransfer: <TApi, TRes>(options: TCreateSwapXcmOptions<TApi, TRes>) => Promise<TRes>;
+declare const handleSwapExecuteTransfer: <TApi, TRes, TSigner>(options: TCreateSwapXcmOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 
-declare const handleToAhTeleport: <TApi, TRes>(origin: TParachain, input: TPolkadotXCMTransferOptions<TApi, TRes>, defaultTx: TRes) => Promise<TRes>;
+declare const getLocalTransferAmount: <TApi, TRes, TSigner>({ assetInfo, balance, isAmountAll, keepAlive }: TTransferLocalOptions<TApi, TRes, TSigner>, fee?: bigint) => bigint;
+
+declare const handleToAhTeleport: <TApi, TRes, TSigner>(origin: TParachain, input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, defaultTx: TRes) => Promise<TRes>;
 
 declare const throwUnsupportedCurrency: (currency: TCurrencyInput, chain: string, { isDestination }?: {
     isDestination: boolean;
@@ -2309,7 +2389,10 @@ declare const throwUnsupportedCurrency: (currency: TCurrencyInput, chain: string
 declare const parseUnits: typeof parseUnits$1;
 declare const formatUnits: typeof formatUnits$1;
 
-declare const validateAddress: <TApi, TRes>(api: IPolkadotApi<TApi, TRes>, address: TAddress, chain: TChain, isDestination?: boolean) => void;
+declare const addXcmVersionHeader: <T, V extends Version>(obj: T, version: V) => OneKey<V, T>;
+declare const selectXcmVersion: (forcedVersion: Version | undefined, originVersion: Version, destMaxVersion?: Version) => Version;
+declare const pickCompatibleXcmVersion: (origin: TSubstrateChain, destination: TDestination, override?: Version) => Version;
+declare const pickRouterCompatibleXcmVersion: (origin: TSubstrateChain | undefined, exchangeChain: TSubstrateChain, destination: TChain | undefined) => Version;
 
-export { AmountTooLowError, AssetClaimBuilder, BaseAssetsPallet, BatchMode, BatchValidationError, BridgeHaltedError, Builder, DRY_RUN_CLIENT_TIMEOUT_MS, DryRunFailedError, ETH_MAINNET_CHAIN_ID, ETH_TESTNET_CHAIN_ID, FeatureTemporarilyDisabledError, GeneralBuilder, InvalidAddressError, MissingChainApiError, MissingParameterError, NoXCMSupportImplementedError, NumberFormatError, OverrideConflictError, PolkadotXcmError, PolkadotXcmExecutionError, ProviderUnavailableError, RELAY_LOCATION, RoutingResolutionError, RuntimeApiUnavailableError, ScenarioNotSupportedError, TX_CLIENT_TIMEOUT_MS, TransferToAhNotSupported, TypeAndThenUnavailableError, UnableToComputeError, UnsupportedOperationError, XTokensError, abstractDecimals, addEthereumBridgeFees, addXcmVersionHeader, applyDecimalAbstraction, assertAddressIsString, assertDerivationPath, assertHasId, assertHasLocation, assertSenderAddress, assertToIsString, blake2b256, blake2b512, calcPreviewMintAmount, claimAssets, computeFeeFromDryRun, computeFeeFromDryRunPjs, computeOverridenAmount, constructTypeAndThenCall, convertSs58, createAsset, createAssetsFilter, createBaseExecuteXcm, createBeneficiaryLocXTokens, createBeneficiaryLocation, createChainClient, createClientCache, createClientPoolHelpers, createDestination, createDirectExecuteXcm, createExecuteCall, createExecuteExchangeXcm, createId, createTx, createTypeAndThenCall, createTypeThenAutoReserve, createVersionedAssets, createVersionedDestination, createX1Payload, deriveAccountId, dryRun, dryRunInternal, dryRunOrigin, encodeSs58, formatAssetIdToERC20, formatUnits, getAssetBalanceInternal, getAssetReserveChain, getBalance, getBalanceInternal, getBridgeStatus, getChain, getChainConfig, getChainLocation, getChainProviders, getChainVersion, getEthErc20Balance, getEvmPrivateKeyHex, getFailureInfo, getMinTransferableAmount, getMinTransferableAmountInternal, getMoonbeamErc20Balance, getOriginXcmFee, getOriginXcmFeeEstimate, getOriginXcmFeeInternal, getParaEthTransferFees, getParaId, getRelayChainOf, getTChain, getTransferInfo, getTransferableAmount, getTransferableAmountInternal, getXcmFee, getXcmFeeEstimate, getXcmFeeInternal, getXcmFeeOnce, handleExecuteTransfer, handleSwapExecuteTransfer, handleToAhTeleport, isConfig, keyFromWs, localizeLocation, maybeOverrideAsset, maybeOverrideAssets, normalizeAmount, overrideTxAmount, padFee, padValueBy, parseUnits, resolveDestChain, resolveModuleError, resolveParaId, reverseTransformLocation, send, sortAssets, throwUnsupportedCurrency, transferMoonbeamEvm, transferMoonbeamToEth, traverseXcmHops, validateAddress, validateAssetSpecifiers, validateCurrency, validateDestination, verifyEdOnDestination, wrapTxBypass };
-export type { BuildHopInfoOptions, ClientCache, HopProcessParams, HopTraversalConfig, HopTraversalResult, IPolkadotApi, IPolkadotXCMTransfer, IXTokensTransfer, IXTransferTransfer, OneKey, TAddress, TApiOrUrl, TAssetClaimInternalOptions, TAssetClaimOptions, TAssetClaimOptionsBase, TBatchOptions, TBatchedSendOptions, TBifrostToken, TBridgeStatus, TBuildDestInfoOptions, TBuildInternalRes, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, TDestXcmFeeDetail, TDestination, TDryRunBaseOptions, TDryRunBypassOptions, TDryRunCallBaseOptions, TDryRunCallOptions, TDryRunChainFailure, TDryRunChainResult, TDryRunChainSuccess, TDryRunError, TDryRunOptions, TDryRunPreviewOptions, TDryRunResBase, TDryRunResult, TDryRunXcmBaseOptions, TDryRunXcmOptions, TEvmBuilderOptions, TEvmBuilderOptionsBase, TEvmChainFrom, TFeeType, TForeignAssetId, TForeignOrNativeAsset, TForeignOrTokenAsset, TGetAssetBalanceOptions, TGetAssetBalanceOptionsBase, TGetBalanceCommonOptions, TGetBalanceOptions, TGetBalanceOptionsBase, TGetFeeForDestChainBaseOptions, TGetFeeForDestChainOptions, TGetMinTransferableAmountOptions, TGetOriginXcmFeeBaseOptions, TGetOriginXcmFeeEstimateOptions, TGetOriginXcmFeeInternalOptions, TGetOriginXcmFeeOptions, TGetReverseTxFeeOptions, TGetTransferInfoOptions, TGetTransferInfoOptionsBase, TGetTransferableAmountOptions, TGetTransferableAmountOptionsBase, TGetXcmFeeBaseOptions, TGetXcmFeeBuilderOptions, TGetXcmFeeEstimateDetail, TGetXcmFeeEstimateOptions, TGetXcmFeeEstimateResult, TGetXcmFeeInternalOptions, TGetXcmFeeOptions, TGetXcmFeeResult, THopInfo, THopTransferInfo, TMantaAsset, TModuleError, TNativeTokenAsset, TNodleAsset, TOriginFeeDetails, TOtherReserveAsset, TPolkadotXCMTransferOptions, TPolkadotXcmMethod, TProviderEntry, TReserveAsset, TResolveHopParams, TScenario, TSelfReserveAsset, TSendBaseOptions, TSendBaseOptionsWithSenderAddress, TSendInternalOptions, TSendOptions, TSerializeEthTransferOptions, TSerializedEthTransfer, TSerializedExtrinsics, TSerializedRuntimeApiQuery, TSerializedStateQuery, TSetBalanceRes, TSwapConfig, TSwapFeeEstimates, TTransferFeeEstimates, TTransferInfo, TTransferLocalOptions, TTxFactory, TTypeAndThenCallContext, TTypeAndThenFees, TTypeAndThenOverrides, TUrl, TVerifyEdOnDestinationOptions, TVerifyEdOnDestinationOptionsBase, TWeight, TXTokensCurrencySelection, TXTokensMethod, TXTokensTransferOptions, TXTransferMethod, TXTransferTransferOptions, TXcmAsset, TXcmFeeBase, TXcmFeeDetail, TXcmFeeDetailError, TXcmFeeDetailSuccess, TXcmFeeDetailWithFallback, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSenderAddress };
+export { AmountTooLowError, AssetClaimBuilder, BaseAssetsPallet, BatchMode, BatchValidationError, BridgeHaltedError, Builder, DRY_RUN_CLIENT_TIMEOUT_MS, DryRunFailedError, ETH_MAINNET_CHAIN_ID, ETH_TESTNET_CHAIN_ID, FeatureTemporarilyDisabledError, GeneralBuilder, InvalidAddressError, MissingChainApiError, MissingParameterError, NoXCMSupportImplementedError, NumberFormatError, OverrideConflictError, PolkadotXcmError, PolkadotXcmExecutionError, ProviderUnavailableError, RELAY_LOCATION, RoutingResolutionError, RuntimeApiUnavailableError, ScenarioNotSupportedError, TRANSACT_ORIGINS, TX_CLIENT_TIMEOUT_MS, TransferToAhNotSupported, TypeAndThenUnavailableError, UnableToComputeError, UnsupportedOperationError, ValidationError, XTokensError, abstractDecimals, addEthereumBridgeFees, addXcmVersionHeader, applyDecimalAbstraction, assertAddressIsString, assertHasId, assertHasLocation, assertSender, assertSenderAddress, assertToIsString, blake2b256, blake2b512, calcPreviewMintAmount, claimAssets, compareAddresses, computeFeeFromDryRun, computeFeeFromDryRunPjs, computeOverridenAmount, constructTypeAndThenCall, convertSs58, createAsset, createAssetsFilter, createBaseExecuteXcm, createBeneficiaryLocXTokens, createBeneficiaryLocation, createChainClient, createClientCache, createClientPoolHelpers, createDestination, createDirectExecuteXcm, createExecuteCall, createExecuteExchangeXcm, createId, createTx, createTypeAndThenCall, createTypeThenAutoReserve, createVersionedAssets, createVersionedDestination, createX1Payload, deriveAccountId, dryRun, dryRunInternal, dryRunOrigin, encodeSs58, formatAssetIdToERC20, formatUnits, getAssetBalanceInternal, getAssetReserveChain, getBalance, getBalanceInternal, getBridgeStatus, getChain, getChainConfig, getChainLocation, getChainProviders, getChainVersion, getEthErc20Balance, getEvmPrivateKeyHex, getFailureInfo, getLocalTransferAmount, getMinTransferableAmount, getMinTransferableAmountInternal, getMoonbeamErc20Balance, getOriginXcmFee, getOriginXcmFeeEstimate, getOriginXcmFeeInternal, getParaEthTransferFees, getParaId, getRelayChainOf, getTChain, getTransferInfo, getTransferableAmount, getTransferableAmountInternal, getXcmFee, getXcmFeeEstimate, getXcmFeeInternal, getXcmFeeOnce, handleExecuteTransfer, handleSwapExecuteTransfer, handleToAhTeleport, isConfig, isSenderSigner, keyFromWs, localizeLocation, maybeOverrideAsset, maybeOverrideAssets, normalizeAmount, overrideTxAmount, padFee, padValueBy, parseUnits, pickCompatibleXcmVersion, pickRouterCompatibleXcmVersion, resolveDestChain, resolveModuleError, resolveParaId, resolveSendParams, reverseTransformLocation, selectXcmVersion, send, sortAssets, throwUnsupportedCurrency, transferMoonbeamEvm, transferMoonbeamToEth, traverseXcmHops, validateAddress, validateAssetSpecifiers, validateCurrency, validateDestination, validateDestinationAddress, validateTransact, verifyEdOnDestination, wrapTxBypass };
+export type { BuildHopInfoOptions, ClientCache, HopProcessParams, HopTraversalConfig, HopTraversalResult, IPolkadotApi, IPolkadotXCMTransfer, IXTokensTransfer, IXTransferTransfer, OneKey, TAddress, TApiOrUrl, TAssetClaimInternalOptions, TAssetClaimOptions, TAssetClaimOptionsBase, TBatchOptions, TBatchedSendOptions, TBifrostToken, TBridgeStatus, TBuildDestInfoOptions, TBuildInternalRes, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, TDestXcmFeeDetail, TDestination, TDryRunBaseOptions, TDryRunBypassOptions, TDryRunCallBaseOptions, TDryRunCallOptions, TDryRunChainFailure, TDryRunChainResult, TDryRunChainSuccess, TDryRunError, TDryRunOptions, TDryRunPreviewOptions, TDryRunResBase, TDryRunResult, TDryRunXcmBaseOptions, TDryRunXcmOptions, TEvmBuilderOptions, TEvmBuilderOptionsBase, TEvmChainFrom, TFeeType, TForeignAssetId, TForeignOrNativeAsset, TForeignOrTokenAsset, TGetAssetBalanceOptions, TGetAssetBalanceOptionsBase, TGetBalanceCommonOptions, TGetBalanceOptions, TGetBalanceOptionsBase, TGetFeeForDestChainBaseOptions, TGetFeeForDestChainOptions, TGetMinTransferableAmountOptions, TGetOriginXcmFeeBaseOptions, TGetOriginXcmFeeEstimateOptions, TGetOriginXcmFeeInternalOptions, TGetOriginXcmFeeOptions, TGetReverseTxFeeOptions, TGetTransferInfoOptions, TGetTransferInfoOptionsBase, TGetTransferableAmountOptions, TGetTransferableAmountOptionsBase, TGetXcmFeeBaseOptions, TGetXcmFeeBuilderOptions, TGetXcmFeeEstimateDetail, TGetXcmFeeEstimateOptions, TGetXcmFeeEstimateResult, TGetXcmFeeInternalOptions, TGetXcmFeeOptions, TGetXcmFeeResult, THopInfo, THopTransferInfo, TMantaAsset, TModuleError, TNativeTokenAsset, TNodleAsset, TOriginFeeDetails, TOtherReserveAsset, TPaymentInfo, TPolkadotXCMTransferOptions, TPolkadotXcmMethod, TProviderEntry, TReserveAsset, TResolveHopParams, TScenario, TSelfReserveAsset, TSendBaseOptions, TSendBaseOptionsWithSenderAddress, TSendInternalOptions, TSendOptions, TSender, TSerializeEthTransferOptions, TSerializedEthTransfer, TSerializedExtrinsics, TSerializedRuntimeApiQuery, TSerializedStateQuery, TSetBalanceRes, TSwapConfig, TSwapFeeEstimates, TTransactOptions, TTransactOrigin, TTransferFeeEstimates, TTransferInfo, TTransferLocalOptions, TTxFactory, TTypeAndThenCallContext, TTypeAndThenFees, TTypeAndThenOverrides, TUrl, TVerifyEdOnDestinationOptions, TVerifyEdOnDestinationOptionsBase, TWeight, TXTokensCurrencySelection, TXTokensMethod, TXTokensTransferOptions, TXTransferMethod, TXTransferTransferOptions, TXcmAsset, TXcmFeeBase, TXcmFeeDetail, TXcmFeeDetailError, TXcmFeeDetailSuccess, TXcmFeeDetailWithFallback, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSenderAddress };