@paraspell/sdk-core 13.4.1 → 13.5.0

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import * as _paraspell_sdk_common 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, TAmount, TAssetWithFee, WithComplexAmount, TAssetInfoWithId } from '@paraspell/assets';
+import { TAssetInfo, WithAmount, TAsset, TCurrencyInputWithAmount, TCurrencyInput, TCurrencyCore, 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 { WalletClient, TransactionSerializableEIP1559, Address, formatUnits as formatUnits$1, parseUnits as parseUnits$1 } from 'viem';
 
 type WithApi<TBase, TApi, TRes, TSigner> = TBase & {
     api: PolkadotApi<TApi, TRes, TSigner>;
@@ -113,7 +113,6 @@ declare abstract class Chain<TApi, TRes, TSigner> {
     transferLocal(options: TTransferInternalOptions<TApi, TRes, TSigner>): Promise<TRes>;
     transferLocalNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): Promise<TRes>;
     transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
-    protected transferToEthereum<TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>, useOnlyDepositInstruction?: boolean): Promise<TRes>;
     getBalanceNative(api: PolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
     getCustomCurrencyId(_asset: TAssetInfo): unknown;
     getBalanceForeign<TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
@@ -150,7 +149,6 @@ declare class AssetHubKusama<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSig
 
 declare class AssetHubPolkadot<TApi, TRes, TSigner> extends Chain<TApi, TRes, TSigner> implements IPolkadotXCMTransfer<TApi, TRes, TSigner> {
     constructor(chain?: TParachain, info?: string, ecosystem?: TRelaychain, version?: Version);
-    handleEthBridgeNativeTransfer<TApi, TRes, TSigner>(input: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
     transferPolkadotXCM(options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>): Promise<TRes>;
     transferLocalNonNativeAsset(options: TTransferLocalOptions<TApi, TRes, TSigner>): TRes;
     getBalanceForeign<TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>, address: string, asset: TAssetInfo): Promise<bigint>;
@@ -601,834 +599,114 @@ declare const TRANSACT_ORIGINS: readonly ["Native", "SovereignAccount", "Superus
  */
 declare const EXCHANGE_CHAINS: readonly ["AssetHubPolkadot", "AssetHubKusama", "AssetHubPaseo", "AssetHubWestend", "Hydration", "Karura", "Acala", "BifrostKusama", "BifrostPolkadot"];
 
-type TSwapConfig = {
-    currencyTo: TCurrencyCore;
-    exchangeChain: TParachain;
-};
-type TDryRunBaseOptions<TRes> = {
-    tx: TRes;
-    origin: TSubstrateChain;
-    destination: TChain;
-    sender: string;
-    currency: TCurrencyInputWithAmount;
-    version?: Version;
-    feeAsset?: TCurrencyInput;
-    swapConfig?: TSwapConfig;
-    useRootOrigin?: boolean;
-    bypassOptions?: TBypassOptions;
-};
-type TDryRunOptions<TApi, TRes, TSigner> = WithApi<TDryRunBaseOptions<TRes>, TApi, TRes, TSigner>;
-type TDryRunCallBaseOptions<TRes> = {
+/**
+ * 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);
     /**
-     * The transaction to dry-run
+     * Specifies the assets to be claimed.
+     *
+     * @param assets - An array of assets to claim in a multi-asset format.
+     * @returns An instance of Builder
      */
-    tx: TRes;
+    currency(currency: TAssetClaimOptionsBase['currency']): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        currency: TAssetClaimOptionsBase['currency'];
+    }>;
     /**
-     * The chain to dry-run on
+     * Sets the sender address.
+     *
+     * @param address - The sender address.
+     * @returns
      */
-    chain: TSubstrateChain;
+    sender(sender: TSender<TSigner>): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        sender: string;
+    }>;
     /**
-     * The destination chain
+     * Specifies the account address on which the assets will be claimed.
+     *
+     * @param address - The destination account address.
+     * @returns An instance of Builder
      */
-    destination: TDestination;
+    address(address: TAddress): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        address: TAddress;
+    }>;
     /**
-     * The address to dry-run with
+     * Sets the XCM version to be used for the asset claim.
+     *
+     * @param version - The XCM version.
+     * @returns An instance of Builder
      */
-    address: string;
+    xcmVersion(version: Version): AssetClaimBuilder<TApi, TRes, TSigner, T & {
+        version: Version;
+    }>;
     /**
-     * Whether to use the root origin
+     * Builds and returns the asset claim extrinsic.
+     *
+     * @returns A Promise that resolves to the asset claim extrinsic.
      */
-    useRootOrigin?: boolean;
+    build(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase>): Promise<TRes>;
+    signAndSubmit(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>>): Promise<string>;
     /**
-     * XCM version to use for the dry-run parameters
+     * Returns the API instance used by the builder.
+     *
+     * @returns The API instance.
      */
-    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;
+    getApi(): TApi;
     /**
-     * The XCM instructions
+     * Disconnects the API.
+     *
+     * @returns A Promise that resolves when the API is disconnected.
      */
-    xcm: any;
-    /** The transaction to dry-run */
-    tx: TRes;
+    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, 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);
     /**
-     * The chain to dry-run on
+     * Specifies the origin chain for the transaction.
+     *
+     * @param chain - The chain from which the transaction originates.
+     * @returns An instance of Builder
      */
-    chain: TSubstrateChain;
+    from(chain: TChain): GeneralBuilder<TApi, TRes, TSigner, T & {
+        from: TChain;
+    }>;
     /**
-     * The origin chain
+     * 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
      */
-    origin: TSubstrateChain;
-    asset: TAssetInfo;
-    version: Version;
-    feeAsset?: TAssetInfo;
-    amount: bigint;
-    originFee: bigint;
-};
-type TDryRunXcmOptions<TApi, TRes, TSigner> = WithApi<TDryRunXcmBaseOptions<TRes>, TApi, TRes, TSigner>;
-type TDryRunResBase = {
-    asset: TAssetInfo;
-    isExchange?: boolean;
-};
-type TDryRunChainSuccess = TDryRunResBase & {
-    success: true;
-    fee: bigint;
-    weight?: TWeight;
-    forwardedXcms: any;
-    destParaId?: number;
-};
-type TDryRunChainFailure = TDryRunResBase & {
-    success: false;
-    failureReason: string;
-    failureSubReason?: string;
-};
-type TDryRunChainResult = TDryRunChainSuccess | TDryRunChainFailure;
-type THopInfo = {
-    chain: TChain;
-    result: TDryRunChainResult;
-};
-type TChainEndpoint = 'origin' | 'destination' | TChain;
-type TDryRunResult = {
-    failureReason?: string;
-    failureSubReason?: string;
-    failureChain?: TChainEndpoint;
-    origin: TDryRunChainResult;
-    destination?: TDryRunChainResult;
-    hops: THopInfo[];
-};
-type TResolveHopParams<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    tx: TRes;
-    originChain: TSubstrateChain;
-    currentChain: TSubstrateChain;
-    destination: TDestination;
-    asset: TAssetInfo;
-    currency: TCurrencyInputWithAmount;
-    swapConfig?: TSwapConfig;
-    hasPassedExchange: boolean;
-};
-type HopProcessParams<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    currentChain: TSubstrateChain;
-    currentOrigin: TSubstrateChain;
-    currentAsset: TAssetInfo;
-    forwardedXcms: any;
-    hasPassedExchange: boolean;
-    isDestination: boolean;
-};
-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 HopTraversalResult<THopResult> = {
-    hops: Array<{
-        chain: TSubstrateChain;
-        result: THopResult;
-    }>;
-    destination?: THopResult;
-    lastProcessedChain?: TSubstrateChain;
-};
-type TBypassOptions = {
-    mintFeeAssets?: boolean;
-    sentAssetMintMode?: 'preview' | 'bypass';
-};
-declare enum XTokensError {
-    AssetHasNoReserve = "AssetHasNoReserve",
-    NotCrossChainTransfer = "NotCrossChainTransfer",
-    InvalidDest = "InvalidDest",
-    NotCrossChainTransferableCurrency = "NotCrossChainTransferableCurrency",
-    UnweighableMessage = "UnweighableMessage",
-    XcmExecutionFailed = "XcmExecutionFailed",
-    CannotReanchor = "CannotReanchor",
-    InvalidAncestry = "InvalidAncestry",
-    InvalidAsset = "InvalidAsset",
-    DestinationNotInvertible = "DestinationNotInvertible",
-    BadVersion = "BadVersion",
-    DistinctReserveForAssetAndFee = "DistinctReserveForAssetAndFee",
-    ZeroFee = "ZeroFee",
-    ZeroAmount = "ZeroAmount",
-    TooManyAssetsBeingSent = "TooManyAssetsBeingSent",
-    AssetIndexNonExistent = "AssetIndexNonExistent",
-    FeeNotEnough = "FeeNotEnough",
-    NotSupportedLocation = "NotSupportedLocation",
-    MinXcmFeeNotDefined = "MinXcmFeeNotDefined",
-    RateLimited = "RateLimited"
-}
-declare 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 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> = {
-    /**
-     * The transaction factory
-     */
-    buildTx: TTxFactory<TRes>;
-    /**
-     * The origin chain
-     */
-    origin: TSubstrateChain;
-    /**
-     * The destination chain
-     */
-    destination: TChain;
-    /**
-     * The sender address
-     */
-    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> = {
-    /**
-     * Current execution phase type
-     */
-    type: TSwapEventType;
-    /**
-     * Full transaction plan for visualization
-     */
-    routerPlan?: TTransactionContext<TApi, TRes>[];
-    /**
-     * Current transaction's origin chain
-     */
-    chain?: TSubstrateChain;
-    /**
-     * Current transaction's destination chain
-     */
-    destinationChain?: TChain;
-    /**
-     * 0-based step index of current operation
-     */
-    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> = {
-    /**
-     * The origin chain
-     */
-    from: TChain;
-    /**
-     * 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;
-    /**
-     * The optional fee asset. Either ID, symbol, or location
-     */
-    feeAsset?: TCurrencyInput;
-    /**
-     * The optional destination parachain ID
-     */
-    paraIdTo?: number;
-    /**
-     * The optional overrided XCM version
-     */
-    version?: Version;
-    /**
-     * The optional pallet override
-     */
-    pallet?: string;
-    /**
-     * Whether to keep the account alive after the transfer.
-     */
-    keepAlive?: boolean;
-    /**
-     * The optional pallet method override
-     */
-    method?: string;
-    /**
-     * Hex of the encoded transaction call to apply on the destination chain
-     */
-    transactOptions?: TTransactOptions<TRes>;
-    /**
-     * The optional swap options
-     */
-    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 TSubstrateTransferBaseOptions<TApi, TRes, TSigner> = Omit<TTransferBaseOptions<TApi, TRes, TSigner>, 'from'> & {
-    from: TSubstrateChain;
-};
-type TSubstrateTransferOptions<TApi, TRes, TSigner> = Omit<TTransferOptions<TApi, TRes, TSigner>, 'from'> & {
-    from: TSubstrateChain;
-};
-type WithRequiredSender<TBase> = Omit<TBase, 'sender'> & {
-    /**
-     * The sender address. A SS58 or H160 format.
-     */
-    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;
-    feeCurrency?: TCurrencyInput;
-    overriddenAsset?: TLocation | TAssetWithFee[];
-    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>;
-};
-type TSerializedStateQuery = {
-    module: TAssetsPallet;
-    method: string;
-    params: unknown[];
-};
-type TSerializedRuntimeApiQuery = {
-    module: string;
-    method: string;
-    params: unknown[];
-};
-type TDestWeight = {
-    ref_time: bigint;
-    proof_size: bigint;
-};
-type 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>;
-    address: TAddress;
-    version: Version;
-};
-type TCreateBeneficiaryXTokensOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    origin: TSubstrateChain;
-    destination: TDestination;
-    recipient: TAddress;
-    version: Version;
-    paraId?: number;
-};
-type TBridgeStatus = 'Normal' | 'Halted';
-type TTransferLocalOptions<TApi, TRes, TSigner> = Omit<TTransferInternalOptions<TApi, TRes, TSigner>, 'recipient'> & {
-    recipient: string;
-    balance: bigint;
-};
-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>;
-    recipient: TAddress;
-    assetInfo: TAssetInfo;
-    sender: string;
-    ahAddress?: string;
-    version: Version;
-};
-
-/** @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 TAssetClaimOptions<TApi, TRes, TSigner> = WithApi<TAssetClaimOptionsBase, TApi, TRes, TSigner>;
-type TAssetClaimInternalOptions<TApi, TRes, TSigner> = TAssetClaimOptions<TApi, TRes, TSigner> & {
-    version: Version;
-    assets: TAsset<bigint>[];
-};
-
-type TSetBalanceRes = {
-    assetStatusTx?: TSerializedExtrinsics;
-    balanceTx: TSerializedExtrinsics;
-};
-declare abstract class BaseAssetsPallet {
-    protected palletName: TAssetsPallet;
-    constructor(palletName: TAssetsPallet);
-    abstract mint<TApi, TRes, TSigner>(address: string, assetInfo: WithAmount<TAssetInfo>, balance: bigint, chain: TSubstrateChain, api: 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;
-    }>;
-    /**
-     * Sets the XCM version to be used for the asset claim.
-     *
-     * @param version - The XCM version.
-     * @returns An instance of Builder
-     */
-    xcmVersion(version: Version): AssetClaimBuilder<TApi, TRes, TSigner, T & {
-        version: Version;
-    }>;
-    /**
-     * Builds and returns the asset claim extrinsic.
-     *
-     * @returns A Promise that resolves to the asset claim extrinsic.
-     */
-    build(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase>): Promise<TRes>;
-    signAndSubmit(this: AssetClaimBuilder<TApi, TRes, TSigner, TAssetClaimOptionsBase & TBuilderInternalOptions<TSigner>>): Promise<string>;
-    /**
-     * Returns the API instance used by the builder.
-     *
-     * @returns The API instance.
-     */
-    getApi(): TApi;
-    /**
-     * Disconnects the API.
-     *
-     * @returns A Promise that resolves when the API is disconnected.
-     */
-    disconnect(): Promise<void>;
-}
-
-declare class BatchTransactionManager<TApi, TRes, TSigner> {
-    transactionOptions: 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>;
-}
-
-/**
- * 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, {
+    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;
     }>;
     /**
@@ -1497,638 +775,1388 @@ declare class GeneralBuilder<TApi, TRes, TSigner, T extends Partial<TTransferBas
         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
+     * 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;
+    }>;
+    /**
+     * 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> & TBuilderInternalOptions<TSigner>>): GeneralBuilder<TApi, TRes, TSigner, T & {
+        from: TSubstrateChain;
+    }>;
+    /**
+     * Builds and returns the batched transaction based on the configured parameters.
+     *
+     * @param options - (Optional) Options to customize the batch transaction.
+     * @returns A Extrinsic representing the batched transactions.
+     */
+    buildBatch(this: GeneralBuilder<TApi, TRes, 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 an unsigned EIP-1559 transaction (viem `TransactionSerializableEIP1559`) for an
+     * EVM-compatible origin. `nonce`, `gas`, and fees are populated from the origin chain's RPC.
+     */
+    buildEvm(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<TransactionSerializableEIP1559>;
+    /**
+     * 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<TDisableFallback extends boolean = false>(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, options?: TGetXcmFeeBuilderOptions & {
+        disableFallback: TDisableFallback;
+    }): Promise<TXcmFeeDetailWithForwardedXcm<TDisableFallback>>;
+    /**
+     * 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;
+    private prepareEvmDispatch;
+    /**
+     * 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 TEvmTransferOptionsBase = {
+    from: TChain;
+    to: TChain;
+    currency: TCurrencyInputWithAmount;
+    recipient: string;
+    ahAddress?: string;
+};
+type TEvmTransferOptions<TApi, TRes, TSigner> = WithApi<TEvmTransferOptionsBase & {
+    signer: WalletClient;
+}, TApi, TRes, TSigner>;
+type TBuildEvmTransferOptions<TApi, TRes, TSigner> = WithApi<TEvmTransferOptionsBase & {
+    sender: string;
+}, TApi, TRes, TSigner>;
+/**
+ * The options for the batch builder.
+ */
+declare enum BatchMode {
+    /**
+     * Does not commit if one of the calls in the batch fails.
+     */
+    BATCH_ALL = "BATCH_ALL",
+    /**
+     * Commits each successful call regardless if a call fails.
+     */
+    BATCH = "BATCH"
+}
+/**
+ * The options for the batch builder.
+ */
+type TBatchOptions = {
+    /**
+     * The batch mode. Can be either:
+     * `BATCH_ALL` - does not commit if one of the calls in the batch fails.
+     * `BATCH` - commits each successful call regardless if a call fails.
+     */
+    mode: BatchMode;
+};
+type TDryRunPreviewOptions = {
+    mintFeeAssets?: boolean;
+};
+type TBuilderOptions<TApi> = TApi | TBuilderConfig<TApi>;
+type TBuilderConfig<TApi> = Partial<{
+    apiOverrides: Partial<Record<TChain, TApi>>;
+    development: boolean;
+    abstractDecimals: boolean;
+    xcmFormatCheck: boolean;
+}>;
+type TCreateTxsOptions<TApi, TRes, TSigner> = Pick<TTransferOptions<TApi, TRes, TSigner>, 'api' | 'from' | 'to' | 'currency'>;
+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;
+};
+type TBuildInternalRes<TApi, TRes, TSigner, TOptions extends TTransferBaseOptions<TApi, TRes, TSigner> = TTransferBaseOptions<TApi, TRes, TSigner>> = TBuildInternalResBase<TApi, TRes, TSigner, TOptions> & {
+    tx: TRes;
+};
+type TBuildAllInternalRes<TApi, TRes, TSigner, TOptions extends TTransferBaseOptions<TApi, TRes, TSigner> = TTransferBaseOptions<TApi, TRes, TSigner>> = TBuildInternalResBase<TApi, TRes, TSigner, TOptions> & {
+    txContexts: TTransactionContext<TApi, TRes>[];
+};
+type TSender<TSigner> = string | TSigner;
+type TBuilderInternalOptions<TSigner> = {
+    senderSource?: TSender<TSigner> | WalletClient;
+};
+
+type TSwapConfig = {
+    currencyTo: TCurrencyCore;
+    exchangeChain: TParachain;
+};
+type TDryRunBaseOptions<TRes> = {
+    tx: TRes;
+    origin: TSubstrateChain;
+    destination: TChain;
+    sender: string;
+    currency: TCurrencyInputWithAmount;
+    version?: Version;
+    feeAsset?: TCurrencyInput;
+    swapConfig?: TSwapConfig;
+    useRootOrigin?: boolean;
+    bypassOptions?: TBypassOptions;
+};
+type TDryRunOptions<TApi, TRes, TSigner> = WithApi<TDryRunBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunCallBaseOptions<TRes> = {
+    /**
+     * The transaction to dry-run
      */
-    feeAsset(currency: TCurrencyInput | undefined): GeneralBuilder<TApi, TRes, TSigner, T & {
-        feeAsset: TCurrencyInput | undefined;
-    }>;
+    tx: TRes;
     /**
-     * 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.
+     * The chain to dry-run on
      */
-    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;
-        };
-    }>;
+    chain: TSubstrateChain;
     /**
-     * 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.
+     * The destination chain
      */
-    swap(options: TSwapOptions<TApi, TRes, TSigner>): GeneralBuilder<TApi, TRes, TSigner, T & {
-        swapOptions: TSwapOptions<TApi, TRes, TSigner>;
-    }>;
+    destination: TDestination;
     /**
-     * Adds the transfer transaction to the batch.
-     *
-     * @returns An instance of Builder
+     * The address to dry-run with
      */
-    addToBatch(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): GeneralBuilder<TApi, TRes, TSigner, T & {
-        from: TSubstrateChain;
-    }>;
+    address: string;
     /**
-     * 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.
+     * Whether to use the root origin
      */
-    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;
+    useRootOrigin?: boolean;
     /**
-     * Builds and returns the transfer extrinsic.
-     *
-     * @returns A Promise that resolves to the transfer extrinsic.
+     * XCM version to use for the dry-run parameters
      */
-    build(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptions<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<TRes>;
+    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;
     /**
-     * Builds and returns multiple transfer or swap extrinsics
-     *
-     * @returns A Promise that resolves to the transfer extrinsic contexts
+     * The XCM instructions
      */
-    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>;
+    xcm: any;
+    /** The transaction to dry-run */
+    tx: TRes;
     /**
-     * Returns the XCM fee for the transfer using dryRun or paymentInfo function.
-     *
-     * @returns An origin and destination fee.
+     * The chain to dry-run on
      */
-    getXcmFee<TDisableFallback extends boolean = false>(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, options?: TGetXcmFeeBuilderOptions & {
-        disableFallback: TDisableFallback;
-    }): Promise<TGetXcmFeeResult<TDisableFallback>>;
+    chain: TSubstrateChain;
     /**
-     * Returns the origin XCM fee for the transfer using dryRun or paymentInfo function.
-     *
-     * @returns An origin fee.
+     * The origin chain
      */
-    getOriginXcmFee(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>, { disableFallback }?: TGetXcmFeeBuilderOptions): Promise<TXcmFeeDetail & {
-        forwardedXcms?: unknown;
-        destParaId?: number;
+    origin: TSubstrateChain;
+    asset: TAssetInfo;
+    version: Version;
+    feeAsset?: TAssetInfo;
+    amount: bigint;
+    originFee: bigint;
+};
+type TDryRunXcmOptions<TApi, TRes, TSigner> = WithApi<TDryRunXcmBaseOptions<TRes>, TApi, TRes, TSigner>;
+type TDryRunResBase = {
+    asset: TAssetInfo;
+    isExchange?: boolean;
+};
+type TDryRunChainSuccess = TDryRunResBase & {
+    success: true;
+    fee: bigint;
+    weight?: TWeight;
+    forwardedXcms: any;
+    destParaId?: number;
+};
+type TDryRunChainFailure = TDryRunResBase & {
+    success: false;
+    failureReason: string;
+    failureSubReason?: string;
+};
+type TDryRunChainResult = TDryRunChainSuccess | TDryRunChainFailure;
+type THopInfo = {
+    chain: TChain;
+    result: TDryRunChainResult;
+};
+type TChainEndpoint = 'origin' | 'destination' | TChain;
+type TDryRunResult = {
+    failureReason?: string;
+    failureSubReason?: string;
+    failureChain?: TChainEndpoint;
+    origin: TDryRunChainResult;
+    destination?: TDryRunChainResult;
+    hops: THopInfo[];
+};
+type TResolveHopParams<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    tx: TRes;
+    originChain: TSubstrateChain;
+    currentChain: TSubstrateChain;
+    destination: TDestination;
+    asset: TAssetInfo;
+    currency: TCurrencyInputWithAmount;
+    swapConfig?: TSwapConfig;
+    hasPassedExchange: boolean;
+};
+type HopProcessParams<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    currentChain: TSubstrateChain;
+    currentOrigin: TSubstrateChain;
+    currentAsset: TAssetInfo;
+    forwardedXcms: any;
+    hasPassedExchange: boolean;
+    isDestination: boolean;
+};
+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 HopTraversalResult<THopResult> = {
+    hops: Array<{
+        chain: TSubstrateChain;
+        result: THopResult;
     }>;
+    destination?: THopResult;
+    lastProcessedChain?: TSubstrateChain;
+};
+type TBypassOptions = {
+    mintFeeAssets?: boolean;
+    sentAssetMintMode?: 'preview' | 'bypass';
+};
+declare enum XTokensError {
+    AssetHasNoReserve = "AssetHasNoReserve",
+    NotCrossChainTransfer = "NotCrossChainTransfer",
+    InvalidDest = "InvalidDest",
+    NotCrossChainTransferableCurrency = "NotCrossChainTransferableCurrency",
+    UnweighableMessage = "UnweighableMessage",
+    XcmExecutionFailed = "XcmExecutionFailed",
+    CannotReanchor = "CannotReanchor",
+    InvalidAncestry = "InvalidAncestry",
+    InvalidAsset = "InvalidAsset",
+    DestinationNotInvertible = "DestinationNotInvertible",
+    BadVersion = "BadVersion",
+    DistinctReserveForAssetAndFee = "DistinctReserveForAssetAndFee",
+    ZeroFee = "ZeroFee",
+    ZeroAmount = "ZeroAmount",
+    TooManyAssetsBeingSent = "TooManyAssetsBeingSent",
+    AssetIndexNonExistent = "AssetIndexNonExistent",
+    FeeNotEnough = "FeeNotEnough",
+    NotSupportedLocation = "NotSupportedLocation",
+    MinXcmFeeNotDefined = "MinXcmFeeNotDefined",
+    RateLimited = "RateLimited"
+}
+declare 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 TDryRunError = {
+    failureReason: string;
+    failureSubReason?: string;
+};
+
+declare class AmountTooLowError extends Error {
+    constructor(message?: string);
+}
+
+/**
+ * Error thrown when an API operation is attempted before the API has been initialized.
+ */
+declare class ApiNotInitializedError extends Error {
+    constructor();
+}
+
+/**
+ * Error thrown when a batch operation is invalid or cannot be executed.
+ */
+declare class BatchValidationError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when the Ethereum bridge is halted.
+ */
+declare class BridgeHaltedError extends Error {
     /**
-     * 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
+     * Constructs a new BridgeHaltedError.
      *
-     * @returns The min transferable amount.
+     * @param message - Optional custom error message.
      */
-    getMinTransferableAmount(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<bigint>;
+    constructor();
+}
+
+/**
+ * Error thrown when the Dry Run fails.
+ */
+declare class DryRunFailedError extends Error {
+    readonly reason: string;
+    readonly dryRunType?: TChainEndpoint;
     /**
-     * Returns the max transferable amount for the transfer
+     * Constructs a new DryRunFailedError.
      *
-     * @returns The max transferable amount.
+     * @param reason - The reason why the dry run failed.
+     * @param dryRunType - Optional. Specifies if the error is related to the 'origin' or 'destination' dry run.
+     * @param prefix - Optional. A short sentence prepended to the message
      */
-    verifyEdOnDestination(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<boolean>;
+    constructor(reason: string, dryRunType?: TChainEndpoint, prefix?: string);
+}
+
+/**
+ * Error thrown when an extension is not installed.
+ */
+declare class ExtensionNotInstalledError extends Error {
     /**
-     * Returns the transfer info for the transfer
+     * Constructs a new ExtensionNotInstalledError.
      *
-     * @returns The transfer info.
+     * @param message - The error message.
      */
-    getTransferInfo(this: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner> & TBuilderInternalOptions<TSigner>>): Promise<TTransferInfo>;
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when a feature or route is temporarily disabled via configuration or governance.
+ */
+declare class FeatureTemporarilyDisabledError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when an invalid address is provided.
+ */
+declare class InvalidAddressError extends Error {
     /**
-     * Returns the receivable amount on the destination after the transfer
+     * Constructs a new InvalidAddressError.
      *
-     * @returns The computed receivable amount.
-     * @throws \{UnableToComputeError\} Thrown when the receivable amount cannot be determined.
+     * @param message - The error message.
      */
-    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;
+    constructor(message: string);
+}
+
+/**
+ * Error development mode is on and no API override is provided for a specific chain.
+ */
+declare class MissingChainApiError extends Error {
     /**
-     * Returns the API instance used by the builder.
+     * Constructs a new MissingChainApiError.
      *
-     * @returns The API instance.
+     * @param chain - The chain for which the API is missing.
      */
-    getApi(): TApi;
+    constructor(chain: TChain);
+}
+
+/**
+ * Error thrown when a required parameter is missing.
+ */
+declare class MissingParameterError extends Error {
+    constructor(parameter: string | string[], message?: string);
+}
+
+/**
+ * Used to inform user, that Parachain they wish to use has not yet implemented full XCM Support
+ */
+declare class NoXCMSupportImplementedError extends Error {
     /**
-     * Disconnects the API.
+     * Constructs a new NoXCMSupportImplementedError.
      *
-     * @returns A Promise that resolves when the API is disconnected.
+     * @param chain - The chain for which XCM support is not implemented.
      */
-    disconnect(): Promise<void>;
+    constructor(chain: TChain);
 }
+
 /**
- * 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.
+ * Error thrown when numeric input is invalid or cannot be parsed.
  */
-declare const Builder: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>) => GeneralBuilder<TApi, TRes, TSigner, object>;
+declare class NumberFormatError extends Error {
+    constructor(message?: string);
+}
 
-type TGetBalanceCommonOptions = {
-    /**
-     * The address of the account.
-     */
-    address: string;
-    /**
-     * The chain on which to query the balance.
-     */
+/**
+ * Error thrown when asset or currency overrides are invalid or conflicting.
+ */
+declare class OverrideConflictError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when no provider or RPC endpoint is available for the requested chain.
+ */
+declare class ProviderUnavailableError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when routing or path resolution fails.
+ */
+declare class RoutingResolutionError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when a runtime API call fails
+ */
+declare class RuntimeApiError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when a required runtime API is not available on the target chain.
+ */
+declare class RuntimeApiUnavailableError extends Error {
+    constructor(chain: string, apiName: string);
+}
+
+type TScenarioNotSupportedContext = {
     chain: TChain;
+    scenario: TScenario;
 };
 /**
- * Retrieves the asset balance for a given account on a specified chain.
+ * Error thrown when a scenario, route, or chain capability is not supported.
  */
-type TGetAssetBalanceOptionsBase = TGetBalanceCommonOptions & {
+declare class ScenarioNotSupportedError extends Error {
+    constructor(message: string);
+    constructor({ chain, scenario }: TScenarioNotSupportedContext);
+}
+
+/**
+ * Error thrown when a submitted transaction encounters a dispatch error on-chain.
+ */
+declare class SubmitTransactionError extends Error {
     /**
-     * The resolved asset to query balance for.
+     * Constructs a new SubmitTransactionError.
+     *
+     * @param message - The dispatch error details.
      */
-    asset: TAssetInfo;
-};
+    constructor(message: string);
+}
+
+declare class TransferToAhNotSupported extends Error {
+    constructor(message?: string);
+}
+
+declare class TypeAndThenUnavailableError extends Error {
+    constructor(message: string);
+}
+
 /**
- * Retrieves the currency balance for a given account on a specified chain.
+ * UnableToComputeError is thrown when a computation cannot be performed.
  */
-type TGetBalanceOptionsBase = TGetBalanceCommonOptions & {
+declare class UnableToComputeError extends Error {
     /**
-     * The currency to query.
+     * Constructs a new UnableToComputeError.
+     *
+     * @param message - Required error message.
      */
-    currency?: TCurrencyCore;
+    constructor(message: string);
+}
+
+/**
+ * Error thrown when an operation or parameter combination is not supported.
+ */
+declare class UnsupportedOperationError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Thrown when a validation check fails.
+ */
+declare class ValidationError extends Error {
+    constructor(message: string);
+}
+
+type TXcmFeeSwapConfig = TSwapConfig & {
+    amountOut: bigint;
 };
-type TGetBalanceOptions<TApi, TRes, TSigner> = WithApi<TGetBalanceOptionsBase, TApi, TRes, TSigner>;
-type TGetAssetBalanceOptions<TApi, TRes, TSigner> = WithApi<TGetAssetBalanceOptionsBase, TApi, TRes, TSigner>;
-type TGetTransferableAmountOptionsBase<TRes> = {
+type TTxFactory<TRes> = (amount?: string, relative?: boolean) => Promise<TRes>;
+type TGetXcmFeeBaseOptions<TRes, TDisableFallback extends boolean = boolean> = {
     /**
-     * The sender address of the account.
+     * The transaction factory
      */
-    sender: string;
+    buildTx: TTxFactory<TRes>;
     /**
-     * The chain on which to query the balance.
+     * The origin chain
      */
     origin: TSubstrateChain;
     /**
-     * The destination chain.
+     * The destination chain
      */
     destination: TChain;
     /**
-     * The currency to query.
+     * The sender address
      */
+    sender: string;
+    recipient: string;
     currency: WithAmount<TCurrencyCore>;
-    version: Version | undefined;
+    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, TDisableFallback extends boolean = boolean> = {
     buildTx: TTxFactory<TRes>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    sender: string;
+    currency: WithAmount<TCurrencyCore>;
+    version?: Version;
     feeAsset?: TCurrencyInput;
+    disableFallback: TDisableFallback;
+    useRootOrigin?: boolean;
 };
-type TGetTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes>, TApi, TRes, TSigner>;
-type TGetMinTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes> & {
+type TGetOriginXcmFeeOptions<TApi, TRes, TSigner, TDisableFallback extends boolean = boolean> = WithApi<TGetOriginXcmFeeBaseOptions<TRes, TDisableFallback>, 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;
-    builder: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>;
-}, TApi, TRes, TSigner>;
-type TVerifyEdOnDestinationOptionsBase<TRes> = {
+    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 TXcmFeeDetailWithForwardedXcm<TDisableFallback extends boolean> = TConditionalXcmFeeDetail<TDisableFallback> & {
+    forwardedXcms?: unknown;
+    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 THopTransferInfo = {
+    chain: TChain;
+    result: {
+        xcmFee: TXcmFeeBase;
+        asset: TAssetInfo;
+        isExchange?: boolean;
+    };
+};
+type TXcmFeeBase = {
+    fee: bigint;
+    asset: TAssetInfo;
+};
+type TTransferInfo = {
+    chain: {
+        origin: TChain;
+        destination: TChain;
+        ecosystem: string;
+    };
+    origin: {
+        selectedCurrency: {
+            sufficient: boolean;
+            balance: bigint;
+            balanceAfter: bigint;
+            asset: TAssetInfo;
+        };
+        xcmFee: TXcmFeeBase & {
+            sufficient: boolean;
+            balance: bigint;
+            balanceAfter: bigint;
+        };
+        isExchange?: boolean;
+    };
+    hops: THopTransferInfo[];
+    destination: {
+        receivedCurrency: {
+            sufficient: boolean | UnableToComputeError;
+            receivedAmount: bigint | UnableToComputeError;
+            balance: bigint;
+            balanceAfter: bigint | UnableToComputeError;
+            asset: TAssetInfo;
+        };
+        xcmFee: TXcmFeeBase & {
+            balanceAfter: bigint | UnableToComputeError;
+        };
+        isExchange?: boolean;
+    };
+};
+type TBuildOriginInfoOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
+    sender: string;
+    currency: TCurrencyCore;
+    originAsset: TAssetInfo;
+    amount: bigint;
+    originFee: bigint;
+    originFeeAsset: TAssetInfo;
+    isFeeAssetAh: boolean;
+};
+type BuildHopInfoOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    chain: TChain;
+    fee: bigint;
+    originChain: TSubstrateChain;
+    currency: TCurrencyCore;
+    asset: TAssetInfo;
+    sender: string;
+    ahAddress?: string;
+};
+type TBuildDestInfoOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    recipient: string;
+    currency: WithAmount<TCurrencyCore>;
+    originFee: bigint;
+    isFeeAssetAh: boolean;
+    destFeeDetail: TXcmFeeDetail;
+    totalHopFee: bigint;
+    bridgeFee?: bigint;
+};
+type TOriginFeeDetails = {
+    sufficientForXCM: boolean;
+    xcmFee: bigint;
+};
+type TGetTransferInfoOptionsBase<TRes> = {
+    buildTx: TTxFactory<TRes>;
+    origin: TSubstrateChain;
+    destination: TChain;
+    sender: string;
+    ahAddress?: string;
+    recipient: string;
+    currency: WithAmount<TCurrencyCore>;
+    version: Version | undefined;
+    feeAsset?: TCurrencyCore;
+};
+type TGetTransferInfoOptions<TApi, TRes, TSigner> = WithApi<TGetTransferInfoOptionsBase<TRes>, TApi, TRes, TSigner>;
+
+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> = {
+    /**
+     * Current execution phase type
+     */
+    type: TSwapEventType;
+    /**
+     * Full transaction plan for visualization
+     */
+    routerPlan?: TTransactionContext<TApi, TRes>[];
+    /**
+     * Current transaction's origin chain
+     */
+    chain?: TSubstrateChain;
+    /**
+     * Current transaction's destination chain
+     */
+    destinationChain?: TChain;
     /**
-     * The origin chain.
+     * 0-based step index of current operation
      */
+    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>>;
+    getOriginXcmFee<TDisableFallback extends boolean = false>(options?: TGetXcmFeeBuilderOptions & {
+        disableFallback: TDisableFallback;
+    }): Promise<TXcmFeeDetailWithForwardedXcm<TDisableFallback>>;
+    getSwapInfo(): Promise<TTransferInfo>;
+    getTransferableAmount(): Promise<bigint>;
+    getMinTransferableAmount(): Promise<bigint>;
+    getBestAmountOut(): Promise<{
+        exchange: TExchangeChain;
+        amountOut: bigint;
+    }>;
+    dryRun(): Promise<TDryRunResult>;
+    dryRunPreview(previewOptions?: TDryRunPreviewOptions): 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> = {
     /**
-     * The destination chain.
+     * The origin chain
      */
-    destination: TChain;
+    from: TChain;
     /**
-     * The address of the account.
+     * The destination address. A SS58 or H160 format.
      */
-    recipient: string;
+    recipient: TAddress;
     /**
-     * The account of the sender.
+     * The optional sender address. A SS58 or H160 format.
      */
-    sender: string;
+    sender?: string;
     /**
-     * The currency to query.
+     * The optional asset hub address. A SS58 format only.
      */
-    currency: WithAmount<TCurrencyCore>;
-    version: Version | undefined;
-    buildTx: TTxFactory<TRes>;
-    feeAsset?: TCurrencyInput;
-};
-type TVerifyEdOnDestinationOptions<TApi, TRes, TSigner> = WithApi<TVerifyEdOnDestinationOptionsBase<TRes>, TApi, TRes, TSigner>;
-
-type TEvmTransferOptionsBase = {
-    from: TChain;
-    to: TChain;
-    currency: TCurrencyInputWithAmount;
-    recipient: string;
     ahAddress?: string;
-    signer: WalletClient;
-};
-type TEvmTransferOptions<TApi, TRes, TSigner> = WithApi<TEvmTransferOptionsBase, TApi, TRes, TSigner>;
-/**
- * The options for the batch builder.
- */
-declare enum BatchMode {
     /**
-     * Does not commit if one of the calls in the batch fails.
+     * The destination chain or XCM location
      */
-    BATCH_ALL = "BATCH_ALL",
+    to: TDestination;
     /**
-     * Commits each successful call regardless if a call fails.
+     * The currency to transfer. Either ID, symbol, location, or multi-asset
      */
-    BATCH = "BATCH"
-}
-/**
- * The options for the batch builder.
- */
-type TBatchOptions = {
+    currency: TCurrencyInputWithAmount;
     /**
-     * The batch mode. Can be either:
-     * `BATCH_ALL` - does not commit if one of the calls in the batch fails.
-     * `BATCH` - commits each successful call regardless if a call fails.
+     * The optional fee asset. Either ID, symbol, or location
      */
-    mode: BatchMode;
-};
-type TDryRunPreviewOptions = {
-    mintFeeAssets?: boolean;
-};
-type TBuilderOptions<TApi> = TApi | TBuilderConfig<TApi>;
-type TBuilderConfig<TApi> = Partial<{
-    apiOverrides: Partial<Record<TChain, TApi>>;
-    development: boolean;
-    abstractDecimals: boolean;
-    xcmFormatCheck: boolean;
-}>;
-type TCreateTxsOptions<TApi, TRes, TSigner> = Pick<TTransferOptions<TApi, TRes, TSigner>, 'api' | 'from' | 'to' | 'currency'>;
-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;
-};
-type TBuildInternalRes<TApi, TRes, TSigner, TOptions extends TTransferBaseOptions<TApi, TRes, TSigner> = TTransferBaseOptions<TApi, TRes, TSigner>> = TBuildInternalResBase<TApi, TRes, TSigner, TOptions> & {
-    tx: TRes;
-};
-type TBuildAllInternalRes<TApi, TRes, TSigner, TOptions extends TTransferBaseOptions<TApi, TRes, TSigner> = TTransferBaseOptions<TApi, TRes, TSigner>> = TBuildInternalResBase<TApi, TRes, TSigner, TOptions> & {
-    txContexts: TTransactionContext<TApi, TRes>[];
-};
-type TSender<TSigner> = string | TSigner;
-type TBuilderInternalOptions<TSigner> = {
-    senderSource?: TSender<TSigner> | WalletClient;
-};
-
-type TProviderEntry = {
-    name: string;
-    endpoint: string;
-};
-type TChainConfig = {
-    name: string;
-    info: string;
-    paraId: number;
-    providers: TProviderEntry[];
-};
-type TChainConfigMap = Record<TSubstrateChain, TChainConfig>;
-
-type OneKey<K extends string, V = unknown> = {
-    [P in K]: Record<P, V> & Partial<Record<Exclude<K, P>, never>> extends infer O ? {
-        [Q in keyof O]: O[Q];
-    } : never;
-}[K];
-type TXcmVersioned<T> = OneKey<Version, T>;
-type TXcmForeignAsset = {
-    ForeignAsset: string | number | bigint | undefined;
-};
-type TForeignAssetId = {
-    ForeignAssetId: bigint | undefined;
-};
-type TForeignOrTokenAsset = TXcmForeignAsset | {
-    Token: string | undefined;
-};
-type TForeignOrNativeAsset = TXcmForeignAsset | 'Native';
-type TXcmAsset = {
-    XCM: number | undefined;
-} | {
-    Native: null;
-};
-type TNativeTokenAsset = 'NativeToken';
-type TZeitgeistAsset = 'Ztg';
-type TOtherReserveAsset = {
-    OtherReserve: string | bigint | undefined;
-};
-type TSelfReserveAsset = 'SelfReserve';
-type TReserveAsset = TOtherReserveAsset | TSelfReserveAsset;
-type TBifrostToken = {
-    Native: string | number;
-} | {
-    VToken: string;
-} | {
-    Token: string;
-} | {
-    VSToken2: number;
-} | {
-    VToken2: number;
-} | {
-    Token2: number;
-};
-type TXTokensCurrencySelection = TXcmVersioned<TLocation | TAsset | TAsset[]> | TXcmForeignAsset | TForeignAssetId | TForeignOrTokenAsset | TXcmAsset | TOtherReserveAsset | TBifrostToken | string | bigint | number | undefined;
-
-declare class AmountTooLowError extends Error {
-    constructor(message?: string);
-}
-
-/**
- * Error thrown when an API operation is attempted before the API has been initialized.
- */
-declare class ApiNotInitializedError extends Error {
-    constructor();
-}
-
-/**
- * Error thrown when a batch operation is invalid or cannot be executed.
- */
-declare class BatchValidationError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when the Ethereum bridge is halted.
- */
-declare class BridgeHaltedError extends Error {
+    feeAsset?: TCurrencyInput;
     /**
-     * Constructs a new BridgeHaltedError.
-     *
-     * @param message - Optional custom error message.
+     * The optional destination parachain ID
      */
-    constructor();
-}
-
-/**
- * Error thrown when the Dry Run fails.
- */
-declare class DryRunFailedError extends Error {
-    readonly reason: string;
-    readonly dryRunType?: TChainEndpoint;
+    paraIdTo?: number;
+    /**
+     * The optional overrided XCM version
+     */
+    version?: Version;
     /**
-     * Constructs a new DryRunFailedError.
-     *
-     * @param reason - The reason why the dry run failed.
-     * @param dryRunType - Optional. Specifies if the error is related to the 'origin' or 'destination' dry run.
+     * The optional pallet override
      */
-    constructor(reason: string, dryRunType?: TChainEndpoint);
-}
-
-/**
- * Error thrown when an extension is not installed.
- */
-declare class ExtensionNotInstalledError extends Error {
+    pallet?: string;
     /**
-     * Constructs a new ExtensionNotInstalledError.
-     *
-     * @param message - The error message.
+     * Whether to keep the account alive after the transfer.
      */
-    constructor(message: string);
-}
-
-/**
- * Error thrown when a feature or route is temporarily disabled via configuration or governance.
- */
-declare class FeatureTemporarilyDisabledError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when an invalid address is provided.
- */
-declare class InvalidAddressError extends Error {
+    keepAlive?: boolean;
     /**
-     * Constructs a new InvalidAddressError.
-     *
-     * @param message - The error message.
+     * The optional pallet method override
      */
-    constructor(message: string);
-}
-
-/**
- * Error development mode is on and no API override is provided for a specific chain.
- */
-declare class MissingChainApiError extends Error {
+    method?: string;
     /**
-     * Constructs a new MissingChainApiError.
-     *
-     * @param chain - The chain for which the API is missing.
+     * Hex of the encoded transaction call to apply on the destination chain
      */
-    constructor(chain: TChain);
-}
-
-/**
- * Error thrown when a required parameter is missing.
- */
-declare class MissingParameterError extends Error {
-    constructor(parameter: string | string[], message?: string);
-}
-
-/**
- * Used to inform user, that Parachain they wish to use has not yet implemented full XCM Support
- */
-declare class NoXCMSupportImplementedError extends Error {
+    transactOptions?: TTransactOptions<TRes>;
     /**
-     * Constructs a new NoXCMSupportImplementedError.
-     *
-     * @param chain - The chain for which XCM support is not implemented.
+     * The optional swap options
      */
-    constructor(chain: TChain);
-}
-
-/**
- * Error thrown when numeric input is invalid or cannot be parsed.
- */
-declare class NumberFormatError extends Error {
-    constructor(message?: string);
-}
-
-/**
- * Error thrown when asset or currency overrides are invalid or conflicting.
- */
-declare class OverrideConflictError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Error thrown when no provider or RPC endpoint is available for the requested chain.
- */
-declare class ProviderUnavailableError extends Error {
-    constructor(message: string);
-}
-
+    swapOptions?: TSwapOptions<TApi, TRes, TSigner>;
+};
 /**
- * Error thrown when routing or path resolution fails.
+ * Options for transferring from a parachain to another parachain or relay chain
  */
-declare class RoutingResolutionError extends Error {
-    constructor(message: string);
-}
+type TTransferOptions<TApi, TRes, TSigner> = WithApi<TTransferBaseOptions<TApi, TRes, TSigner>, TApi, TRes, TSigner> & {
+    isAmountAll: boolean;
+};
+type TSubstrateTransferBaseOptions<TApi, TRes, TSigner> = Omit<TTransferBaseOptions<TApi, TRes, TSigner>, 'from'> & {
+    from: TSubstrateChain;
+};
+type TSubstrateTransferOptions<TApi, TRes, TSigner> = Omit<TTransferOptions<TApi, TRes, TSigner>, 'from'> & {
+    from: TSubstrateChain;
+};
+type WithRequiredSender<TBase> = Omit<TBase, 'sender'> & {
+    /**
+     * The sender address. A SS58 or H160 format.
+     */
+    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;
+    feeCurrency?: TCurrencyInput;
+    overriddenAsset?: TLocation | TAssetWithFee[];
+    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>;
+};
+type TSerializedStateQuery = {
+    module: TAssetsPallet;
+    method: string;
+    params: unknown[];
+};
+type TSerializedRuntimeApiQuery = {
+    module: string;
+    method: string;
+    params: unknown[];
+};
+type TDestWeight = {
+    ref_time: bigint;
+    proof_size: bigint;
+};
+type 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>;
+    address: TAddress;
+    version: Version;
+};
+type TCreateBeneficiaryXTokensOptions<TApi, TRes, TSigner> = {
+    api: PolkadotApi<TApi, TRes, TSigner>;
+    origin: TSubstrateChain;
+    destination: TDestination;
+    recipient: TAddress;
+    version: Version;
+    paraId?: number;
+};
+type TBridgeStatus = 'Normal' | 'Halted';
+type TTransferLocalOptions<TApi, TRes, TSigner> = Omit<TTransferInternalOptions<TApi, TRes, TSigner>, 'recipient'> & {
+    recipient: string;
+    balance: bigint;
+};
+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;
+    forceBuyExecution?: 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>;
+    recipient: TAddress;
+    assetInfo: TAssetInfo;
+    sender: string;
+    ahAddress?: string;
+    version: Version;
+};
 
-/**
- * Error thrown when a runtime API call fails
- */
-declare class RuntimeApiError extends Error {
-    constructor(message: string);
-}
+/** @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 TAssetClaimOptions<TApi, TRes, TSigner> = WithApi<TAssetClaimOptionsBase, TApi, TRes, TSigner>;
+type TAssetClaimInternalOptions<TApi, TRes, TSigner> = TAssetClaimOptions<TApi, TRes, TSigner> & {
+    version: Version;
+    assets: TAsset<bigint>[];
+};
 
-/**
- * Error thrown when a required runtime API is not available on the target chain.
- */
-declare class RuntimeApiUnavailableError extends Error {
-    constructor(chain: string, apiName: string);
+type 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>;
 }
 
-type TScenarioNotSupportedContext = {
+type TGetBalanceCommonOptions = {
+    /**
+     * The address of the account.
+     */
+    address: string;
+    /**
+     * The chain on which to query the balance.
+     */
     chain: TChain;
-    scenario: TScenario;
 };
 /**
- * Error thrown when a scenario, route, or chain capability is not supported.
- */
-declare class ScenarioNotSupportedError extends Error {
-    constructor(message: string);
-    constructor({ chain, scenario }: TScenarioNotSupportedContext);
-}
-
-/**
- * Error thrown when a submitted transaction encounters a dispatch error on-chain.
+ * Retrieves the asset balance for a given account on a specified chain.
  */
-declare class SubmitTransactionError extends Error {
+type TGetAssetBalanceOptionsBase = TGetBalanceCommonOptions & {
     /**
-     * Constructs a new SubmitTransactionError.
-     *
-     * @param message - The dispatch error details.
+     * The resolved asset to query balance for.
      */
-    constructor(message: string);
-}
-
-declare class TransferToAhNotSupported extends Error {
-    constructor(message?: string);
-}
-
-declare class TypeAndThenUnavailableError extends Error {
-    constructor(message: string);
-}
-
+    asset: TAssetInfo;
+};
 /**
- * UnableToComputeError is thrown when a computation cannot be performed.
+ * Retrieves the currency balance for a given account on a specified chain.
  */
-declare class UnableToComputeError extends Error {
+type TGetBalanceOptionsBase = TGetBalanceCommonOptions & {
     /**
-     * Constructs a new UnableToComputeError.
-     *
-     * @param message - Required error message.
+     * The currency to query.
      */
-    constructor(message: string);
-}
-
-/**
- * Error thrown when an operation or parameter combination is not supported.
- */
-declare class UnsupportedOperationError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Thrown when a validation check fails.
- */
-declare class ValidationError extends Error {
-    constructor(message: string);
-}
-
-type THopTransferInfo = {
-    chain: TChain;
-    result: {
-        xcmFee: TXcmFeeBase;
-        asset: TAssetInfo;
-    };
-};
-type TXcmFeeBase = {
-    fee: bigint;
-    asset: TAssetInfo;
-};
-type TTransferInfo = {
-    chain: {
-        origin: TChain;
-        destination: TChain;
-        ecosystem: string;
-    };
-    origin: {
-        selectedCurrency: {
-            sufficient: boolean;
-            balance: bigint;
-            balanceAfter: bigint;
-            asset: TAssetInfo;
-        };
-        xcmFee: TXcmFeeBase & {
-            sufficient: boolean;
-            balance: bigint;
-            balanceAfter: bigint;
-        };
-    };
-    hops: THopTransferInfo[];
-    destination: {
-        receivedCurrency: {
-            sufficient: boolean | UnableToComputeError;
-            receivedAmount: bigint | UnableToComputeError;
-            balance: bigint;
-            balanceAfter: bigint | UnableToComputeError;
-            asset: TAssetInfo;
-        };
-        xcmFee: TXcmFeeBase & {
-            balanceAfter: bigint | UnableToComputeError;
-        };
-    };
+    currency?: TCurrencyCore;
 };
-type BuildHopInfoOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
-    chain: TSubstrateChain;
-    fee: bigint;
-    originChain: TSubstrateChain;
-    currency: TCurrencyCore;
-    asset: TAssetInfo;
+type TGetBalanceOptions<TApi, TRes, TSigner> = WithApi<TGetBalanceOptionsBase, TApi, TRes, TSigner>;
+type TGetAssetBalanceOptions<TApi, TRes, TSigner> = WithApi<TGetAssetBalanceOptionsBase, TApi, TRes, TSigner>;
+type TGetTransferableAmountOptionsBase<TRes> = {
+    /**
+     * The sender address of the account.
+     */
     sender: string;
-    ahAddress?: string;
-};
-type TBuildDestInfoOptions<TApi, TRes, TSigner> = {
-    api: PolkadotApi<TApi, TRes, TSigner>;
+    /**
+     * The chain on which to query the balance.
+     */
     origin: TSubstrateChain;
+    /**
+     * The destination chain.
+     */
     destination: TChain;
-    recipient: string;
+    /**
+     * The currency to query.
+     */
     currency: WithAmount<TCurrencyCore>;
-    originFee: bigint;
-    isFeeAssetAh: boolean;
-    destFeeDetail: TXcmFeeDetail;
-    totalHopFee: bigint;
-    bridgeFee?: bigint;
-};
-type TOriginFeeDetails = {
-    sufficientForXCM: boolean;
-    xcmFee: bigint;
-};
-type TGetTransferInfoOptionsBase<TRes> = {
+    version: Version | undefined;
     buildTx: TTxFactory<TRes>;
+    feeAsset?: TCurrencyInput;
+};
+type TGetTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes>, TApi, TRes, TSigner>;
+type TGetMinTransferableAmountOptions<TApi, TRes, TSigner> = WithApi<TGetTransferableAmountOptionsBase<TRes> & {
+    recipient: string;
+    builder: GeneralBuilder<TApi, TRes, TSigner, TTransferBaseOptionsWithSender<TApi, TRes, TSigner>>;
+}, TApi, TRes, TSigner>;
+type TVerifyEdOnDestinationOptionsBase<TRes> = {
+    /**
+     * The origin chain.
+     */
     origin: TSubstrateChain;
+    /**
+     * The destination chain.
+     */
     destination: TChain;
-    sender: string;
-    ahAddress?: string;
+    /**
+     * The address of the account.
+     */
     recipient: string;
+    /**
+     * The account of the sender.
+     */
+    sender: string;
+    /**
+     * The currency to query.
+     */
     currency: WithAmount<TCurrencyCore>;
     version: Version | undefined;
-    feeAsset?: TCurrencyCore;
+    buildTx: TTxFactory<TRes>;
+    feeAsset?: TCurrencyInput;
 };
-type TGetTransferInfoOptions<TApi, TRes, TSigner> = WithApi<TGetTransferInfoOptionsBase<TRes>, TApi, TRes, TSigner>;
+type TVerifyEdOnDestinationOptions<TApi, TRes, TSigner> = WithApi<TVerifyEdOnDestinationOptionsBase<TRes>, TApi, TRes, TSigner>;
+
+type TProviderEntry = {
+    name: string;
+    endpoint: string;
+};
+type TChainConfig = {
+    name: string;
+    info: string;
+    paraId: number;
+    providers: TProviderEntry[];
+};
+type TChainConfigMap = Record<TSubstrateChain, TChainConfig>;
+
+type OneKey<K extends string, V = unknown> = {
+    [P in K]: Record<P, V> & Partial<Record<Exclude<K, P>, never>> extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+type TXcmVersioned<T> = OneKey<Version, T>;
+type TXcmForeignAsset = {
+    ForeignAsset: string | number | bigint | undefined;
+};
+type TForeignAssetId = {
+    ForeignAssetId: bigint | undefined;
+};
+type TForeignOrTokenAsset = TXcmForeignAsset | {
+    Token: string | undefined;
+};
+type TForeignOrNativeAsset = TXcmForeignAsset | 'Native';
+type TXcmAsset = {
+    XCM: number | undefined;
+} | {
+    Native: null;
+};
+type TNativeTokenAsset = 'NativeToken';
+type TZeitgeistAsset = 'Ztg';
+type TOtherReserveAsset = {
+    OtherReserve: string | bigint | undefined;
+};
+type TSelfReserveAsset = 'SelfReserve';
+type TReserveAsset = TOtherReserveAsset | TSelfReserveAsset;
+type TBifrostToken = {
+    Native: string | number;
+} | {
+    VToken: string;
+} | {
+    Token: string;
+} | {
+    VSToken2: number;
+} | {
+    VToken2: number;
+} | {
+    Token2: number;
+};
+type TXTokensCurrencySelection = TXcmVersioned<TLocation | TAsset | TAsset[]> | TXcmForeignAsset | TForeignAssetId | TForeignOrTokenAsset | TXcmAsset | TOtherReserveAsset | TBifrostToken | string | bigint | number | undefined;
 
 type TChainWithApi<TApi, TRes, TSigner, T = TSubstrateChain> = {
     api: PolkadotApi<TApi, TRes, TSigner>;
@@ -2136,13 +2164,14 @@ type TChainWithApi<TApi, TRes, TSigner, T = TSubstrateChain> = {
 };
 type TTypeAndThenCallContext<TApi, TRes, TSigner> = {
     origin: TChainWithApi<TApi, TRes, TSigner>;
-    dest: TChainWithApi<TApi, TRes, TSigner>;
+    dest: TChainWithApi<TApi, TRes, TSigner, TChain>;
     reserve: TChainWithApi<TApi, TRes, TSigner, TChain>;
     isSubBridge: boolean;
     isSnowbridge: boolean;
     isRelayAsset: boolean;
     assetInfo: WithAmount<TAssetInfo>;
     systemAsset: TAssetInfo;
+    bridgeHopChain?: TSubstrateChain;
     options: TPolkadotXCMTransferOptions<TApi, TRes, TSigner>;
 };
 type TTypeAndThenFees = {
@@ -2197,13 +2226,15 @@ declare const getParaId: (chain: TChain) => number;
 declare const getTChain: (paraId: number, ecosystem: TRelaychain | TExternalChain) => TChain | null;
 
 interface TEvmExtension {
-    executeEvmTransfer: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
+    executeTransfer: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
+    buildTransfer: <TApi, TRes, TSigner>(options: TBuildEvmTransferOptions<TApi, TRes, TSigner>) => Promise<TransactionSerializableEIP1559>;
 }
 declare const registerEvmExtension: (extension: TEvmExtension | undefined) => void;
 declare const getEvmExtensionOrThrow: () => TEvmExtension;
 
 interface TEvmSnowbridgeExtension {
-    executeEvmSnowbridgeTransfer: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
+    executeTransfer: <TApi, TRes, TSigner>(options: TEvmTransferOptions<TApi, TRes, TSigner>) => Promise<string>;
+    buildTransfer: <TApi, TRes, TSigner>(options: TBuildEvmTransferOptions<TApi, TRes, TSigner>) => Promise<TransactionSerializableEIP1559>;
 }
 declare const registerEvmSnowbridgeExtension: (extension: TEvmSnowbridgeExtension | undefined) => void;
 declare const getEvmSnowbridgeExtensionOrThrow: () => TEvmSnowbridgeExtension;
@@ -2259,10 +2290,7 @@ declare const transferMoonbeamEvm: <TApi, TRes, TSigner>(options: TEvmTransferOp
 
 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;
-    destParaId?: number;
-}>;
+declare const getOriginXcmFee: <TApi, TRes, TSigner, TDisableFallback extends boolean = boolean>(options: TGetOriginXcmFeeOptions<TApi, TRes, TSigner, TDisableFallback>) => Promise<TXcmFeeDetailWithForwardedXcm<TDisableFallback>>;
 
 declare const getOriginXcmFeeInternal: <TApi, TRes, TSigner>({ api, tx, origin, destination, sender, disableFallback, feeAsset, currency, version, useRootOrigin }: TGetOriginXcmFeeInternalOptions<TApi, TRes, TSigner>) => Promise<TXcmFeeDetail & {
     forwardedXcms?: any;
@@ -2276,6 +2304,37 @@ declare const getXcmFeeOnce: <TApi, TRes, TSigner, TDisableFallback extends bool
 
 declare const getBridgeStatus: <TApi, TRes, TSigner>(api: PolkadotApi<TApi, TRes, TSigner>) => Promise<TBridgeStatus>;
 
+declare const aggregateHopFees: (hops: TXcmFeeHopInfo[], matchAsset: TAssetInfo) => {
+    totalHopFee: bigint;
+    bridgeFee?: bigint;
+};
+
+declare const buildDestInfo: <TApi, TRes, TSigner>({ api, origin, destination, recipient, currency, originFee, isFeeAssetAh, destFeeDetail, totalHopFee, bridgeFee }: TBuildDestInfoOptions<TApi, TRes, TSigner>) => Promise<{
+    receivedCurrency: {
+        sufficient: boolean | UnableToComputeError;
+        receivedAmount: bigint | UnableToComputeError;
+        balance: bigint;
+        balanceAfter: bigint | UnableToComputeError;
+        asset: _paraspell_assets.TAssetInfo;
+    };
+    xcmFee: {
+        fee: bigint;
+        balance: bigint;
+        balanceAfter: bigint;
+        asset: _paraspell_assets.TAssetInfo;
+    };
+}>;
+
+declare const buildHopInfo: <TApi, TRes, TSigner>({ api, chain, fee, originChain, asset, currency }: BuildHopInfoOptions<TApi, TRes, TSigner>) => Promise<{
+    asset: _paraspell_assets.TAssetInfo;
+    xcmFee: {
+        fee: bigint;
+        asset: _paraspell_assets.TAssetInfo;
+    };
+}>;
+
+declare const buildOriginInfo: <TApi, TRes, TSigner>({ api, origin, sender, currency, originAsset, amount, originFee, originFeeAsset, isFeeAssetAh }: TBuildOriginInfoOptions<TApi, TRes, TSigner>) => Promise<TTransferInfo["origin"]>;
+
 declare const getTransferInfo: <TApi, TRes, TSigner>({ api, buildTx, origin, destination, sender, ahAddress, recipient, currency, feeAsset, version }: TGetTransferInfoOptions<TApi, TRes, TSigner>) => Promise<TTransferInfo>;
 
 declare const getMinTransferableAmountInternal: <TApi, TRes, TSigner>({ api, origin, sender, recipient, origin: chain, destination, currency, feeAsset, buildTx, builder, version }: TGetMinTransferableAmountOptions<TApi, TRes, TSigner>) => Promise<bigint>;
@@ -2314,7 +2373,9 @@ declare const validateDestinationAddress: <TApi, TRes, TSigner>(address: TAddres
 declare const assertToIsString: (to: TDestination, overrideMsg?: string) => asserts to is Exclude<TDestination, TLocation>;
 declare const assertAddressIsString: (address: TAddress) => asserts address is Exclude<TAddress, TLocation>;
 declare const assertSender: (address: string | undefined) => asserts address is string;
+declare const assertEvmAddress: (address: string) => asserts address is Address;
 declare const assertHasId: (asset: TAssetInfo) => asserts asset is TAssetInfoWithId;
+declare const assertCurrencyCore: <T>(value: T) => asserts value is (T & TCurrencyCore) | (T & undefined);
 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;
@@ -2341,7 +2402,7 @@ declare const createTxOverrideAmount: <TApi, TRes, TSigner>(options: TCreateTxsO
 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, assetLocation: TLocation) => TSubstrateChain;
+declare const getAssetReserveChain: (chain: TSubstrateChain, assetLocation: TLocation, resolveExternalReserve?: boolean) => TChain;
 
 declare const getChainVersion: <TApi, TRes, TSigner>(chain: TChain) => Version;
 
@@ -2384,7 +2445,7 @@ 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, destination: TDestination, chainId?: number, junction?: TJunction, parents?: Parents) => TLocation;
+declare const createDestination: (version: Version, origin: TChain, 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;
@@ -2459,5 +2520,5 @@ declare const selectXcmVersion: (forcedVersion: Version | undefined, originVersi
 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, 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, 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 };
+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, aggregateHopFees, applyDecimalAbstraction, assertAddressIsString, assertCurrencyCore, assertEvmAddress, assertExtensionInstalled, assertHasId, assertNotEvmTransfer, assertSender, assertSenderSource, assertSubstrateOrigin, assertSwapSupport, assertToIsString, blake2b256, blake2b512, buildDestInfo, buildHopInfo, buildOriginInfo, 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, TBuildEvmTransferOptions, TBuildInternalRes, TBuildInternalResBase, TBuildOriginInfoOptions, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateEthBridgeInstructionsOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, 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, 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, TXcmFeeDetailWithForwardedXcm, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSender, WithRequiredSwapOptions };