@paraspell/sdk-core 13.2.2 → 13.4.0

package/dist/index.d.ts

@@ -1,14 +1,12 @@
 import * as _paraspell_sdk_common from '@paraspell/sdk-common';
-import { TSubstrateChain as TSubstrateChain$1, TChain as TChain$1, Version, TLocation, TRelaychain, TParachain, TExternalChain, TJunction, Parents, TJunctions } from '@paraspell/sdk-common';
+import { TSubstrateChain, TChain, Version, TRelaychain, TParachain, TLocation, TExternalChain, TJunction, Parents, TJunctions } from '@paraspell/sdk-common';
 export * from '@paraspell/sdk-common';
 import * as _paraspell_assets from '@paraspell/assets';
-import { TAssetInfo, WithAmount, TAsset, TCurrencyCore, TCurrencyInputWithAmount, TCurrencyInput as TCurrencyInput$1, TAssetWithFee, WithComplexAmount, TAmount as TAmount$1, TAssetInfoWithId } from '@paraspell/assets';
+import { TAssetInfo, WithAmount, TAsset, TCurrencyCore, TCurrencyInputWithAmount, TCurrencyInput, TAmount, TAssetWithFee, WithComplexAmount, TAssetInfoWithId } from '@paraspell/assets';
 export * from '@paraspell/assets';
 import { TPallet, TAssetsPallet } from '@paraspell/pallets';
 export * from '@paraspell/pallets';
 import { WalletClient, formatUnits as formatUnits$1, parseUnits as parseUnits$1 } from 'viem';
-import * as _paraspell_swap from '@paraspell/swap';
-import { RouterBuilder } from '@paraspell/swap';
 
 type WithApi<TBase, TApi, TRes, TSigner> = TBase & {
     api: PolkadotApi<TApi, TRes, TSigner>;
@@ -42,7 +40,7 @@ type TApiType = (typeof API_TYPES)[number];
 
 declare abstract class PolkadotApi<TApi, TRes, TSigner> {
     _api?: TApi;
-    _chain?: TSubstrateChain$1;
+    _chain?: TSubstrateChain;
     readonly _config?: TBuilderOptions<TApiOrUrl<TApi>>;
     _ttlMs: number;
     _disconnectAllowed: boolean;
@@ -52,12 +50,14 @@ declare abstract class PolkadotApi<TApi, TRes, TSigner> {
     set disconnectAllowed(allowed: boolean);
     get disconnectAllowed(): boolean;
     get config(): TBuilderOptions<TApiOrUrl<TApi>> | undefined;
-    abstract init(chain: TChain$1, clientTtlMs?: number): Promise<void>;
-    abstract createApiInstance(wsUrl: TUrl, chain: TSubstrateChain$1): Promise<TApi>;
+    init(chain: TChain, clientTtlMs?: number): Promise<void>;
+    abstract leaseClient(wsUrl: TUrl, ttlMs: number): Promise<TApi>;
     abstract accountToHex(address: string, isPrefixed?: boolean): string;
     abstract accountToUint8a(address: string): Uint8Array;
     abstract deserializeExtrinsics(serialized: TSerializedExtrinsics): TRes;
     abstract txFromHex(hex: string): Promise<TRes>;
+    abstract txToHex(tx: TRes): Promise<string>;
+    abstract encodeTx(hex: string): unknown;
     abstract queryState<T>(serialized: TSerializedStateQuery): Promise<T>;
     abstract queryRuntimeApi<T>(serialized: TSerializedRuntimeApiQuery): Promise<T>;
     abstract callBatchMethod(calls: TRes[], mode: BatchMode): TRes;
@@ -72,14 +72,13 @@ declare abstract class PolkadotApi<TApi, TRes, TSigner> {
         partialFee: bigint;
         weight: TWeight;
     }>;
-    abstract quoteAhPrice(fromMl: TLocation, toMl: TLocation, amountIn: bigint, includeFee?: boolean): Promise<bigint | undefined>;
     abstract getXcmWeight(xcm: any): Promise<TWeight>;
-    abstract getXcmPaymentApiFee(chain: TSubstrateChain$1, localXcm: any, forwardedXcm: any, asset: TAssetInfo, version: Version, transformXcm: boolean): Promise<bigint>;
+    abstract getXcmPaymentApiFee(chain: TSubstrateChain, localXcm: any, forwardedXcm: any, asset: TAssetInfo, version: Version, transformXcm: boolean): Promise<bigint>;
     abstract getEvmStorage(contract: string, slot: string): Promise<string>;
     abstract getFromRpc(module: string, method: string, key: string): Promise<string>;
     abstract blake2AsHex(data: Uint8Array): string;
     abstract clone(): PolkadotApi<TApi, TRes, TSigner>;
-    abstract createApiForChain(chain: TSubstrateChain$1): Promise<PolkadotApi<TApi, TRes, TSigner>>;
+    abstract createApiForChain(chain: TSubstrateChain): Promise<PolkadotApi<TApi, TRes, TSigner>>;
     abstract getDryRunCall(options: TDryRunCallBaseOptions<TRes>): Promise<TDryRunChainResult>;
     abstract getDryRunXcm(options: TDryRunXcmBaseOptions<TRes>): Promise<TDryRunChainResult>;
     abstract getBridgeStatus(): Promise<TBridgeStatus>;
@@ -96,18 +95,18 @@ declare abstract class Chain<TApi, TRes, TSigner> {
     private readonly _info;
     private readonly _ecosystem;
     private readonly _version;
-    constructor(chain: TSubstrateChain$1, info: string, ecosystem: TRelaychain, version: Version);
+    constructor(chain: TSubstrateChain, info: string, ecosystem: TRelaychain, version: Version);
     get info(): string;
     get ecosystem(): TRelaychain;
-    get chain(): TSubstrateChain$1;
+    get chain(): TSubstrateChain;
     get version(): Version;
     transfer(transferOptions: TTransferInternalOptions<TApi, TRes, TSigner>): Promise<TRes>;
     isRelayToParaEnabled(): boolean;
-    throwIfCantReceive(destChain: TChain$1 | undefined): void;
-    throwIfTempDisabled(options: TTransferInternalOptions<TApi, TRes, TSigner>, destChain?: TChain$1): void;
+    throwIfCantReceive(destChain: TChain | undefined): void;
+    throwIfTempDisabled(options: TTransferInternalOptions<TApi, TRes, TSigner>, destChain?: TChain): void;
     isSendingTempDisabled(_options: TTransferInternalOptions<TApi, TRes, TSigner>): boolean;
     isReceivingTempDisabled(_scenario: TScenario): boolean;
-    canReceiveFrom(_origin: TChain$1): boolean;
+    canReceiveFrom(_origin: TChain): boolean;
     shouldUseNativeAssetTeleport({ assetInfo: asset, to }: TTransferInternalOptions<TApi, TRes, TSigner>): boolean;
     createAsset(asset: WithAmount<TAssetInfo>, version: Version): TAsset;
     getNativeAssetSymbol(): string;
@@ -286,7 +285,7 @@ declare class CoretimeKusama<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSig
 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$1): boolean;
+    canReceiveFrom(origin: TChain): boolean;
 }
 
 declare class CoretimePaseo<TApi, TRes, TSigner> extends CoretimePolkadot<TApi, TRes, TSigner> {
@@ -388,7 +387,7 @@ declare class Kintsugi<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> i
 }
 
 declare class Polkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
-    constructor(chain?: TSubstrateChain$1, info?: string, ecosystem?: TRelaychain, version?: Version);
+    constructor(chain?: TSubstrateChain, info?: string, ecosystem?: TRelaychain, version?: Version);
     transferPolkadotXCM(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
 }
 
@@ -515,14 +514,14 @@ declare class Westend<TApi, TRes, TSigner> extends Polkadot<TApi, TRes, TSigner>
 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$1): boolean;
+    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$1): boolean;
+    canReceiveFrom(origin: TChain): boolean;
     transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
 }
 
@@ -611,1005 +610,1045 @@ declare const TRANSACT_ORIGINS: readonly ["Native", "SovereignAccount", "Superus
  */
 declare const EXCHANGE_CHAINS: readonly ["AssetHubPolkadot", "AssetHubKusama", "AssetHubPaseo", "AssetHubWestend", "Hydration", "Karura", "Acala", "BifrostKusama", "BifrostPolkadot"];
 
-type TExchangeChain = (typeof EXCHANGE_CHAINS)[number];
-type TExchangeInput = TExchangeChain | TExchangeChain[] | undefined;
-type TSwapOptions<TApi, TRes, TSigner> = {
+type TSwapConfig = {
     currencyTo: TCurrencyCore;
-    exchange?: TExchangeInput;
-    slippage?: number;
-    evmSenderAddress?: string;
-    evmSigner?: TSigner;
-    onStatusChange?: TStatusChangeCallback<TApi, TRes>;
+    exchangeChain: TParachain;
 };
-type TTransactionContext<TApi, TRes> = {
-    type: TTransactionType;
-    api: TApi;
-    chain: TSubstrateChain$1;
+type TDryRunBaseOptions<TRes> = {
     tx: TRes;
-};
-type TTransactionType = 'TRANSFER' | 'SWAP' | 'SWAP_AND_TRANSFER';
-type TSwapEventType = TTransactionType | 'SELECTING_EXCHANGE' | 'COMPLETED';
-/**
- * The transaction progress information.
- */
-type TSwapEvent<TApi, TRes> = {
-    /**
-     * Current execution phase type
-     */
-    type: TSwapEventType;
-    /**
-     * Full transaction plan for visualization
-     */
-    routerPlan?: TTransactionContext<TApi, TRes>[];
-    /**
-     * Current transaction's origin chain
-     */
-    chain?: TSubstrateChain$1;
-    /**
-     * Current transaction's destination chain
-     */
-    destinationChain?: TChain$1;
-    /**
-     * 0-based step index of current operation
-     */
-    currentStep?: number;
-};
-type TStatusChangeCallback<TApi, TRes> = (info: TSwapEvent<TApi, TRes>) => void;
-
-type TPolkadotXCMTransferOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    chain: TSubstrateChain$1;
-    beneficiaryLocation: TLocation;
-    recipient: TAddress;
-    asset: TAsset;
-    overriddenAsset?: TLocation | TAssetWithFee[];
-    scenario: TScenario;
-    assetInfo: WithAmount<TAssetInfo>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    sender: string;
     currency: TCurrencyInputWithAmount;
-    feeAssetInfo?: TAssetInfo;
-    feeCurrency?: TCurrencyInput$1;
-    destination: TDestination;
-    destChain?: TChain$1;
-    paraIdTo?: number;
-    version: Version;
-    sender?: string;
-    ahAddress?: string;
-    pallet?: string;
-    method?: string;
-    transactOptions?: TTransactOptions<TRes>;
-};
-type TXTokensTransferOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    asset: WithAmount<TAssetInfo>;
-    recipient: TAddress;
-    scenario: TScenario;
-    origin: TSubstrateChain$1;
-    destination: TDestination;
-    paraIdTo?: number;
-    version: Version;
-    overriddenAsset?: TLocation | TAssetWithFee[];
-    pallet?: string;
-    method?: string;
-    useMultiAssetTransfer?: boolean;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    swapConfig?: TSwapConfig;
+    useRootOrigin?: boolean;
+    bypassOptions?: TBypassOptions;
 };
-interface IPolkadotXCMTransfer<TApi, TRes, TSigner> {
-    transferPolkadotXCM: (input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
-}
-interface IXTokensTransfer<TApi, TRes, TSigner> {
-    transferXTokens: (input: TXTokensTransferOptions<TApi, TRes, TSigner>) => TRes;
-}
-type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
-type TAddress = string | TLocation;
-type TDestination = TChain$1 | TLocation;
-type TTransferBaseOptions<TApi, TRes, TSigner> = {
-    /**
-     * The origin chain
-     */
-    from: TSubstrateChain$1;
-    /**
-     * The destination address. A SS58 or H160 format.
-     */
-    recipient: TAddress;
-    /**
-     * The optional sender address. A SS58 or H160 format.
-     */
-    sender?: 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;
+type TDryRunOptions<TApi, TRes, TSigner> = WithApi<TDryRunBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunCallBaseOptions<TRes> = {
     /**
-     * The optional fee asset. Either ID, symbol, or location
+     * The transaction to dry-run
      */
-    feeAsset?: TCurrencyInput$1;
+    tx: TRes;
     /**
-     * The optional destination parachain ID
+     * The chain to dry-run on
      */
-    paraIdTo?: number;
+    chain: TSubstrateChain;
     /**
-     * The optional overrided XCM version
+     * The destination chain
      */
-    version?: Version;
+    destination: TDestination;
     /**
-     * The optional pallet override
+     * The address to dry-run with
      */
-    pallet?: string;
+    address: string;
     /**
-     * Whether to keep the account alive after the transfer.
+     * Whether to use the root origin
      */
-    keepAlive?: boolean;
+    useRootOrigin?: boolean;
     /**
-     * The optional pallet method override
+     * XCM version to use for the dry-run parameters
      */
-    method?: string;
+    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;
     /**
-     * Hex of the encoded transaction call to apply on the destination chain
+     * The XCM instructions
      */
-    transactOptions?: TTransactOptions<TRes>;
+    xcm: any;
+    /** The transaction to dry-run */
+    tx: TRes;
     /**
-     * The optional swap options
+     * The chain to dry-run on
      */
-    swapOptions?: TSwapOptions<TApi, TRes, TSigner>;
-};
-/**
- * Options for transferring from a parachain to another parachain or relay chain
- */
-type TTransferOptions<TApi, TRes, TSigner> = WithApi<TTransferBaseOptions<TApi, TRes, TSigner>, TApi, TRes, TSigner> & {
-    isAmountAll: boolean;
-};
-type WithRequiredSender<TBase> = Omit<TBase, 'sender'> & {
+    chain: TSubstrateChain;
     /**
-     * The sender address. A SS58 or H160 format.
+     * The origin chain
      */
-    sender: string;
-};
-type WithRequiredSwapOptions<TBase, TApi, TRes, TSigner> = Omit<TBase, 'swapOptions'> & {
-    swapOptions: TSwapOptions<TApi, TRes, TSigner>;
-};
-type TTransferOptionsWithSwap<TApi, TRes, TSigner> = WithRequiredSwapOptions<Omit<TTransferOptions<TApi, TRes, TSigner>, 'isAmountAll'>, TApi, TRes, TSigner>;
-type TTransferBaseOptionsWithSwap<TApi, TRes, TSigner> = WithRequiredSwapOptions<TTransferBaseOptions<TApi, TRes, TSigner>, TApi, TRes, TSigner>;
-type TTransferBaseOptionsWithSender<TApi, TRes, TSigner> = WithRequiredSender<TTransferBaseOptions<TApi, TRes, TSigner>>;
-type TTransferInternalOptions<TApi, TRes, TSigner> = Omit<TTransferBaseOptions<TApi, TRes, TSigner>, 'from' | 'feeAsset' | 'version'> & {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    assetInfo: WithAmount<TAssetInfo>;
-    feeAsset?: TAssetInfo;
-    feeCurrency?: TCurrencyInput$1;
-    overriddenAsset?: TLocation | TAssetWithFee[];
+    origin: TSubstrateChain;
+    asset: TAssetInfo;
     version: Version;
-    isAmountAll: 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>;
+    feeAsset?: TAssetInfo;
+    amount: bigint;
+    originFee: bigint;
 };
-type TSerializedStateQuery = {
-    module: TAssetsPallet;
-    method: string;
-    params: unknown[];
+type TDryRunXcmOptions<TApi, TRes, TSigner> = WithApi<TDryRunXcmBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunResBase = {
+    asset: TAssetInfo;
+    isExchange?: boolean;
 };
-type TSerializedRuntimeApiQuery = {
-    module: string;
-    method: string;
-    params: unknown[];
+type TDryRunChainSuccess = TDryRunResBase & {
+    success: true;
+    fee: bigint;
+    weight?: TWeight;
+    forwardedXcms: any;
+    destParaId?: number;
 };
-type TDestWeight = {
-    ref_time: bigint;
-    proof_size: bigint;
+type TDryRunChainFailure = TDryRunResBase & {
+    success: false;
+    failureReason: string;
+    failureSubReason?: string;
 };
-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 TDryRunChainResult = TDryRunChainSuccess | TDryRunChainFailure;
+type THopInfo = {
+    chain: TChain;
+    result: TDryRunChainResult;
 };
-type TCreateBeneficiaryOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    address: TAddress;
-    version: Version;
+type TChainEndpoint = 'origin' | 'destination' | TChain;
+type TDryRunResult = {
+    failureReason?: string;
+    failureSubReason?: string;
+    failureChain?: TChainEndpoint;
+    origin: TDryRunChainResult;
+    destination?: TDryRunChainResult;
+    hops: THopInfo[];
 };
-type TCreateBeneficiaryXTokensOptions<TApi, TRes, TSigner> = {
+type TResolveHopParams<TApi, TRes, TSigner> = {
     api: PolkadotApi<TApi, TRes, TSigner>;
-    origin: TSubstrateChain$1;
+    tx: TRes;
+    originChain: TSubstrateChain;
+    currentChain: TSubstrateChain;
     destination: TDestination;
-    recipient: TAddress;
-    version: Version;
-    paraId?: number;
+    asset: TAssetInfo;
+    currency: TCurrencyInputWithAmount;
+    swapConfig?: TSwapConfig;
+    hasPassedExchange: boolean;
 };
-type TBridgeStatus = 'Normal' | 'Halted';
-type TTransferLocalOptions<TApi, TRes, TSigner> = Omit<TTransferInternalOptions<TApi, TRes, TSigner>, 'recipient'> & {
-    recipient: string;
-    balance: bigint;
+type HopProcessParams<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    currentChain: TSubstrateChain;
+    currentOrigin: TSubstrateChain;
+    currentAsset: TAssetInfo;
+    forwardedXcms: any;
+    hasPassedExchange: boolean;
+    isDestination: boolean;
 };
-type TTransferFeeEstimates = {
-    originFee: bigint;
-    reserveFee: bigint;
-};
-type TCreateBaseTransferXcmOptions<TRes> = {
-    chain: TSubstrateChain$1;
-    destChain: TChain$1;
-    assetInfo: WithAmount<TAssetInfo>;
-    feeAssetInfo?: TAssetInfo;
-    fees: TTransferFeeEstimates;
-    recipient: string;
-    sender?: string;
-    version: Version;
-    useJitWithdraw?: boolean;
-    useFeeAssetOnHops?: boolean;
-    paraIdTo?: number;
-    transactOptions?: TTransactOptions<TRes>;
-};
-type TCreateTransferXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseTransferXcmOptions<TRes>, TApi, TRes, TSigner>;
-type TCreateBaseSwapXcmOptions = {
-    chain?: TSubstrateChain$1;
-    exchangeChain: TExchangeChain;
-    destChain?: TChain$1;
-    assetInfoFrom: WithAmount<TAssetInfo>;
-    assetInfoTo: WithAmount<TAssetInfo>;
-    currencyTo: TCurrencyInput$1;
-    feeAssetInfo?: TAssetInfo;
-    sender: string;
-    recipient: string;
-    calculateMinAmountOut: (amountIn: bigint, assetTo?: TAssetInfo) => Promise<bigint>;
-};
-type TCreateSwapXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner>;
-type TSwapFeeEstimates = {
-    originFee: bigint;
-    originReserveFee: bigint;
-    exchangeFee: bigint;
-    destReserveFee: bigint;
+type HopTraversalConfig<TApi, TRes, TSigner, THopResult> = {
+    api: PolkadotApi<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 TCreateSwapXcmInternalOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner> & {
-    version: Version;
-    fees: TSwapFeeEstimates;
-    paraIdTo?: number;
+type HopTraversalResult<THopResult> = {
+    hops: Array<{
+        chain: TSubstrateChain;
+        result: THopResult;
+    }>;
+    destination?: THopResult;
+    lastProcessedChain?: TSubstrateChain;
 };
-type TCreateEthBridgeInstructionsOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    recipient: TAddress;
-    assetInfo: TAssetInfo;
-    sender: string;
-    ahAddress?: string;
-    version: Version;
+type TBypassOptions = {
+    mintFeeAssets?: boolean;
+    sentAssetMintMode?: 'preview' | 'bypass';
 };
-
-/** @deprecated Asset claim functionality is deprecated and will be removed in v14. */
-type TAssetClaimOptionsBase = {
-    chain: TSubstrateChain$1;
-    currency: WithComplexAmount<TCurrencyCore> | TAsset<TAmount$1>[] | WithComplexAmount<TCurrencyCore>[];
-    address: TAddress;
-    version?: Version;
+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 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 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 TAssetClaimOptions<TApi, TRes, TSigner> = WithApi<TAssetClaimOptionsBase, TApi, TRes, TSigner>;
-type TAssetClaimInternalOptions<TApi, TRes, TSigner> = TAssetClaimOptions<TApi, TRes, TSigner> & {
-    version: Version;
-    assets: TAsset<bigint>[];
+type TDryRunError = {
+    failureReason: string;
+    failureSubReason?: string;
 };
 
-type TSetBalanceRes = {
-    assetStatusTx?: TSerializedExtrinsics;
-    balanceTx: TSerializedExtrinsics;
+type TXcmFeeSwapConfig = TSwapConfig & {
+    amountOut: bigint;
 };
-declare abstract class BaseAssetsPallet {
-    protected palletName: TAssetsPallet;
-    constructor(palletName: TAssetsPallet);
-    abstract mint<TApi, TRes, TSigner>(address: string, assetInfo: WithAmount<TAssetInfo>, balance: bigint, chain: TSubstrateChain$1, api: PolkadotApi<TApi, TRes, TSigner>): Promise<TSetBalanceRes>;
-    abstract getBalance<TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo, customCurrencyId?: unknown): Promise<bigint>;
-}
-
-/**
- * Builder class for constructing asset claim transactions.
- *
- * @deprecated Asset claim functionality is deprecated and will be removed in v14.
- */
-declare class AssetClaimBuilder<TApi, TRes, TSigner, T extends Partial<TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>> = object> {
-    readonly api: PolkadotApi<TApi, TRes, TSigner>;
-    readonly _options: T;
-    constructor(api: PolkadotApi<TApi, TRes, TSigner>, 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, TSigner, T & {
-        currency: TAssetClaimOptionsBase['currency'];
-    }>;
-    /**
-     * Sets the sender address.
-     *
-     * @param address - The sender address.
-     * @returns
-     */
-    sender(sender: TSender<TSigner>): AssetClaimBuilder<TApi, TRes, TSigner, T & {
-        sender: 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, TSigner, T & {
-        address: TAddress;
-    }>;
+type TTxFactory<TRes> = (amount?: string, relative?: boolean) => Promise<TRes>;
+type TGetXcmFeeBaseOptions<TRes, TDisableFallback extends boolean = boolean> = {
     /**
-     * Sets the XCM version to be used for the asset claim.
-     *
-     * @param version - The XCM version.
-     * @returns An instance of Builder
+     * The transaction factory
      */
-    xcmVersion(version: Version): AssetClaimBuilder<TApi, TRes, TSigner, T & {
-        version: Version;
-    }>;
+    buildTx: TTxFactory<TRes>;
     /**
-     * Builds and returns the asset claim extrinsic.
-     *
-     * @returns A Promise that resolves to the asset claim extrinsic.
+     * The origin chain
      */
-    build(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase>): Promise<TRes>;
-    signAndSubmit(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>>): Promise<string>;
+    origin: TSubstrateChain;
     /**
-     * Returns the API instance used by the builder.
-     *
-     * @returns The API instance.
+     * The destination chain
      */
-    getApi(): TApi;
+    destination: TChain;
     /**
-     * Disconnects the API.
-     *
-     * @returns A Promise that resolves when the API is disconnected.
+     * The sender address
      */
-    disconnect(): Promise<void>;
-}
-
-declare class BatchTransactionManager<TApi, TRes, TSigner> {
-    transactionOptions: TBatchedTransferOptions<TApi, TRes, TSigner>[];
-    addTransaction(options: TBatchedTransferOptions<TApi, TRes, TSigner>): void;
-    isEmpty(): boolean;
-    buildBatch(api: PolkadotApi<TApi, TRes, TSigner>, from: TSubstrateChain$1, options?: TBatchOptions): Promise<TRes>;
-}
-
-/**
- * A builder class for constructing Para-to-Para, Para-to-Relay, Relay-to-Para transactions and asset claims.
- */
-declare class GeneralBuilder<TApi, TRes, TSigner, T extends Partial<TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>> = object> {
-    readonly batchManager: BatchTransactionManager<TApi, TRes, TSigner>;
-    readonly api: PolkadotApi<TApi, TRes, TSigner>;
-    readonly _options: T;
-    constructor(api: PolkadotApi<TApi, TRes, TSigner>, batchManager: BatchTransactionManager<TApi, TRes, TSigner>, options?: T);
+    sender: string;
+    recipient: string;
+    currency: WithAmount<TCurrencyCore>;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    disableFallback: TDisableFallback;
+    swapConfig?: TXcmFeeSwapConfig;
+    skipReverseFeeCalculation?: boolean;
+};
+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 TGetXcmFeeBuilderOptions = {
+    disableFallback: boolean;
+};
+type TGetOriginXcmFeeBaseOptions<TRes> = {
+    buildTx: TTxFactory<TRes>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    sender: string;
+    currency: WithAmount<TCurrencyCore>;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    disableFallback: boolean;
+    useRootOrigin?: boolean;
+};
+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 TGetFeeForDestChainBaseOptions<TRes> = {
+    prevChain: TSubstrateChain;
+    origin: TSubstrateChain;
+    destination: TChain;
+    sender: string;
+    recipient: string;
+    currency: WithAmount<TCurrencyCore>;
+    forwardedXcms: any;
+    tx: TRes;
+    asset: TAssetInfo;
+    version: Version;
+    originFee: bigint;
+    feeAsset?: TCurrencyInput;
+    disableFallback: boolean;
+    hasPassedExchange?: boolean;
+    swapConfig?: TXcmFeeSwapConfig;
+    skipReverseFeeCalculation?: boolean;
+};
+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 TFeeType = 'dryRun' | 'paymentInfo' | 'noFeeRequired';
+type TXcmFeeBase$1 = {
+    asset: TAssetInfo;
+    weight?: TWeight;
+    sufficient?: boolean;
+    isExchange?: boolean;
+};
+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 TPaymentInfo = {
+    partialFee: bigint;
+    weight: TWeight;
+};
+
+type TExchangeChain = (typeof EXCHANGE_CHAINS)[number];
+type TExchangeInput = TExchangeChain | TExchangeChain[] | undefined;
+type TSwapOptions<TApi, TRes, TSigner> = {
+    currencyTo: TCurrencyCore;
+    exchange?: TExchangeInput;
+    slippage?: number;
+    evmSenderAddress?: string;
+    evmSigner?: TSigner;
+    onStatusChange?: TStatusChangeCallback<TApi, TRes>;
+};
+type TTransactionContext<TApi, TRes> = {
+    type: TTransactionType;
+    api: TApi;
+    chain: TSubstrateChain;
+    tx: TRes;
+};
+type TTransactionType = 'TRANSFER' | 'SWAP' | 'SWAP_AND_TRANSFER';
+type TSwapEventType = TTransactionType | 'SELECTING_EXCHANGE' | 'COMPLETED';
+/**
+ * The transaction progress information.
+ */
+type TSwapEvent<TApi, TRes> = {
     /**
-     * Specifies the origin chain for the transaction.
-     *
-     * @param chain - The chain from which the transaction originates.
-     * @returns An instance of Builder
+     * Current execution phase type
      */
-    from(chain: TSubstrateChain$1): GeneralBuilder<TApi, TRes, TSigner, T & {
-        from: TSubstrateChain$1;
-    }>;
+    type: TSwapEventType;
     /**
-     * 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
+     * Full transaction plan for visualization
      */
-    to(chain: TDestination, paraIdTo?: number): GeneralBuilder<TApi, TRes, TSigner, T & {
-        to: TDestination;
-    }>;
+    routerPlan?: TTransactionContext<TApi, TRes>[];
     /**
-     * Initiates the process to claim assets from a specified chain.
-     *
-     * @deprecated Asset claim functionality is deprecated and will be removed in v14.
-     * @param chain - The chain from which to claim assets.
-     * @returns An instance of Builder
+     * Current transaction's origin chain
      */
-    claimFrom(chain: TSubstrateChain$1): AssetClaimBuilder<TApi, TRes, TSigner, {
-        chain: TSubstrateChain$1;
-    }>;
+    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
+     * Current transaction's destination chain
      */
-    currency(currency: TCurrencyInputWithAmount): GeneralBuilder<TApi, TRes, TSigner, T & {
-        currency: TCurrencyInputWithAmount;
-    }>;
+    destinationChain?: TChain;
     /**
-     * Sets the recipient address.
-     *
-     * @param address - The recipient address on the destination chain.
-     * @returns An instance of Builder
+     * 0-based step index of current operation
      */
-    recipient(address: TAddress): GeneralBuilder<TApi, TRes, TSigner, T & {
-        recipient: TAddress;
+    currentStep?: number;
+};
+type TStatusChangeCallback<TApi, TRes> = (info: TSwapEvent<TApi, TRes>) => void;
+interface TSwapBuilder<TApi, TRes, TSigner> {
+    from(chain: TSubstrateChain | undefined): TSwapBuilder<TApi, TRes, TSigner>;
+    to(chain: TChain | undefined): TSwapBuilder<TApi, TRes, TSigner>;
+    exchange(chain: TExchangeInput): TSwapBuilder<TApi, TRes, TSigner>;
+    currencyFrom(currency: TCurrencyInput): TSwapBuilder<TApi, TRes, TSigner>;
+    currencyTo(currency: TCurrencyInput): TSwapBuilder<TApi, TRes, TSigner>;
+    feeAsset(currency: TCurrencyInput | undefined): TSwapBuilder<TApi, TRes, TSigner>;
+    amount(amount: TAmount): TSwapBuilder<TApi, TRes, TSigner>;
+    recipient(address: string | undefined): TSwapBuilder<TApi, TRes, TSigner>;
+    sender(address: string): TSwapBuilder<TApi, TRes, TSigner>;
+    signer(signer: TSigner): TSwapBuilder<TApi, TRes, TSigner>;
+    evmSenderAddress(address: string | undefined): TSwapBuilder<TApi, TRes, TSigner>;
+    evmSigner(signer: TSigner | undefined): TSwapBuilder<TApi, TRes, TSigner>;
+    slippagePct(pct: string): TSwapBuilder<TApi, TRes, TSigner>;
+    onStatusChange(callback: TStatusChangeCallback<TApi, TRes>): TSwapBuilder<TApi, TRes, TSigner>;
+    getXcmFees<TDisableFallback extends boolean = false>(options?: TGetXcmFeeBuilderOptions & {
+        disableFallback: TDisableFallback;
+    }): Promise<TGetXcmFeeResult<TDisableFallback>>;
+    getTransferableAmount(): Promise<bigint>;
+    getMinTransferableAmount(): Promise<bigint>;
+    getBestAmountOut(): Promise<{
+        exchange: TExchangeChain;
+        amountOut: bigint;
     }>;
+    dryRun(): Promise<TDryRunResult>;
+    build(): Promise<TTransactionContext<TApi, TRes>[]>;
+    signAndSubmit(): Promise<string[]>;
+}
+type TSwapBuilderFactory = <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>) => TSwapBuilder<TApi, TRes, TSigner>;
+
+type TPolkadotXCMTransferOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    chain: TSubstrateChain;
+    beneficiaryLocation: TLocation;
+    recipient: 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;
+    sender?: string;
+    ahAddress?: string;
+    pallet?: string;
+    method?: string;
+    transactOptions?: TTransactOptions<TRes>;
+};
+type TXTokensTransferOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    asset: WithAmount<TAssetInfo>;
+    recipient: TAddress;
+    scenario: TScenario;
+    origin: TSubstrateChain;
+    destination: TDestination;
+    paraIdTo?: number;
+    version: Version;
+    overriddenAsset?: TLocation | TAssetWithFee[];
+    pallet?: string;
+    method?: string;
+    useMultiAssetTransfer?: boolean;
+};
+interface IPolkadotXCMTransfer<TApi, TRes, TSigner> {
+    transferPolkadotXCM: (input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
+}
+interface IXTokensTransfer<TApi, TRes, TSigner> {
+    transferXTokens: (input: TXTokensTransferOptions<TApi, TRes, TSigner>) => TRes;
+}
+type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
+type TAddress = string | TLocation;
+type TDestination = TChain | TLocation;
+type TTransferBaseOptions<TApi, TRes, TSigner> = {
     /**
-     * Sets the sender address.
-     *
-     * @param sender - The sender address or signer.
-     * @returns An instance of Builder
+     * The origin chain
      */
-    sender(sender: TSender<TSigner>): GeneralBuilder<TApi, TRes, TSigner, T & {
-        sender: string;
-    }>;
+    from: TChain;
     /**
-     * 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
+     * The destination address. A SS58 or H160 format.
      */
-    ahAddress(address: string | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
-        ahAddress: string | undefined;
-    }>;
+    recipient: TAddress;
     /**
-     * Sets the XCM version to be used for the transfer.
-     *
-     * @param version - The XCM version.
-     * @returns An instance of Builder
+     * The optional sender address. A SS58 or H160 format.
      */
-    xcmVersion(version: Version): GeneralBuilder<TApi, TRes, TSigner, T & {
-        version: Version;
-    }>;
+    sender?: string;
     /**
-     * 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
+     * The optional asset hub address. A SS58 format only.
      */
-    keepAlive(keepAlive: boolean): GeneralBuilder<TApi, TRes, TSigner, T & {
-        keepAlive: boolean;
-    }>;
+    ahAddress?: string;
     /**
-     * Sets a custom pallet for the transaction.
-     *
-     * @param pallet - The name of the custom pallet to be used.
-     * @param method - The name of the method to be used.
-     * @returns An instance of the Builder.
+     * The destination chain or XCM location
      */
-    customPallet(pallet: string | undefined, method: string | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
-        pallet: string | undefined;
-        method: string | undefined;
-    }>;
+    to: TDestination;
     /**
-     * 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$1 | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
-        feeAsset: TCurrencyInput$1 | undefined;
-    }>;
-    /**
-     * 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.
-     */
-    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;
-        };
-    }>;
-    /**
-     * Performs a token swap as part of the transfer, using the specified exchange and destination currency.
-     *
-     * @param options - The swap options.
-     * @returns An instance of the Builder.
-     */
-    swap(options: TSwapOptions<TApi, TRes, TSigner>): GeneralBuilder<TApi, TRes, TSigner, T & {
-        swapOptions: TSwapOptions<TApi, TRes, TSigner>;
-    }>;
-    /**
-     * Adds the transfer transaction to the batch.
-     *
-     * @returns An instance of Builder
-     */
-    addToBatch(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner>>): GeneralBuilder<TApi, TRes, TSigner, T & {
-        from: TSubstrateChain$1;
-    }>;
-    /**
-     * 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, TSigner, TTransferBaseOptions<TApi, TRes, TSigner>>, options?: TBatchOptions): Promise<TRes>;
-    protected buildInternal<TOptions extends TTransferBaseOptions<TApi, TRes, TSigner>>(this: GeneralBuilder<TApi, TRes, TSigner, TOptions>): Promise<TBuildInternalRes<TApi, TRes, TSigner, TOptions>>;
-    private prepareNormalizedOptions;
-    /**
-     * Builds and returns the transfer extrinsic.
-     *
-     * @returns A Promise that resolves to the transfer extrinsic.
-     */
-    build(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner>>): Promise<TRes>;
-    /**
-     * Builds and returns multiple transfer or swap extrinsics
-     *
-     * @returns A Promise that resolves to the transfer extrinsic contexts
-     */
-    buildAll(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner>>): Promise<TTransactionContext<TApi, TRes>[]>;
-    private validateBatchState;
-    private buildCommon;
-    private buildCommonAll;
-    private maybePerformXcmFormatCheck;
-    dryRun(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>): Promise<TDryRunResult>;
-    dryRunPreview(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>, dryRunOptions?: TDryRunPreviewOptions): Promise<TDryRunResult>;
-    protected createTxFactory<TOptions extends TTransferBaseOptions<TApi, TRes, TSigner>>(this: GeneralBuilder<TApi, TRes, TSigner, TOptions>): TTxFactory<TRes>;
-    /**
-     * Returns the XCM fee for the transfer using dryRun or paymentInfo function.
-     *
-     * @returns An origin and destination fee.
+     * The currency to transfer. Either ID, symbol, location, or multi-asset
      */
-    getXcmFee<TDisableFallback extends boolean = false>(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>, options?: TGetXcmFeeBuilderOptions & {
-        disableFallback: TDisableFallback;
-    }): Promise<TGetXcmFeeResult<TDisableFallback>>;
+    currency: TCurrencyInputWithAmount;
     /**
-     * Returns the origin XCM fee for the transfer using dryRun or paymentInfo function.
-     *
-     * @returns An origin fee.
+     * The optional fee asset. Either ID, symbol, or location
      */
-    getOriginXcmFee(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>, { disableFallback }?: TGetXcmFeeBuilderOptions): Promise<TXcmFeeDetail & {
-        forwardedXcms?: unknown;
-        destParaId?: number;
-    }>;
+    feeAsset?: TCurrencyInput;
     /**
-     * Returns the max transferable amount for the transfer
-     *
-     * @returns The max transferable amount.
+     * The optional destination parachain ID
      */
-    getTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>): Promise<bigint>;
+    paraIdTo?: number;
     /**
-     * Returns the min transferable amount for the transfer
-     *
-     * @returns The min transferable amount.
+     * The optional overrided XCM version
      */
-    getMinTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>): Promise<bigint>;
+    version?: Version;
     /**
-     * Returns the max transferable amount for the transfer
-     *
-     * @returns The max transferable amount.
+     * The optional pallet override
      */
-    verifyEdOnDestination(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>): Promise<boolean>;
+    pallet?: string;
     /**
-     * Returns the transfer info for the transfer
-     *
-     * @returns The transfer info.
+     * Whether to keep the account alive after the transfer.
      */
-    getTransferInfo(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>): Promise<TTransferInfo>;
+    keepAlive?: boolean;
     /**
-     * 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.
+     * The optional pallet method override
      */
-    getReceivableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>): Promise<bigint>;
-    getBestAmountOut(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSwap<TApi, TRes, TSigner>>): Promise<_paraspell_swap.TGetBestAmountOutResult>;
-    signAndSubmit(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<string>;
-    signAndSubmitAll(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<string[]>;
+    method?: string;
     /**
-     * Returns the API instance used by the builder.
-     *
-     * @returns The API instance.
+     * Hex of the encoded transaction call to apply on the destination chain
      */
-    getApi(): TApi;
+    transactOptions?: TTransactOptions<TRes>;
     /**
-     * Disconnects the API.
-     *
-     * @returns A Promise that resolves when the API is disconnected.
+     * The optional swap options
      */
-    disconnect(): Promise<void>;
-}
+    swapOptions?: TSwapOptions<TApi, TRes, TSigner>;
+};
 /**
- * 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.
+ * Options for transferring from a parachain to another parachain or relay chain
  */
-declare const Builder: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>) => GeneralBuilder<TApi, TRes, TSigner, object>;
-
-type TSwapConfig = {
-    currencyTo: TCurrencyCore;
-    exchangeChain: TParachain;
+type TTransferOptions<TApi, TRes, TSigner> = WithApi<TTransferBaseOptions<TApi, TRes, TSigner>, TApi, TRes, TSigner> & {
+    isAmountAll: boolean;
 };
-type TDryRunBaseOptions<TRes> = {
-    tx: TRes;
-    origin: TSubstrateChain$1;
-    destination: TChain$1;
-    sender: string;
-    currency: TCurrencyInputWithAmount;
-    version?: Version;
-    feeAsset?: TCurrencyInput$1;
-    swapConfig?: TSwapConfig;
-    useRootOrigin?: boolean;
-    bypassOptions?: TBypassOptions;
+type TSubstrateTransferBaseOptions<TApi, TRes, TSigner> = Omit<TTransferBaseOptions<TApi, TRes, TSigner>, 'from'> & {
+    from: TSubstrateChain;
 };
-type TDryRunOptions<TApi, TRes, TSigner> = WithApi<TDryRunBaseOptions<TRes>, TApi, TRes, TSigner>;
-type TDryRunCallBaseOptions<TRes> = {
-    /**
-     * The transaction to dry-run
-     */
-    tx: TRes;
-    /**
-     * The chain to dry-run on
-     */
-    chain: TSubstrateChain$1;
-    /**
-     * The destination chain
-     */
-    destination: TDestination;
-    /**
-     * The address to dry-run with
-     */
-    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 TSubstrateTransferOptions<TApi, TRes, TSigner> = Omit<TTransferOptions<TApi, TRes, TSigner>, 'from'> & {
+    from: TSubstrateChain;
 };
-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$1;
+type WithRequiredSender<TBase> = Omit<TBase, 'sender'> & {
     /**
-     * The origin chain
+     * The sender address. A SS58 or H160 format.
      */
-    origin: TSubstrateChain$1;
-    asset: TAssetInfo;
-    version: Version;
+    sender: string;
+};
+type WithRequiredSwapOptions<TBase, TApi, TRes, TSigner> = Omit<TBase, 'swapOptions'> & {
+    swapOptions: TSwapOptions<TApi, TRes, TSigner>;
+};
+type TTransferOptionsWithSwap<TApi, TRes, TSigner> = WithRequiredSwapOptions<Omit<TSubstrateTransferOptions<TApi, TRes, TSigner>, 'isAmountAll'>, TApi, TRes, TSigner>;
+type TTransferBaseOptionsWithSwap<TApi, TRes, TSigner> = WithRequiredSwapOptions<TTransferBaseOptions<TApi, TRes, TSigner>, TApi, TRes, TSigner>;
+type TTransferBaseOptionsWithSender<TApi, TRes, TSigner> = WithRequiredSender<TTransferBaseOptions<TApi, TRes, TSigner>>;
+type TSubstrateTransferBaseOptionsWithSender<TApi, TRes, TSigner> = WithRequiredSender<TSubstrateTransferBaseOptions<TApi, TRes, TSigner>>;
+type TTransferInternalOptions<TApi, TRes, TSigner> = Omit<TTransferBaseOptions<TApi, TRes, TSigner>, 'from' | 'feeAsset' | 'version'> & {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    assetInfo: WithAmount<TAssetInfo>;
     feeAsset?: TAssetInfo;
-    amount: bigint;
-    originFee: bigint;
+    feeCurrency?: TCurrencyInput;
+    overriddenAsset?: TLocation | TAssetWithFee[];
+    version: Version;
+    isAmountAll: boolean;
 };
-type TDryRunXcmOptions<TApi, TRes, TSigner> = WithApi<TDryRunXcmBaseOptions<TRes>, TApi, TRes, TSigner>;
-type TDryRunResBase = {
-    asset: TAssetInfo;
-    isExchange?: boolean;
+type TTransactOrigin = (typeof TRANSACT_ORIGINS)[number];
+type TTransactOptions<TRes, TWeightType = bigint> = {
+    call: string | TRes;
+    originKind?: TTransactOrigin;
+    maxWeight?: TWeight<TWeightType>;
 };
-type TDryRunChainSuccess = TDryRunResBase & {
-    success: true;
-    fee: bigint;
-    weight?: TWeight;
-    forwardedXcms: any;
-    destParaId?: number;
+type TSerializedExtrinsics = {
+    module: TPallet;
+    method: string;
+    params: Record<string, unknown>;
 };
-type TDryRunChainFailure = TDryRunResBase & {
-    success: false;
-    failureReason: string;
-    failureSubReason?: string;
+type TSerializedStateQuery = {
+    module: TAssetsPallet;
+    method: string;
+    params: unknown[];
 };
-type TDryRunChainResult = TDryRunChainSuccess | TDryRunChainFailure;
-type THopInfo = {
-    chain: TChain$1;
-    result: TDryRunChainResult;
+type TSerializedRuntimeApiQuery = {
+    module: string;
+    method: string;
+    params: unknown[];
 };
-type TChainEndpoint = 'origin' | 'destination' | TChain$1;
-type TDryRunResult = {
-    failureReason?: string;
-    failureSubReason?: string;
-    failureChain?: TChainEndpoint;
-    origin: TDryRunChainResult;
-    destination?: TDryRunChainResult;
-    hops: THopInfo[];
+type TDestWeight = {
+    ref_time: bigint;
+    proof_size: bigint;
 };
-type TResolveHopParams<TApi, TRes, TSigner> = {
+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 TCreateBeneficiaryOptions<TApi, TRes, TSigner> = {
     api: PolkadotApi<TApi, TRes, TSigner>;
-    tx: TRes;
-    originChain: TSubstrateChain$1;
-    currentChain: TSubstrateChain$1;
+    address: TAddress;
+    version: Version;
+};
+type TCreateBeneficiaryXTokensOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
     destination: TDestination;
-    asset: TAssetInfo;
-    currency: TCurrencyInputWithAmount;
-    swapConfig?: TSwapConfig;
-    hasPassedExchange: boolean;
+    recipient: TAddress;
+    version: Version;
+    paraId?: number;
 };
-type HopProcessParams<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    currentChain: TSubstrateChain$1;
-    currentOrigin: TSubstrateChain$1;
-    currentAsset: TAssetInfo;
-    forwardedXcms: any;
-    hasPassedExchange: boolean;
-    isDestination: boolean;
+type TBridgeStatus = 'Normal' | 'Halted';
+type TTransferLocalOptions<TApi, TRes, TSigner> = Omit<TTransferInternalOptions<TApi, TRes, TSigner>, 'recipient'> & {
+    recipient: string;
+    balance: bigint;
 };
-type HopTraversalConfig<TApi, TRes, TSigner, THopResult> = {
+type TTransferFeeEstimates = {
+    originFee: bigint;
+    reserveFee: bigint;
+};
+type TCreateBaseTransferXcmOptions<TRes> = {
+    chain: TSubstrateChain;
+    destChain: TChain;
+    assetInfo: WithAmount<TAssetInfo>;
+    feeAssetInfo?: TAssetInfo;
+    fees: TTransferFeeEstimates;
+    recipient: string;
+    sender?: string;
+    version: Version;
+    useJitWithdraw?: boolean;
+    useFeeAssetOnHops?: boolean;
+    paraIdTo?: number;
+    transactOptions?: TTransactOptions<TRes>;
+};
+type TCreateTransferXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseTransferXcmOptions<TRes>, TApi, TRes, TSigner>;
+type TCreateBaseSwapXcmOptions = {
+    chain?: TSubstrateChain;
+    exchangeChain: TExchangeChain;
+    destChain?: TChain;
+    assetInfoFrom: WithAmount<TAssetInfo>;
+    assetInfoTo: WithAmount<TAssetInfo>;
+    currencyTo: TCurrencyInput;
+    feeAssetInfo?: TAssetInfo;
+    sender: string;
+    recipient: string;
+    calculateMinAmountOut: (amountIn: bigint, assetTo?: TAssetInfo) => Promise<bigint>;
+};
+type TCreateSwapXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner>;
+type TSwapFeeEstimates = {
+    originFee: bigint;
+    originReserveFee: bigint;
+    exchangeFee: bigint;
+    destReserveFee: bigint;
+};
+type TCreateSwapXcmInternalOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner> & {
+    version: Version;
+    fees: TSwapFeeEstimates;
+    paraIdTo?: number;
+};
+type TCreateEthBridgeInstructionsOptions<TApi, TRes, TSigner> = {
     api: PolkadotApi<TApi, TRes, TSigner>;
-    origin: TSubstrateChain$1;
-    destination: TChain$1;
-    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;
-    };
+    recipient: TAddress;
+    assetInfo: TAssetInfo;
+    sender: string;
+    ahAddress?: string;
+    version: Version;
 };
-type HopTraversalResult<THopResult> = {
-    hops: Array<{
-        chain: TSubstrateChain$1;
-        result: THopResult;
-    }>;
-    destination?: THopResult;
-    lastProcessedChain?: TSubstrateChain$1;
+
+/** @deprecated Asset claim functionality is deprecated and will be removed in v14. */
+type TAssetClaimOptionsBase = {
+    chain: TSubstrateChain;
+    currency: WithComplexAmount<TCurrencyCore> | TAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
+    address: TAddress;
+    version?: Version;
 };
-type TBypassOptions = {
-    mintFeeAssets?: boolean;
-    sentAssetMintMode?: 'preview' | 'bypass';
+type TAssetClaimOptions<TApi, TRes, TSigner> = WithApi<TAssetClaimOptionsBase, TApi, TRes, TSigner>;
+type TAssetClaimInternalOptions<TApi, TRes, TSigner> = TAssetClaimOptions<TApi, TRes, TSigner> & {
+    version: Version;
+    assets: TAsset<bigint>[];
 };
-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"
+
+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: PolkadotApi<TApi, TRes, TSigner>): Promise<TSetBalanceRes>;
+    abstract getBalance<TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo, customCurrencyId?: unknown): Promise<bigint>;
 }
-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"
+
+/**
+ * Builder class for constructing asset claim transactions.
+ *
+ * @deprecated Asset claim functionality is deprecated and will be removed in v14.
+ */
+declare class AssetClaimBuilder<TApi, TRes, TSigner, T extends Partial<TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>> = object> {
+    readonly api: PolkadotApi<TApi, TRes, TSigner>;
+    readonly _options: T;
+    constructor(api: PolkadotApi<TApi, TRes, TSigner>, 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, TSigner, T & {
+        currency: TAssetClaimOptionsBase['currency'];
+    }>;
+    /**
+     * Sets the sender address.
+     *
+     * @param address - The sender address.
+     * @returns
+     */
+    sender(sender: TSender<TSigner>): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        sender: 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, 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 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"
+
+declare class BatchTransactionManager<TApi, TRes, TSigner> {
+    transactionOptions: TBatchedTransferOptions<TApi, TRes, TSigner>[];
+    addTransaction(options: TBatchedTransferOptions<TApi, TRes, TSigner>): void;
+    isEmpty(): boolean;
+    buildBatch(api: PolkadotApi<TApi, TRes, TSigner>, from: TSubstrateChain, options?: TBatchOptions): Promise<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> = {
+/**
+ * A builder class for constructing Para-to-Para, Para-to-Relay, Relay-to-Para transactions and asset claims.
+ */
+declare class GeneralBuilder<TApi, TRes, TSigner, T extends Partial<TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>> = object> {
+    readonly batchManager: BatchTransactionManager<TApi, TRes, TSigner>;
+    readonly api: PolkadotApi<TApi, TRes, TSigner>;
+    readonly _options: T;
+    constructor(api: PolkadotApi<TApi, TRes, TSigner>, batchManager: BatchTransactionManager<TApi, TRes, TSigner>, 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: TChain): GeneralBuilder<TApi, TRes, TSigner, T & {
+        from: TChain;
+    }>;
+    /**
+     * 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, TSigner, T & {
+        to: TDestination;
+    }>;
+    /**
+     * Initiates the process to claim assets from a specified chain.
+     *
+     * @deprecated Asset claim functionality is deprecated and will be removed in v14.
+     * @param chain - The chain from which to claim assets.
+     * @returns An instance of Builder
+     */
+    claimFrom(chain: TSubstrateChain): AssetClaimBuilder<TApi, TRes, TSigner, {
+        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, TSigner, T & {
+        currency: TCurrencyInputWithAmount;
+    }>;
+    /**
+     * Sets the recipient address.
+     *
+     * @param address - The recipient address on the destination chain.
+     * @returns An instance of Builder
+     */
+    recipient(address: TAddress): GeneralBuilder<TApi, TRes, TSigner, T & {
+        recipient: TAddress;
+    }>;
+    /**
+     * Sets the sender address or signer.
+     *
+     * @param sender - The sender address, substrate signer, or viem `WalletClient`.
+     * @returns An instance of Builder
+     */
+    sender(sender: TSender<TSigner> | WalletClient): GeneralBuilder<TApi, TRes, TSigner, T & {
+        sender: 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, 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
+     */
+    xcmVersion(version: Version): GeneralBuilder<TApi, TRes, TSigner, T & {
+        version: Version;
+    }>;
+    /**
+     * 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
+     */
+    keepAlive(keepAlive: boolean): GeneralBuilder<TApi, TRes, TSigner, T & {
+        keepAlive: boolean;
+    }>;
+    /**
+     * Sets a custom pallet for the transaction.
+     *
+     * @param pallet - The name of the custom pallet to be used.
+     * @param method - The name of the method to be used.
+     * @returns An instance of the Builder.
+     */
+    customPallet(pallet: string | undefined, method: string | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
+        pallet: string | undefined;
+        method: string | undefined;
+    }>;
+    /**
+     * 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, TSigner, T & {
+        feeAsset: TCurrencyInput | undefined;
+    }>;
     /**
-     * The transaction factory
+     * 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.
      */
-    buildTx: TTxFactory<TRes>;
+    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 origin chain
+     * Performs a token swap as part of the transfer, using the specified exchange and destination currency.
+     *
+     * @param options - The swap options.
+     * @returns An instance of the Builder.
      */
-    origin: TSubstrateChain$1;
+    swap(options: TSwapOptions<TApi, TRes, TSigner>): GeneralBuilder<TApi, TRes, TSigner, T & {
+        swapOptions: TSwapOptions<TApi, TRes, TSigner>;
+    }>;
     /**
-     * The destination chain
+     * Adds the transfer transaction to the batch.
+     *
+     * @returns An instance of Builder
      */
-    destination: TChain$1;
+    addToBatch(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): GeneralBuilder<TApi, TRes, TSigner, T & {
+        from: TSubstrateChain;
+    }>;
     /**
-     * The sender address
+     * 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.
      */
-    sender: string;
-    recipient: string;
-    currency: WithAmount<TCurrencyCore>;
-    version?: Version;
-    feeAsset?: TCurrencyInput$1;
-    disableFallback: TDisableFallback;
-    swapConfig?: TXcmFeeSwapConfig;
-    skipReverseFeeCalculation?: boolean;
-};
-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 TGetXcmFeeBuilderOptions = {
-    disableFallback: boolean;
-};
-type TGetOriginXcmFeeBaseOptions<TRes> = {
-    buildTx: TTxFactory<TRes>;
-    origin: TSubstrateChain$1;
-    destination: TChain$1;
-    sender: string;
-    currency: WithAmount<TCurrencyCore>;
-    version?: Version;
-    feeAsset?: TCurrencyInput$1;
-    disableFallback: boolean;
-    useRootOrigin?: boolean;
-};
-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 TGetFeeForDestChainBaseOptions<TRes> = {
-    prevChain: TSubstrateChain$1;
-    origin: TSubstrateChain$1;
-    destination: TChain$1;
-    sender: string;
-    recipient: string;
-    currency: WithAmount<TCurrencyCore>;
-    forwardedXcms: any;
-    tx: TRes;
-    asset: TAssetInfo;
-    version: Version;
-    originFee: bigint;
-    feeAsset?: TCurrencyInput$1;
-    disableFallback: boolean;
-    hasPassedExchange?: boolean;
-    swapConfig?: TXcmFeeSwapConfig;
-    skipReverseFeeCalculation?: boolean;
-};
-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$1;
-};
-type TFeeType = 'dryRun' | 'paymentInfo' | 'noFeeRequired';
-type TXcmFeeBase$1 = {
-    asset: TAssetInfo;
-    weight?: TWeight;
-    sufficient?: boolean;
-    isExchange?: boolean;
-};
-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$1;
-    result: TConditionalXcmFeeDetail<TDisableFallback>;
-};
-type TXcmFeeHopInfo = {
-    chain: TChain$1;
-    result: TXcmFeeDetail;
-};
-type TGetXcmFeeResult<TDisableFallback extends boolean = boolean> = {
-    failureReason?: string;
-    failureChain?: TChainEndpoint;
-    origin: TConditionalXcmFeeDetail<TDisableFallback>;
-    destination: TConditionalXcmFeeDetail<TDisableFallback>;
-    hops: TConditionalXcmFeeHopInfo<TDisableFallback>[];
-};
-type TPaymentInfo = {
-    partialFee: bigint;
-    weight: TWeight;
-};
+    buildBatch(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, options?: TBatchOptions): Promise<TRes>;
+    protected buildInternal<TOptions extends TTransferBaseOptions<TApi, TRes, TSigner>>(this: GeneralBuilder<TApi, TRes, TSigner, TOptions>): Promise<TBuildInternalRes<TApi, TRes, TSigner, TOptions>>;
+    private prepareNormalizedOptions;
+    /**
+     * Builds and returns the transfer extrinsic.
+     *
+     * @returns A Promise that resolves to the transfer extrinsic.
+     */
+    build(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<TRes>;
+    /**
+     * Builds and returns multiple transfer or swap extrinsics
+     *
+     * @returns A Promise that resolves to the transfer extrinsic contexts
+     */
+    buildAll(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<TTransactionContext<TApi, TRes>[]>;
+    private validateBatchState;
+    private buildCommon;
+    private buildCommonAll;
+    private maybePerformXcmFormatCheck;
+    dryRun(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<TDryRunResult>;
+    dryRunPreview(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, dryRunOptions?: TDryRunPreviewOptions): Promise<TDryRunResult>;
+    protected createTxFactory<TOptions extends TTransferBaseOptions<TApi, TRes, TSigner>>(this: GeneralBuilder<TApi, TRes, TSigner, 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, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, 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, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, { disableFallback }?: TGetXcmFeeBuilderOptions): Promise<TXcmFeeDetail & {
+        forwardedXcms?: unknown;
+        destParaId?: number;
+    }>;
+    /**
+     * Returns the max transferable amount for the transfer
+     *
+     * @returns The max transferable amount.
+     */
+    getTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<bigint>;
+    /**
+     * Returns the min transferable amount for the transfer
+     *
+     * @returns The min transferable amount.
+     */
+    getMinTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<bigint>;
+    /**
+     * Returns the max transferable amount for the transfer
+     *
+     * @returns The max transferable amount.
+     */
+    verifyEdOnDestination(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<boolean>;
+    /**
+     * Returns the transfer info for the transfer
+     *
+     * @returns The transfer info.
+     */
+    getTransferInfo(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): 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, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<bigint>;
+    getBestAmountOut(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSwap<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<{
+        exchange: TExchangeChain;
+        amountOut: bigint;
+    }>;
+    signAndSubmit(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<string>;
+    signAndSubmitAll(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<string[]>;
+    private executeWithEvmSigner;
+    /**
+     * 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>;
+}
+/**
+ * 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, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>) => GeneralBuilder<TApi, TRes, TSigner, object>;
 
 type TGetBalanceCommonOptions = {
     /**
@@ -1619,7 +1658,7 @@ type TGetBalanceCommonOptions = {
     /**
      * The chain on which to query the balance.
      */
-    chain: TChain$1;
+    chain: TChain;
 };
 /**
  * Retrieves the asset balance for a given account on a specified chain.
@@ -1649,18 +1688,18 @@ type TGetTransferableAmountOptionsBase<TRes> = {
     /**
      * The chain on which to query the balance.
      */
-    origin: TSubstrateChain$1;
+    origin: TSubstrateChain;
     /**
      * The destination chain.
      */
-    destination: TChain$1;
+    destination: TChain;
     /**
      * The currency to query.
      */
     currency: WithAmount<TCurrencyCore>;
     version: Version | undefined;
     buildTx: TTxFactory<TRes>;
-    feeAsset?: TCurrencyInput$1;
+    feeAsset?: TCurrencyInput;
 };
 type TGetTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes>, TApi, TRes, TSigner>;
 type TGetMinTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes> & {
@@ -1671,11 +1710,11 @@ type TVerifyEdOnDestinationOptionsBase<TRes> = {
     /**
      * The origin chain.
      */
-    origin: TSubstrateChain$1;
+    origin: TSubstrateChain;
     /**
      * The destination chain.
      */
-    destination: TChain$1;
+    destination: TChain;
     /**
      * The address of the account.
      */
@@ -1690,51 +1729,19 @@ type TVerifyEdOnDestinationOptionsBase<TRes> = {
     currency: WithAmount<TCurrencyCore>;
     version: Version | undefined;
     buildTx: TTxFactory<TRes>;
-    feeAsset?: TCurrencyInput$1;
+    feeAsset?: TCurrencyInput;
 };
 type TVerifyEdOnDestinationOptions<TApi, TRes, TSigner> = WithApi<TVerifyEdOnDestinationOptionsBase<TRes>, TApi, TRes, TSigner>;
 
-type TEvmChainFrom = Extract<TChain$1, '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$1;
-    /**
-     * The currency to transfer. Symbol or ID.
-     */
+type TEvmTransferOptionsBase = {
+    from: TChain;
+    to: TChain;
     currency: TCurrencyInputWithAmount;
-    /**
-     * The Polkadot destination address.
-     */
     recipient: 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;
-};
+type TEvmTransferOptions<TApi, TRes, TSigner> = WithApi<TEvmTransferOptionsBase, TApi, TRes, TSigner>;
 /**
  * The options for the batch builder.
  */
@@ -1764,14 +1771,14 @@ type TDryRunPreviewOptions = {
 };
 type TBuilderOptions<TApi> = TApi | TBuilderConfig<TApi>;
 type TBuilderConfig<TApi> = Partial<{
-    apiOverrides: Partial<Record<TChain$1, TApi>>;
+    apiOverrides: Partial<Record<TChain, TApi>>;
     development: boolean;
     abstractDecimals: boolean;
     xcmFormatCheck: boolean;
 }>;
 type TCreateTxsOptions<TApi, TRes, TSigner> = Pick<TTransferOptions<TApi, TRes, TSigner>, 'api' | 'from' | 'to' | 'currency'>;
-type TBatchedTransferOptions<TApi, TRes, TSigner> = Omit<TTransferOptions<TApi, TRes, TSigner>, 'isAmountAll'> & {
-    builder: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner>>;
+type TBatchedTransferOptions<TApi, TRes, TSigner> = Omit<TSubstrateTransferOptions<TApi, TRes, TSigner>, 'isAmountAll'> & {
+    builder: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>;
 };
 type TBuildInternalResBase<TApi, TRes, TSigner, TOptions extends TTransferBaseOptions<TApi, TRes, TSigner> = TTransferBaseOptions<TApi, TRes, TSigner>> = {
     options: TTransferOptions<TApi, TRes, TSigner> & TOptions;
@@ -1784,7 +1791,7 @@ type TBuildAllInternalRes<TApi, TRes, TSigner, TOptions extends TTransferBaseOpt
 };
 type TSender<TSigner> = string | TSigner;
 type TBuilderInternalOptions<TSigner> = {
-    senderSource?: TSender<TSigner>;
+    senderSource?: TSender<TSigner> | WalletClient;
 };
 
 type TProviderEntry = {
@@ -1797,7 +1804,7 @@ type TChainConfig = {
     paraId: number;
     providers: TProviderEntry[];
 };
-type TChainConfigMap = Record<TSubstrateChain$1, TChainConfig>;
+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 ? {
@@ -1930,7 +1937,7 @@ declare class MissingChainApiError extends Error {
      *
      * @param chain - The chain for which the API is missing.
      */
-    constructor(chain: TChain$1);
+    constructor(chain: TChain);
 }
 
 /**
@@ -1949,7 +1956,7 @@ declare class NoXCMSupportImplementedError extends Error {
      *
      * @param chain - The chain for which XCM support is not implemented.
      */
-    constructor(chain: TChain$1);
+    constructor(chain: TChain);
 }
 
 /**
@@ -1995,7 +2002,7 @@ declare class RuntimeApiUnavailableError extends Error {
 }
 
 type TScenarioNotSupportedContext = {
-    chain: TChain$1;
+    chain: TChain;
     scenario: TScenario;
 };
 /**
@@ -2053,7 +2060,7 @@ declare class ValidationError extends Error {
 }
 
 type THopTransferInfo = {
-    chain: TChain$1;
+    chain: TChain;
     result: {
         xcmFee: TXcmFeeBase;
         asset: TAssetInfo;
@@ -2065,8 +2072,8 @@ type TXcmFeeBase = {
 };
 type TTransferInfo = {
     chain: {
-        origin: TChain$1;
-        destination: TChain$1;
+        origin: TChain;
+        destination: TChain;
         ecosystem: string;
     };
     origin: {
@@ -2098,9 +2105,9 @@ type TTransferInfo = {
 };
 type BuildHopInfoOptions<TApi, TRes, TSigner> = {
     api: PolkadotApi<TApi, TRes, TSigner>;
-    chain: TSubstrateChain$1;
+    chain: TSubstrateChain;
     fee: bigint;
-    originChain: TSubstrateChain$1;
+    originChain: TSubstrateChain;
     currency: TCurrencyCore;
     asset: TAssetInfo;
     sender: string;
@@ -2108,8 +2115,8 @@ type BuildHopInfoOptions<TApi, TRes, TSigner> = {
 };
 type TBuildDestInfoOptions<TApi, TRes, TSigner> = {
     api: PolkadotApi<TApi, TRes, TSigner>;
-    origin: TSubstrateChain$1;
-    destination: TChain$1;
+    origin: TSubstrateChain;
+    destination: TChain;
     recipient: string;
     currency: WithAmount<TCurrencyCore>;
     originFee: bigint;
@@ -2124,8 +2131,8 @@ type TOriginFeeDetails = {
 };
 type TGetTransferInfoOptionsBase<TRes> = {
     buildTx: TTxFactory<TRes>;
-    origin: TSubstrateChain$1;
-    destination: TChain$1;
+    origin: TSubstrateChain;
+    destination: TChain;
     sender: string;
     ahAddress?: string;
     recipient: string;
@@ -2135,14 +2142,14 @@ type TGetTransferInfoOptionsBase<TRes> = {
 };
 type TGetTransferInfoOptions<TApi, TRes, TSigner> = WithApi<TGetTransferInfoOptionsBase<TRes>, TApi, TRes, TSigner>;
 
-type TChainWithApi<TApi, TRes, TSigner, T = TSubstrateChain$1> = {
+type TChainWithApi<TApi, TRes, TSigner, T = TSubstrateChain> = {
     api: PolkadotApi<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$1>;
+    reserve: TChainWithApi<TApi, TRes, TSigner, TChain>;
     isSubBridge: boolean;
     isSnowbridge: boolean;
     isRelayAsset: boolean;
@@ -2155,7 +2162,7 @@ type TTypeAndThenFees = {
     destFee: bigint;
 };
 type TTypeAndThenOverrides = {
-    reserveChain?: TSubstrateChain$1;
+    reserveChain?: TSubstrateChain;
     noFeeAsset?: boolean;
 };
 
@@ -2165,15 +2172,13 @@ declare const createClientPoolHelpers: <TClient>(clientPool: ClientCache<TClient
     releaseClient: (ws: TUrl) => void;
 };
 
-declare const resolveChainApi: <TApi>(config: TBuilderOptions<TApiOrUrl<TApi>> | undefined, chain: TSubstrateChain$1, createApiInstance: (wsUrl: TUrl) => Promise<TApi>) => Promise<TApi>;
-
 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 blake2b256: (msg: Uint8Array) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+declare const blake2b512: (msg: Uint8Array) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
 declare const deriveAccountId: (raw: Uint8Array) => Uint8Array;
 declare const encodeSs58: (payload: Uint8Array, network: number) => string;
-declare const convertSs58: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: string, chain: TSubstrateChain$1) => string;
+declare const convertSs58: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: string, chain: TSubstrateChain) => string;
 
 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>;
@@ -2181,11 +2186,11 @@ declare const getBalance: <TApi, TRes, TSigner>(options: TGetBalanceOptions<TApi
 
 declare const getEthErc20Balance: (chain: TExternalChain, asset: TAssetInfo, address: string) => Promise<bigint>;
 
-declare const getMoonbeamErc20Balance: (chain: TSubstrateChain$1, assetId: string, address: string) => Promise<bigint>;
+declare const getMoonbeamErc20Balance: (chain: TSubstrateChain, assetId: string, address: string) => Promise<bigint>;
 
-declare const getChainConfig: (chain: TSubstrateChain$1) => TChainConfig;
+declare const getChainConfig: (chain: TSubstrateChain) => TChainConfig;
 
-declare const getChainProviders: (chain: TSubstrateChain$1) => string[];
+declare const getChainProviders: (chain: TSubstrateChain) => string[];
 
 /**
  * Retrieves the parachain ID for a specified chain.
@@ -2193,7 +2198,7 @@ declare const getChainProviders: (chain: TSubstrateChain$1) => string[];
  * @param chain - The chain for which to get the paraId.
  * @returns The parachain ID of the chain.
  */
-declare const getParaId: (chain: TChain$1) => number;
+declare const getParaId: (chain: TChain) => number;
 
 /**
  * Retrieves the chain name corresponding to a specified parachain ID.
@@ -2201,14 +2206,32 @@ declare const getParaId: (chain: TChain$1) => number;
  * @param paraId - The parachain ID.
  * @returns The chain name if found; otherwise, null.
  */
-declare const getTChain: (paraId: number, ecosystem: TRelaychain | TExternalChain) => TChain$1 | null;
+declare const getTChain: (paraId: number, ecosystem: TRelaychain | TExternalChain) => TChain | null;
+
+interface TEvmExtension {
+    executeEvmTransfer: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
+}
+declare const registerEvmExtension: (extension: TEvmExtension | undefined) => void;
+declare const getEvmExtensionOrThrow: () => TEvmExtension;
+
+interface TEvmSnowbridgeExtension {
+    executeEvmSnowbridgeTransfer: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
+}
+declare const registerEvmSnowbridgeExtension: (extension: TEvmSnowbridgeExtension | undefined) => void;
+declare const getEvmSnowbridgeExtensionOrThrow: () => TEvmSnowbridgeExtension;
+
+interface TSwapExtension {
+    SwapBuilder: TSwapBuilderFactory;
+}
+declare const registerSwapExtension: (extension: TSwapExtension | undefined) => void;
+declare const getSwapExtensionOrThrow: () => TSwapExtension;
 
 /**
  * @deprecated Asset claim functionality is deprecated and will be removed in v14.
  */
 declare const claimAssets: <TApi, TRes, TSigner>(options: TAssetClaimOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 
-declare const resolveTransferParams: <TApi, TRes, TSigner>(options: TTransferOptions<TApi, TRes, TSigner>) => {
+declare const resolveTransferParams: <TApi, TRes, TSigner>(options: TSubstrateTransferOptions<TApi, TRes, TSigner>) => {
     resolvedFeeAsset: TAssetInfo | undefined;
     resolvedVersion: _paraspell_sdk_common.Version;
     overriddenAsset: _paraspell_sdk_common.TLocation | _paraspell_assets.TAssetWithFee[] | undefined;
@@ -2224,7 +2247,7 @@ declare const resolveTransferParams: <TApi, TRes, TSigner>(options: TTransferOpt
         alias?: string;
     };
 };
-declare const createTransfer: <TApi, TRes, TSigner>(options: TTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
+declare const createTransfer: <TApi, TRes, TSigner>(options: TSubstrateTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 
 declare const dryRun: <TApi, TRes, TSigner>(options: TDryRunOptions<TApi, TRes, TSigner>) => Promise<TDryRunResult>;
 
@@ -2237,16 +2260,16 @@ declare const getFailureInfo: (result: TDryRunResult) => Pick<TDryRunResult, "fa
 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: PolkadotApi<TApi, TRes, TSigner>, bridgeHubResult: TResult | undefined, destination: TChain$1, assetHubChain: TSubstrateChain$1) => Promise<TResult | undefined>;
+}>(api: PolkadotApi<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, TSigner>(dryRunOptions: TDryRunBypassOptions<TApi, TRes, TSigner>, options?: TBypassOptions) => Promise<TRes>;
 
 declare const getParaEthTransferFees: <TApi, TRes, TSigner>(ahApi: PolkadotApi<TApi, TRes, TSigner>, shouldDisconnect?: boolean) => Promise<[bigint, bigint]>;
 
-declare const transferMoonbeamEvm: <TApi, TRes, TSigner>(options: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<string>;
+declare const transferMoonbeamEvm: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
 
-declare const transferMoonbeamToEth: <TApi, TRes, TSigner>(from: TSubstrateChain$1, { api, to, signer, recipient, ahAddress, currency }: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<`0x${string}`>;
+declare const transferMoonbeamToEth: <TApi, TRes, TSigner>(from: TSubstrateChain, { api, to, signer, recipient, ahAddress, currency }: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<`0x${string}`>;
 
 declare const getOriginXcmFee: <TApi, TRes, TSigner>(options: TGetOriginXcmFeeOptions<TApi, TRes, TSigner>) => Promise<TXcmFeeDetail & {
     forwardedXcms?: unknown;
@@ -2285,18 +2308,18 @@ declare const createTypeAndThenCall: <TApi, TRes, TSigner>(options: TPolkadotXCM
  * 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, TSigner>(chain: TSubstrateChain$1, options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TSerializedExtrinsics>;
+declare const createTypeThenAutoReserve: <TApi, TRes, TSigner>(chain: TSubstrateChain, options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>) => Promise<TSerializedExtrinsics>;
 
-declare const validateCurrency: (currency: TCurrencyInput$1, feeAsset?: TCurrencyInput$1) => void;
-declare const validateDestination: (origin: TSubstrateChain$1, destination: TDestination) => void;
-declare const validateAssetSpecifiers: (assetCheckEnabled: boolean, currency: TCurrencyInput$1) => void;
-declare const validateTransact: <TApi, TRes, TSigner>({ api, from, to, sender, recipient: address, transactOptions }: TTransferOptions<TApi, TRes, TSigner>) => ValidationError | undefined;
+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, sender, recipient: address, transactOptions }: TSubstrateTransferOptions<TApi, TRes, TSigner>) => ValidationError | undefined;
 
 declare const verifyEdOnDestination: <TApi, TRes, TSigner>(options: TVerifyEdOnDestinationOptions<TApi, TRes, TSigner>) => Promise<boolean>;
 
 declare const compareAddresses: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, addr1: string, addr2: string) => boolean;
 
-declare const validateAddress: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: TAddress, chain: TChain$1, isDestination?: boolean) => void;
+declare const validateAddress: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: TAddress, chain: TChain, isDestination?: boolean) => void;
 
 declare const validateDestinationAddress: <TApi, TRes, TSigner>(address: TAddress, destination: TDestination, api: PolkadotApi<TApi, TRes, TSigner>) => void;
 
@@ -2307,6 +2330,9 @@ declare const assertHasId: (asset: TAssetInfo) => asserts asset is TAssetInfoWit
 declare const assertSenderSource: <TSigner>(sender?: TSender<TSigner>) => asserts sender is TSender<TSigner>;
 declare const isSenderSigner: <TSigner>(sender: TSender<TSigner>) => sender is TSigner;
 declare const assertSwapSupport: <TApi, TRes, TSigner>(options: TSwapOptions<TApi, TRes, TSigner> | undefined) => void;
+declare const assertSubstrateOrigin: (chain: TChain) => asserts chain is TSubstrateChain;
+declare const assertNotEvmTransfer: <TSigner>(from: TChain, senderSource?: TSender<TSigner> | WalletClient) => asserts from is TSubstrateChain;
+declare const assertExtensionInstalled: <T>(extension: T | undefined, extensionName: string, packageName: string, usage: string) => asserts extension is T;
 
 declare const createAssetId: (version: Version, location: TLocation) => TLocation | {
     Concrete: TLocation;
@@ -2324,14 +2350,12 @@ declare const sortAssets: (assets: TAsset[]) => TAsset[];
 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, TTransferBaseOptions<TApi, TRes, TSigner>>, amount: string, relative?: boolean) => Promise<TRes>;
 declare const createTxOverrideAmount: <TApi, TRes, TSigner>(options: TCreateTxsOptions<TApi, TRes, TSigner>, builder: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner>>, amount?: string, relative?: boolean) => Promise<TRes>;
-declare const createTransferOrSwapAll: <TApi, TRes, TSigner>(options: TTransferOptions<TApi, TRes, TSigner>) => Promise<TTransactionContext<TApi, TRes>[]>;
-declare const createTransferOrSwap: <TApi, TRes, TSigner>(options: TTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
-
-declare const isConfig: <TApi>(value: any) => value is TBuilderConfig<TApi>;
+declare const createTransferOrSwapAll: <TApi, TRes, TSigner>(options: TSubstrateTransferOptions<TApi, TRes, TSigner>) => Promise<TTransactionContext<TApi, TRes>[]>;
+declare const createTransferOrSwap: <TApi, TRes, TSigner>(options: TSubstrateTransferOptions<TApi, TRes, TSigner>) => Promise<TRes>;
 
-declare const getAssetReserveChain: (chain: TSubstrateChain$1, assetLocation: TLocation) => TSubstrateChain$1;
+declare const getAssetReserveChain: (chain: TSubstrateChain, assetLocation: TLocation) => TSubstrateChain;
 
-declare const getChainVersion: <TApi, TRes, TSigner>(chain: TChain$1) => Version;
+declare const getChainVersion: <TApi, TRes, TSigner>(chain: TChain) => Version;
 
 /**
  * Gets the relay chain (Polkadot, Kusama, Westend, or Paseo) of a given chain.
@@ -2339,13 +2363,20 @@ declare const getChainVersion: <TApi, TRes, TSigner>(chain: TChain$1) => Version
  * @param chain - The chain to evaluate.
  * @returns The corresponding relay chain.
  */
-declare const getRelayChainOf: (chain: TSubstrateChain$1) => TRelaychain;
+declare const getRelayChainOf: (chain: TSubstrateChain) => TRelaychain;
+
+declare const createChainClient: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, chain: TSubstrateChain) => Promise<TApi>;
 
-declare const createChainClient: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, chain: TSubstrateChain$1) => Promise<TApi>;
+declare const resolveModuleError: (chain: TSubstrateChain, error: TModuleError) => TDryRunError;
 
-declare const resolveModuleError: (chain: TSubstrateChain$1, error: TModuleError) => TDryRunError;
+declare const createEthereumBridgeInstructions: <TApi, TRes, TSigner>({ api, sender, recipient, assetInfo, ahAddress, version }: TCreateEthBridgeInstructionsOptions<TApi, TRes, TSigner>, origin: TSubstrateChain, messageId: string, ethAsset: TAssetInfo) => unknown[];
+declare const createCustomXcmOnDest: <TApi, TRes, TSigner>(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, origin: TSubstrateChain, messageId: string, ethAsset: TAssetInfo) => {
+    [x: string]: unknown[];
+};
+
+declare const generateMessageId: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, senderAddress: string, sourceParaId: number, tokenAddress: string, recipient: string, amount: TAmount) => Promise<string>;
 
-declare const padFee: (raw: bigint, origin: TSubstrateChain$1, dest: TChain$1, side: "origin" | "destination") => bigint;
+declare const padFee: (raw: bigint, origin: TSubstrateChain, dest: TChain, side: "origin" | "destination") => bigint;
 declare const padValueBy: (amount: bigint, percent: number) => bigint;
 
 /**
@@ -2358,15 +2389,19 @@ declare const getChain: <TApi, TRes, TSigner, T extends keyof ReturnType<typeof
 
 declare const getEvmPrivateKeyHex: (path: string) => "0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133" | "0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b" | "0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b" | "0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68" | "0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4" | "0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df" | undefined;
 
+declare const isConfig: <TApi>(value: any) => value is TBuilderConfig<TApi>;
+
+declare const isViemSigner: (value: unknown) => value is WalletClient;
+
 declare const createBeneficiaryLocXTokens: <TApi, TRes, TSigner>({ api, recipient, 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$1, destination: TDestination, chainId?: number, junction?: TJunction, parents?: Parents) => TLocation;
-declare const createVersionedDestination: (version: Version, origin: TSubstrateChain$1, destination: TDestination, chainId?: number, junction?: TJunction, parents?: Parents) => TXcmVersioned<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>;
 
 declare const createX1Payload: (version: Version, junction: TJunction) => TJunctions;
 
-declare const getChainLocation: (chain: TChain$1, destChain: TChain$1) => TLocation;
+declare const getChainLocation: (chain: TChain, destChain: TChain) => TLocation;
 
 /**
  * This function localizes a location by removing the `Parachain` junction
@@ -2377,49 +2412,23 @@ declare const getChainLocation: (chain: TChain$1, destChain: TChain$1) => TLocat
  * @param location - The location to localize
  * @returns The localized location
  */
-declare const localizeLocation: (chain: TChain$1, location: TLocation, origin?: TChain$1) => TLocation;
+declare const localizeLocation: (chain: TChain, location: TLocation, origin?: TChain) => TLocation;
 
 declare const reverseTransformLocation: (location: TLocation) => TLocation;
 
 declare const normalizeAmount: (amount: bigint) => bigint;
 
-declare const resolveDestChain: (originChain: TSubstrateChain$1, paraId: number | undefined) => "AssetHubPolkadot" | "Acala" | "Ajuna" | "Astar" | "BifrostPolkadot" | "BridgeHubPolkadot" | "Centrifuge" | "Darwinia" | "EnergyWebX" | "Hydration" | "Interlay" | "Heima" | "Jamton" | "Moonbeam" | "CoretimePolkadot" | "Collectives" | "Crust" | "Manta" | "NeuroWeb" | "Pendulum" | "Mythos" | "Peaq" | "PeoplePolkadot" | "Unique" | "Xode" | "AssetHubKusama" | "BridgeHubKusama" | "Karura" | "Kintsugi" | "Moonriver" | "CoretimeKusama" | "Encointer" | "Basilisk" | "BifrostKusama" | "CrustShadow" | "Crab" | "Laos" | "Quartz" | "RobonomicsPolkadot" | "PeopleKusama" | "Shiden" | "Zeitgeist" | "AssetHubWestend" | "BridgeHubWestend" | "CollectivesWestend" | "CoretimeWestend" | "Penpal" | "PeopleWestend" | "AjunaPaseo" | "AssetHubPaseo" | "BifrostPaseo" | "BridgeHubPaseo" | "CoretimePaseo" | "EnergyWebXPaseo" | "HeimaPaseo" | "HydrationPaseo" | "LaosPaseo" | "NeuroWebPaseo" | "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" | "NeuroWeb" | "Pendulum" | "Mythos" | "Peaq" | "PeoplePolkadot" | "Unique" | "Xode" | "AssetHubKusama" | "BridgeHubKusama" | "Karura" | "Kintsugi" | "Moonriver" | "CoretimeKusama" | "Encointer" | "Basilisk" | "BifrostKusama" | "CrustShadow" | "Crab" | "Laos" | "Quartz" | "RobonomicsPolkadot" | "PeopleKusama" | "Shiden" | "Zeitgeist" | "AssetHubWestend" | "BridgeHubWestend" | "CollectivesWestend" | "CoretimeWestend" | "Penpal" | "PeopleWestend" | "AjunaPaseo" | "AssetHubPaseo" | "BifrostPaseo" | "BridgeHubPaseo" | "CoretimePaseo" | "EnergyWebXPaseo" | "HeimaPaseo" | "HydrationPaseo" | "LaosPaseo" | "NeuroWebPaseo" | "PeoplePaseo" | "ZeitgeistPaseo" | undefined;
 
 declare const resolveParaId: (paraId: number | undefined, destination: TDestination) => number | undefined;
 
-interface TSwapExtension {
-    RouterBuilder: typeof RouterBuilder;
-}
-declare const registerSwapExtension: (extension: TSwapExtension) => void;
-declare const getSwapExtensionOrThrow: () => TSwapExtension;
-
 declare const convertBuilderConfig: <TApi>(config: TBuilderOptions<TApiOrUrl<TApi>> | undefined) => TBuilderConfig<TUrl> | undefined;
-declare const createRouterBuilder: <TApi, TRes, TSigner>(options: TTransferOptionsWithSwap<TApi, TRes, TSigner>) => _paraspell_swap.RouterBuilderCore<unknown, unknown, unknown, object & {
-    from: TSubstrateChain | undefined;
-} & {
-    exchange: TExchangeInput;
-} & {
-    to: TChain | undefined;
-} & {
-    currencyFrom: TCurrencyInput;
-} & {
-    currencyTo: TCurrencyInput;
-} & {
-    amount: TAmount;
-} & {
-    sender: string;
-} & {
-    evmSenderAddress: string | undefined;
-} & {
-    recipient: string | undefined;
-} & {
-    slippagePct: string;
-}>;
-declare const executeWithRouter: <TApi, TRes, TSigner, T>(options: TTransferOptionsWithSwap<TApi, TRes, TSigner>, executor: (builder: ReturnType<typeof createRouterBuilder<TApi, TRes, TSigner>>) => Promise<T>) => Promise<T>;
+declare const createSwapBuilder: <TApi, TRes, TSigner>(options: TTransferOptionsWithSwap<TApi, TRes, TSigner>) => TSwapBuilder<TApi, TRes, TSigner>;
+declare const executeWithSwap: <TApi, TRes, TSigner, T>(options: TTransferOptionsWithSwap<TApi, TRes, TSigner>, executor: (builder: TSwapBuilder<TApi, TRes, TSigner>) => Promise<T>) => Promise<T>;
 declare const normalizeExchange: (exchange: TExchangeInput) => TExchangeInput;
 
-declare const abstractDecimals: <TApi, TRes, TSigner>(amount: TAmount$1, decimals: number | undefined, api: PolkadotApi<TApi, TRes, TSigner>) => bigint;
-declare const applyDecimalAbstraction: (amount: TAmount$1, decimals: number | undefined, shouldAbstract: boolean) => bigint;
+declare const abstractDecimals: <TApi, TRes, TSigner>(amount: TAmount, decimals: number | undefined, api: PolkadotApi<TApi, TRes, TSigner>) => bigint;
+declare const applyDecimalAbstraction: (amount: TAmount, decimals: number | undefined, shouldAbstract: boolean) => bigint;
 
 declare const createAssetsFilter: (asset: TAsset, version: Version) => {
     Wild: {
@@ -2436,9 +2445,9 @@ declare const createBaseExecuteXcm: <TRes>(options: TCreateBaseTransferXcmOption
     suffixXcm?: unknown[];
 }) => unknown[];
 
-declare const createExecuteCall: (chain: TSubstrateChain$1, xcm: TXcmVersioned<any>, maxWeight: TWeight) => TSerializedExtrinsics;
+declare const createExecuteCall: (chain: TSubstrateChain, xcm: TXcmVersioned<any>, maxWeight: TWeight) => TSerializedExtrinsics;
 
-declare const createExecuteExchangeXcm: <TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, origin: TSubstrateChain$1, 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, TSigner>(options: TCreateTransferXcmOptions<TApi, TRes, TSigner>) => Promise<OneKey<_paraspell_sdk_common.Version, unknown[]>>;
 
@@ -2450,7 +2459,7 @@ declare const getLocalTransferAmount: <TApi, TRes, TSigner>({ assetInfo, balance
 
 declare const handleToAhTeleport: <TApi, TRes, TSigner>(origin: TParachain, input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, defaultTx: TRes) => Promise<TRes>;
 
-declare const throwUnsupportedCurrency: (currency: TCurrencyInput$1, chain: string, { isDestination }?: {
+declare const throwUnsupportedCurrency: (currency: TCurrencyInput, chain: string, { isDestination }?: {
     isDestination: boolean;
 }) => never;
 
@@ -2459,8 +2468,8 @@ declare const formatUnits: typeof formatUnits$1;
 
 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$1, destination: TDestination, override?: Version) => Version;
-declare const pickRouterCompatibleXcmVersion: (origin: TSubstrateChain$1 | undefined, exchangeChain: TSubstrateChain$1, destination: TChain$1 | undefined) => Version;
+declare const pickCompatibleXcmVersion: (origin: TSubstrateChain, destination: TDestination, override?: Version) => Version;
+declare const pickRouterCompatibleXcmVersion: (origin: TSubstrateChain | undefined, exchangeChain: TSubstrateChain, destination: TChain | undefined) => Version;
 
-export { API_TYPES, AmountTooLowError, ApiNotInitializedError, AssetClaimBuilder, BaseAssetsPallet, BatchMode, BatchValidationError, BridgeHaltedError, Builder, DEFAULT_TTL_MS, DRY_RUN_CLIENT_TIMEOUT_MS, DryRunFailedError, ETH_MAINNET_CHAIN_ID, ETH_TESTNET_CHAIN_ID, EXCHANGE_CHAINS, EXTENSION_MS, ExtensionNotInstalledError, FeatureTemporarilyDisabledError, GeneralBuilder, InvalidAddressError, MAX_CLIENTS, MissingChainApiError, MissingParameterError, NoXCMSupportImplementedError, NumberFormatError, OverrideConflictError, PolkadotApi, PolkadotXcmError, PolkadotXcmExecutionError, ProviderUnavailableError, RELAY_LOCATION, RoutingResolutionError, RuntimeApiError, RuntimeApiUnavailableError, ScenarioNotSupportedError, SubmitTransactionError, TRANSACT_ORIGINS, TX_CLIENT_TIMEOUT_MS, TransferToAhNotSupported, TypeAndThenUnavailableError, UnableToComputeError, UnsupportedOperationError, ValidationError, XTokensError, abstractDecimals, addEthereumBridgeFees, addXcmVersionHeader, applyDecimalAbstraction, assertAddressIsString, assertHasId, assertSender, assertSenderSource, assertSwapSupport, assertToIsString, blake2b256, blake2b512, calcPreviewMintAmount, claimAssets, compareAddresses, computeOverridenAmount, constructTypeAndThenCall, convertBuilderConfig, convertSs58, createAsset, createAssetId, createAssetsFilter, createBaseExecuteXcm, createBeneficiaryLocXTokens, createBeneficiaryLocation, createChainClient, createClientCache, createClientPoolHelpers, createDestination, createDirectExecuteXcm, createExecuteCall, createExecuteExchangeXcm, createRouterBuilder, createTransfer, createTransferOrSwap, createTransferOrSwapAll, createTxOverrideAmount, createTypeAndThenCall, createTypeThenAutoReserve, createVersionedAssets, createVersionedDestination, createX1Payload, deriveAccountId, dryRun, dryRunInternal, dryRunOrigin, encodeSs58, executeWithRouter, formatAssetIdToERC20, formatUnits, getAssetBalanceInternal, getAssetReserveChain, getBalance, getBalanceInternal, getBridgeStatus, getChain, getChainConfig, getChainLocation, getChainProviders, getChainVersion, getEthErc20Balance, getEvmPrivateKeyHex, getFailureInfo, getLocalTransferAmount, getMinTransferableAmount, getMinTransferableAmountInternal, getMoonbeamErc20Balance, getOriginXcmFee, getOriginXcmFeeInternal, getParaEthTransferFees, getParaId, getRelayChainOf, getSwapExtensionOrThrow, getTChain, getTransferInfo, getTransferableAmount, getTransferableAmountInternal, getXcmFee, getXcmFeeInternal, getXcmFeeOnce, handleExecuteTransfer, handleSwapExecuteTransfer, handleToAhTeleport, isConfig, isSenderSigner, keyFromWs, localizeLocation, maybeOverrideAsset, maybeOverrideAssets, normalizeAmount, normalizeExchange, overrideTxAmount, padFee, padValueBy, parseUnits, pickCompatibleXcmVersion, pickRouterCompatibleXcmVersion, registerSwapExtension, resolveAssetCount, resolveChainApi, resolveDestChain, resolveModuleError, resolveParaId, resolveTransferParams, reverseTransformLocation, selectXcmVersion, sortAssets, throwUnsupportedCurrency, transferMoonbeamEvm, transferMoonbeamToEth, traverseXcmHops, validateAddress, validateAssetSpecifiers, validateCurrency, validateDestination, validateDestinationAddress, validateTransact, verifyEdOnDestination, wrapTxBypass };
-export type { BuildHopInfoOptions, ClientCache, HopProcessParams, HopTraversalConfig, HopTraversalResult, IPolkadotXCMTransfer, IXTokensTransfer, OneKey, TAddress, TApiOrUrl, TApiType, TAssetClaimInternalOptions, TAssetClaimOptions, TAssetClaimOptionsBase, TBatchOptions, TBatchedTransferOptions, TBifrostToken, TBridgeStatus, TBuildAllInternalRes, TBuildDestInfoOptions, TBuildInternalRes, TBuildInternalResBase, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateEthBridgeInstructionsOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, TDestXcmFeeDetail, TDestination, TDryRunBaseOptions, TDryRunBypassOptions, TDryRunCallBaseOptions, TDryRunCallOptions, TDryRunChainFailure, TDryRunChainResult, TDryRunChainSuccess, TDryRunError, TDryRunOptions, TDryRunPreviewOptions, TDryRunResBase, TDryRunResult, TDryRunXcmBaseOptions, TDryRunXcmOptions, TEvmBuilderOptions, TEvmBuilderOptionsBase, TEvmChainFrom, TExchangeChain, TExchangeInput, TFeeType, TForeignAssetId, TForeignOrNativeAsset, TForeignOrTokenAsset, TGetAssetBalanceOptions, TGetAssetBalanceOptionsBase, TGetBalanceCommonOptions, TGetBalanceOptions, TGetBalanceOptionsBase, TGetFeeForDestChainBaseOptions, TGetFeeForDestChainOptions, TGetMinTransferableAmountOptions, TGetOriginXcmFeeBaseOptions, TGetOriginXcmFeeInternalOptions, TGetOriginXcmFeeOptions, TGetReverseTxFeeOptions, TGetTransferInfoOptions, TGetTransferInfoOptionsBase, TGetTransferableAmountOptions, TGetTransferableAmountOptionsBase, TGetXcmFeeBaseOptions, TGetXcmFeeBuilderOptions, TGetXcmFeeInternalOptions, TGetXcmFeeOptions, TGetXcmFeeResult, THopInfo, THopTransferInfo, TMantaAsset, TModuleError, TNativeTokenAsset, TOriginFeeDetails, TOtherReserveAsset, TPaymentInfo, TPolkadotXCMTransferOptions, TPolkadotXcmMethod, TProviderEntry, TReserveAsset, TResolveHopParams, TScenario, TSelfReserveAsset, TSender, TSerializeEthTransferOptions, TSerializedEthTransfer, TSerializedExtrinsics, TSerializedRuntimeApiQuery, TSerializedStateQuery, TSetBalanceRes, TStatusChangeCallback, TSwapConfig, TSwapEvent, TSwapEventType, TSwapExtension, TSwapFeeEstimates, TSwapOptions, TTransactOptions, TTransactOrigin, TTransactionContext, TTransactionType, TTransferBaseOptions, TTransferBaseOptionsWithSender, TTransferBaseOptionsWithSwap, TTransferFeeEstimates, TTransferInfo, TTransferInternalOptions, TTransferLocalOptions, TTransferOptions, TTransferOptionsWithSwap, TTxFactory, TTypeAndThenCallContext, TTypeAndThenFees, TTypeAndThenOverrides, TUrl, TVerifyEdOnDestinationOptions, TVerifyEdOnDestinationOptionsBase, TWeight, TXTokensCurrencySelection, TXTokensMethod, TXTokensTransferOptions, TXcmAsset, TXcmFeeBase, TXcmFeeDetail, TXcmFeeDetailError, TXcmFeeDetailSuccess, TXcmFeeDetailWithFallback, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSender, WithRequiredSwapOptions };
+export { API_TYPES, AmountTooLowError, ApiNotInitializedError, AssetClaimBuilder, BaseAssetsPallet, BatchMode, BatchValidationError, BridgeHaltedError, Builder, DEFAULT_TTL_MS, DRY_RUN_CLIENT_TIMEOUT_MS, DryRunFailedError, ETH_MAINNET_CHAIN_ID, ETH_TESTNET_CHAIN_ID, EXCHANGE_CHAINS, EXTENSION_MS, ExtensionNotInstalledError, FeatureTemporarilyDisabledError, GeneralBuilder, InvalidAddressError, MAX_CLIENTS, MissingChainApiError, MissingParameterError, NoXCMSupportImplementedError, NumberFormatError, OverrideConflictError, PolkadotApi, PolkadotXcmError, PolkadotXcmExecutionError, ProviderUnavailableError, RELAY_LOCATION, RoutingResolutionError, RuntimeApiError, RuntimeApiUnavailableError, ScenarioNotSupportedError, SubmitTransactionError, TRANSACT_ORIGINS, TX_CLIENT_TIMEOUT_MS, TransferToAhNotSupported, TypeAndThenUnavailableError, UnableToComputeError, UnsupportedOperationError, ValidationError, XTokensError, abstractDecimals, addEthereumBridgeFees, addXcmVersionHeader, applyDecimalAbstraction, assertAddressIsString, assertExtensionInstalled, assertHasId, assertNotEvmTransfer, assertSender, assertSenderSource, assertSubstrateOrigin, assertSwapSupport, assertToIsString, blake2b256, blake2b512, calcPreviewMintAmount, claimAssets, compareAddresses, computeOverridenAmount, constructTypeAndThenCall, convertBuilderConfig, convertSs58, createAsset, createAssetId, createAssetsFilter, createBaseExecuteXcm, createBeneficiaryLocXTokens, createBeneficiaryLocation, createChainClient, createClientCache, createClientPoolHelpers, createCustomXcmOnDest, createDestination, createDirectExecuteXcm, createEthereumBridgeInstructions, createExecuteCall, createExecuteExchangeXcm, createSwapBuilder, createTransfer, createTransferOrSwap, createTransferOrSwapAll, createTxOverrideAmount, createTypeAndThenCall, createTypeThenAutoReserve, createVersionedAssets, createVersionedDestination, createX1Payload, deriveAccountId, dryRun, dryRunInternal, dryRunOrigin, encodeSs58, executeWithSwap, formatAssetIdToERC20, formatUnits, generateMessageId, getAssetBalanceInternal, getAssetReserveChain, getBalance, getBalanceInternal, getBridgeStatus, getChain, getChainConfig, getChainLocation, getChainProviders, getChainVersion, getEthErc20Balance, getEvmExtensionOrThrow, getEvmPrivateKeyHex, getEvmSnowbridgeExtensionOrThrow, getFailureInfo, getLocalTransferAmount, getMinTransferableAmount, getMinTransferableAmountInternal, getMoonbeamErc20Balance, getOriginXcmFee, getOriginXcmFeeInternal, getParaEthTransferFees, getParaId, getRelayChainOf, getSwapExtensionOrThrow, getTChain, getTransferInfo, getTransferableAmount, getTransferableAmountInternal, getXcmFee, getXcmFeeInternal, getXcmFeeOnce, handleExecuteTransfer, handleSwapExecuteTransfer, handleToAhTeleport, isConfig, isSenderSigner, isViemSigner, keyFromWs, localizeLocation, maybeOverrideAsset, maybeOverrideAssets, normalizeAmount, normalizeExchange, overrideTxAmount, padFee, padValueBy, parseUnits, pickCompatibleXcmVersion, pickRouterCompatibleXcmVersion, registerEvmExtension, registerEvmSnowbridgeExtension, registerSwapExtension, resolveAssetCount, resolveDestChain, resolveModuleError, resolveParaId, resolveTransferParams, reverseTransformLocation, selectXcmVersion, sortAssets, throwUnsupportedCurrency, transferMoonbeamEvm, transferMoonbeamToEth, traverseXcmHops, validateAddress, validateAssetSpecifiers, validateCurrency, validateDestination, validateDestinationAddress, validateTransact, verifyEdOnDestination, wrapTxBypass };
+export type { BuildHopInfoOptions, ClientCache, HopProcessParams, HopTraversalConfig, HopTraversalResult, IPolkadotXCMTransfer, IXTokensTransfer, OneKey, TAddress, TApiOrUrl, TApiType, TAssetClaimInternalOptions, TAssetClaimOptions, TAssetClaimOptionsBase, TBatchOptions, TBatchedTransferOptions, TBifrostToken, TBridgeStatus, TBuildAllInternalRes, TBuildDestInfoOptions, TBuildInternalRes, TBuildInternalResBase, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateEthBridgeInstructionsOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, TDestXcmFeeDetail, TDestination, TDryRunBaseOptions, TDryRunBypassOptions, TDryRunCallBaseOptions, TDryRunCallOptions, TDryRunChainFailure, TDryRunChainResult, TDryRunChainSuccess, TDryRunError, TDryRunOptions, TDryRunPreviewOptions, TDryRunResBase, TDryRunResult, TDryRunXcmBaseOptions, TDryRunXcmOptions, TEvmExtension, TEvmSnowbridgeExtension, TEvmTransferOptions, TEvmTransferOptionsBase, TExchangeChain, TExchangeInput, TFeeType, TForeignAssetId, TForeignOrNativeAsset, TForeignOrTokenAsset, TGetAssetBalanceOptions, TGetAssetBalanceOptionsBase, TGetBalanceCommonOptions, TGetBalanceOptions, TGetBalanceOptionsBase, TGetFeeForDestChainBaseOptions, TGetFeeForDestChainOptions, TGetMinTransferableAmountOptions, TGetOriginXcmFeeBaseOptions, TGetOriginXcmFeeInternalOptions, TGetOriginXcmFeeOptions, TGetReverseTxFeeOptions, TGetTransferInfoOptions, TGetTransferInfoOptionsBase, TGetTransferableAmountOptions, TGetTransferableAmountOptionsBase, TGetXcmFeeBaseOptions, TGetXcmFeeBuilderOptions, TGetXcmFeeInternalOptions, TGetXcmFeeOptions, TGetXcmFeeResult, THopInfo, THopTransferInfo, TMantaAsset, TModuleError, TNativeTokenAsset, TOriginFeeDetails, TOtherReserveAsset, TPaymentInfo, TPolkadotXCMTransferOptions, TPolkadotXcmMethod, TProviderEntry, TReserveAsset, TResolveHopParams, TScenario, TSelfReserveAsset, TSender, TSerializedExtrinsics, TSerializedRuntimeApiQuery, TSerializedStateQuery, TSetBalanceRes, TStatusChangeCallback, TSubstrateTransferBaseOptions, TSubstrateTransferBaseOptionsWithSender, TSubstrateTransferOptions, TSwapBuilder, TSwapBuilderFactory, TSwapConfig, TSwapEvent, TSwapEventType, TSwapExtension, TSwapFeeEstimates, TSwapOptions, TTransactOptions, TTransactOrigin, TTransactionContext, TTransactionType, TTransferBaseOptions, TTransferBaseOptionsWithSender, TTransferBaseOptionsWithSwap, TTransferFeeEstimates, TTransferInfo, TTransferInternalOptions, TTransferLocalOptions, TTransferOptions, TTransferOptionsWithSwap, TTxFactory, TTypeAndThenCallContext, TTypeAndThenFees, TTypeAndThenOverrides, TUrl, TVerifyEdOnDestinationOptions, TVerifyEdOnDestinationOptionsBase, TWeight, TXTokensCurrencySelection, TXTokensMethod, TXTokensTransferOptions, TXcmAsset, TXcmFeeBase, TXcmFeeDetail, TXcmFeeDetailError, TXcmFeeDetailSuccess, TXcmFeeDetailWithFallback, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSender, WithRequiredSwapOptions };