@moonbeam-network/xcm-builder 1.0.0-dev.152 → 1.0.0-dev.154

package/build/index.d.ts

@@ -1,605 +1,327 @@
-import { Chain, AnyParachain, AssetAmount, ChainAssetId, ChainAsset, AnyChain, EvmParachain } from '@moonbeam-network/xcm-types';
-import { ApiPromise } from '@polkadot/api';
-import { FrameSystemAccountInfo, StagingXcmV3MultiLocation } from '@polkadot/types/lookup';
+import {
+  SetOptional,
+  ChainAssetId,
+  AnyChain,
+  AnyParachain,
+} from '@moonbeam-network/xcm-types';
+import {
+  FrameSystemAccountInfo,
+  StagingXcmV3MultiLocation,
+} from '@polkadot/types/lookup';
 import { Struct, u128, Enum } from '@polkadot/types';
-import { Abi, PublicClient, HttpTransport } from 'viem';
 import { SubmittableExtrinsicFunction } from '@polkadot/api/types';
-import { HexString } from '@polkadot/util/types';
-import { Wormhole, Network } from '@wormhole-foundation/sdk-connect';
+import { ApiPromise } from '@polkadot/api';
 
-interface ConfigBuilder<Config, Params = BuilderParams> {
-    build: (params: Params) => Config;
-}
-interface BuilderParams<IChain extends Chain = AnyParachain> {
-    asset: AssetAmount;
-    destination: IChain;
-    destinationAddress: string;
-    destinationApi?: ApiPromise;
-    fee: AssetAmount;
-    source: IChain;
-    sourceAddress: string;
-    sourceApi?: ApiPromise;
+declare enum CallType {
+  Evm = 'Evm',
+  Substrate = 'Substrate',
 }
 
 interface BaseConfigConstructorParams {
-    module: string;
-    func: string;
+  module: string;
+  func: string;
+  type: CallType;
 }
 declare class BaseConfig {
-    readonly module: string;
-    readonly func: string;
-    constructor({ module, func }: BaseConfigConstructorParams);
+  readonly module: string;
+  readonly func: string;
+  readonly type: CallType;
+  constructor({ module, func, type }: BaseConfigConstructorParams);
 }
 
-interface QueryConfigConstructorParams extends BaseConfigConstructorParams {
-    args?: unknown[];
-    transform: (data: any) => Promise<bigint>;
+interface QueryConfigConstructorParams
+  extends SetOptional<BaseConfigConstructorParams, 'type'> {
+  args?: any[];
+  transform: (data: any) => Promise<bigint>;
 }
 declare class SubstrateQueryConfig extends BaseConfig {
-    readonly args: unknown[];
-    readonly transform: (data: unknown) => Promise<bigint>;
-    static is(obj: unknown): obj is SubstrateQueryConfig;
-    constructor({ args, transform, ...other }: QueryConfigConstructorParams);
+  readonly args: any[];
+  readonly transform: (data: any) => Promise<bigint>;
+  constructor({
+    args,
+    transform,
+    type,
+    ...other
+  }: QueryConfigConstructorParams);
 }
 
-type AssetMinConfigBuilder = ConfigBuilder<SubstrateQueryConfig, AssetMinConfigBuilderParams>;
-interface AssetMinConfigBuilderParams {
-    asset: ChainAssetId;
+interface AssetMinConfigBuilder {
+  build: (params: AssetMinConfigBuilderPrams) => SubstrateQueryConfig;
+}
+interface AssetMinConfigBuilderPrams {
+  asset: ChainAssetId;
 }
 
 declare function AssetMinBuilder(): {
-    assetRegistry: typeof assetRegistry;
-    assets: typeof assets$1;
+  assetRegistry: typeof assetRegistry;
+  assets: typeof assets$1;
+  foreignAssets: typeof foreignAssets$1;
 };
 declare function assetRegistry(): {
-    assetMetadatas: () => AssetMinConfigBuilder;
-    currencyMetadatas: () => AssetMinConfigBuilder;
+  assetMetadatas: () => AssetMinConfigBuilder;
+  currencyMetadatas: () => AssetMinConfigBuilder;
 };
 declare function assets$1(): {
-    asset: () => AssetMinConfigBuilder;
+  asset: () => AssetMinConfigBuilder;
+};
+declare function foreignAssets$1(): {
+  asset: () => AssetMinConfigBuilder;
 };
 
-interface ContractConfigConstructorParams extends BaseConfigConstructorParams {
-    address: string;
-    abi: Abi;
-    args: any[];
+interface ContractConfigConstructorParams
+  extends Omit<BaseConfigConstructorParams, 'type'> {
+  args: any[];
+  address?: string;
 }
 declare class ContractConfig extends BaseConfig {
-    readonly address: string;
-    readonly abi: Abi;
-    readonly args: any[];
-    static is(obj: unknown): obj is ContractConfig;
-    constructor({ address, abi, args, ...other }: ContractConfigConstructorParams);
-    encodeFunctionData(): `0x${string}`;
+  readonly args: any[];
+  readonly address?: string;
+  constructor({ args, address, ...other }: ContractConfigConstructorParams);
 }
 
-type ContractConfigBuilder = ConfigBuilder<ContractConfig>;
+interface ContractConfigBuilder {
+  build: (params: ContractConfigBuilderPrams) => ContractConfig;
+}
+interface ContractConfigBuilderPrams {
+  address: string;
+  amount: bigint;
+  asset: ChainAssetId;
+  destination: AnyChain;
+  fee: bigint;
+  feeAsset: ChainAssetId;
+}
 
 declare function Xtokens(): {
-    transfer: (weight?: bigint) => ContractConfigBuilder;
-    transferMultiCurrencies: (weight?: bigint) => ContractConfigBuilder;
-    transferWithEvmTo32: (weight?: bigint) => ContractConfigBuilder;
+  transfer: (weight?: bigint) => ContractConfigBuilder;
+  transferMultiCurrencies: (weight?: bigint) => ContractConfigBuilder;
+  transferWithEvmTo32: (weight?: bigint) => ContractConfigBuilder;
 };
 
 declare function ContractBuilder(): {
-    Xtokens: typeof Xtokens;
+  Xtokens: typeof Xtokens;
 };
 
-type EvmQueryFunctions = 'getBalance';
-type EvmFunctionArgs = Parameters<PublicClient<HttpTransport>[EvmQueryFunctions]>;
-interface EvmQueryConfigParams {
-    readonly args: EvmFunctionArgs;
-    readonly func: EvmQueryFunctions;
+interface BalanceConfigBuilder {
+  build: (
+    params: BalanceConfigBuilderPrams,
+  ) => SubstrateQueryConfig | ContractConfig;
 }
-declare class EvmQueryConfig {
-    readonly args: EvmFunctionArgs;
-    readonly func: EvmQueryFunctions;
-    static is(obj: unknown): obj is EvmQueryConfig;
-    constructor({ args, func }: EvmQueryConfigParams);
-}
-
-type BalanceConfigBuilder = ConfigBuilder<ContractConfig | SubstrateQueryConfig | EvmQueryConfig, BalanceBuilderParams>;
-interface BalanceBuilderParams {
-    address: string;
-    asset: ChainAsset;
+interface BalanceConfigBuilderPrams {
+  address: string;
+  asset: ChainAssetId;
 }
 interface PalletBalancesAccountDataOld extends Struct {
-    readonly free: u128;
-    readonly reserved: u128;
-    readonly miscFrozen: u128;
-    readonly feeFrozen: u128;
+  readonly free: u128;
+  readonly reserved: u128;
+  readonly miscFrozen: u128;
+  readonly feeFrozen: u128;
 }
 interface TokensPalletAccountData {
-    free: u128;
-    reserved: u128;
-    frozen: u128;
+  free: u128;
+  reserved: u128;
+  frozen: u128;
 }
-type EquilibriumSystemBalanceData = Array<[
+type EquilibriumSystemBalanceData = Array<
+  [
     number,
     {
-        positive: number;
-    }
-]>;
+      positive: number;
+    },
+  ]
+>;
 
 declare function BalanceBuilder(): {
-    evm: typeof evm;
-    substrate: typeof substrate;
+  evm: typeof evm;
+  substrate: typeof substrate;
 };
 declare function evm(): {
-    erc20: typeof erc20;
-    native: typeof native;
+  erc20: typeof erc20;
 };
-declare function erc20(): BalanceConfigBuilder;
-declare function native(): BalanceConfigBuilder;
 declare function substrate(): {
-    assets: typeof assets;
-    system: typeof system;
-    tokens: typeof tokens;
+  assets: typeof assets;
+  foreignAssets: typeof foreignAssets;
+  system: typeof system;
+  tokens: typeof tokens;
 };
+declare function erc20(): BalanceConfigBuilder;
 declare function assets(): {
-    account: () => BalanceConfigBuilder;
+  account: () => BalanceConfigBuilder;
+};
+declare function foreignAssets(): {
+  account: () => BalanceConfigBuilder;
 };
 declare function system(): {
-    account: () => BalanceConfigBuilder;
-    accountEquilibrium: () => BalanceConfigBuilder;
-    accountEvmTo32: () => BalanceConfigBuilder;
+  account: () => BalanceConfigBuilder;
+  accountEquilibrium: () => BalanceConfigBuilder;
+  accountEvmTo32: () => BalanceConfigBuilder;
 };
 declare function tokens(): {
-    accounts: () => BalanceConfigBuilder;
+  accounts: () => BalanceConfigBuilder;
 };
-declare function calculateSystemAccountBalance(response: FrameSystemAccountInfo): Promise<bigint>;
-
-declare const ERC20_ABI: readonly [{
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "name";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_spender";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "approve";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "totalSupply";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_from";
-        readonly type: "address";
-    }, {
-        readonly name: "_to";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "transferFrom";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "decimals";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint8";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [{
-        readonly name: "_owner";
-        readonly type: "address";
-    }];
-    readonly name: "balanceOf";
-    readonly outputs: readonly [{
-        readonly name: "balance";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "symbol";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_to";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "transfer";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [{
-        readonly name: "_owner";
-        readonly type: "address";
-    }, {
-        readonly name: "_spender";
-        readonly type: "address";
-    }];
-    readonly name: "allowance";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly payable: true;
-    readonly stateMutability: "payable";
-    readonly type: "fallback";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly name: "spender";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly name: "value";
-        readonly type: "uint256";
-    }];
-    readonly name: "Approval";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly name: "value";
-        readonly type: "uint256";
-    }];
-    readonly name: "Transfer";
-    readonly type: "event";
-}];
+declare function calculateSystemAccountBalance(
+  response: FrameSystemAccountInfo,
+): Promise<bigint>;
 
-interface ExtrinsicConfigConstructorParams extends Omit<BaseConfigConstructorParams, 'type'> {
-    getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
+interface ExtrinsicConfigConstructorParams
+  extends Omit<BaseConfigConstructorParams, 'type'> {
+  getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
 }
 declare class ExtrinsicConfig extends BaseConfig {
-    getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
-    static is(obj: unknown): obj is ExtrinsicConfig;
-    constructor({ getArgs, ...other }: ExtrinsicConfigConstructorParams);
+  getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
+  constructor({ getArgs, ...other }: ExtrinsicConfigConstructorParams);
 }
 
-type ExtrinsicConfigBuilder = ConfigBuilder<ExtrinsicConfig>;
+interface ExtrinsicConfigBuilder {
+  build: (params: ExtrinsicConfigBuilderPrams) => ExtrinsicConfig;
+}
+interface ExtrinsicConfigBuilderPrams {
+  address: string;
+  amount: bigint;
+  asset: ChainAssetId;
+  destination: AnyChain;
+  fee: bigint;
+  feeAsset: ChainAssetId;
+  palletInstance?: number;
+  source: AnyChain;
+}
 declare enum XcmVersion {
-    v1 = "V1",
-    v2 = "V2",
-    v3 = "V3",
-    v4 = "V4",
-    v5 = "V5"
+  v1 = 'V1',
+  v2 = 'V2',
+  v3 = 'V3',
+  v4 = 'V4',
 }
 type Parents = 0 | 1;
 
 declare function eqBalances(): {
-    xcmTransfer: () => ExtrinsicConfigBuilder;
-    transferXcm: () => ExtrinsicConfigBuilder;
+  xcmTransfer: () => ExtrinsicConfigBuilder;
+  transferXcm: () => ExtrinsicConfigBuilder;
 };
 
-declare function polkadotXcm$1(): {
-    limitedReserveTransferAssets: () => {
-        here: () => ExtrinsicConfigBuilder;
-        X1: () => ExtrinsicConfigBuilder;
-        X2: () => ExtrinsicConfigBuilder;
-    };
-    limitedReserveWithdrawAssets: () => {
-        X2: () => ExtrinsicConfigBuilder;
-    };
-    transferAssets: () => {
-        here: () => ExtrinsicConfigBuilder;
-    };
+declare function polkadotXcm(): {
+  limitedReserveTransferAssets: () => {
+    here: () => ExtrinsicConfigBuilder;
+    X1: () => ExtrinsicConfigBuilder;
+    X2: () => ExtrinsicConfigBuilder;
+  };
+  limitedReserveWithdrawAssets: () => {
+    X2: () => ExtrinsicConfigBuilder;
+  };
+  trasferAssets: () => {
+    here: () => ExtrinsicConfigBuilder;
+  };
+  transferAssetsUsingTypeAndThen: () => {
+    globalConcensusEthereum: () => ExtrinsicConfigBuilder;
+  };
 };
 
 declare function xTokens(): {
-    transfer: () => ExtrinsicConfigBuilder;
-    transferMultiAsset: (originParachainId: number) => {
-        here: () => ExtrinsicConfigBuilder;
-        X1: () => ExtrinsicConfigBuilder;
-        X2: () => ExtrinsicConfigBuilder;
-    };
-    transferMultiCurrencies: () => ExtrinsicConfigBuilder;
+  transfer: () => ExtrinsicConfigBuilder;
+  transferMultiAsset: (originParachainId: number) => {
+    here: () => ExtrinsicConfigBuilder;
+    X1: () => ExtrinsicConfigBuilder;
+    X2: () => ExtrinsicConfigBuilder;
+  };
+  transferMultiCurrencies: () => ExtrinsicConfigBuilder;
 };
 
 declare function xTransfer(): {
-    transfer: () => {
-        here: () => ExtrinsicConfigBuilder;
-        X2: () => ExtrinsicConfigBuilder;
-    };
+  transfer: () => {
+    here: () => ExtrinsicConfigBuilder;
+    X2: () => ExtrinsicConfigBuilder;
+  };
 };
 
 declare function xcmPallet(): {
-    limitedReserveTransferAssets: (parents?: Parents) => {
-        here: () => ExtrinsicConfigBuilder;
-    };
-    transferAssetsUsingTypeAndThen: () => {
-        here: () => ExtrinsicConfigBuilder;
-    };
+  limitedReserveTransferAssets: (parents?: Parents) => {
+    here: () => ExtrinsicConfigBuilder;
+  };
+  transferAssetsUsingTypeAndThen: () => {
+    here: () => ExtrinsicConfigBuilder;
+  };
 };
 
 declare function ExtrinsicBuilder(): {
-    eqBalances: typeof eqBalances;
-    xTokens: typeof xTokens;
-    xTransfer: typeof xTransfer;
-    polkadotXcm: typeof polkadotXcm$1;
-    xcmPallet: typeof xcmPallet;
+  eqBalances: typeof eqBalances;
+  xTokens: typeof xTokens;
+  xTransfer: typeof xTransfer;
+  polkadotXcm: typeof polkadotXcm;
+  xcmPallet: typeof xcmPallet;
 };
 
 interface SubstrateCallConfigConstructorParams {
-    api: ApiPromise;
-    call: () => Promise<bigint>;
+  api: ApiPromise;
+  call: () => Promise<bigint>;
 }
 declare class SubstrateCallConfig {
-    readonly api: ApiPromise;
-    readonly call: () => Promise<any>;
-    static is(obj: unknown): obj is SubstrateCallConfig;
-    constructor({ api, call }: SubstrateCallConfigConstructorParams);
+  readonly api: ApiPromise;
+  readonly call: () => Promise<any>;
+  readonly type = CallType.Substrate;
+  constructor({ api, call }: SubstrateCallConfigConstructorParams);
 }
 
-type FeeConfigBuilder = ConfigBuilder<SubstrateCallConfig, FeeConfigBuilderParams>;
-interface FeeConfigBuilderParams {
-    address: string;
-    api: ApiPromise;
-    asset: ChainAsset;
-    destination: AnyParachain;
-    feeAsset: ChainAsset;
+interface FeeConfigBuilder {
+  build: (params: FeeConfigBuilderPrams) => SubstrateCallConfig;
+}
+interface FeeConfigBuilderPrams {
+  address: string;
+  api: ApiPromise;
+  feeAsset: ChainAssetId;
+  transferAsset: ChainAssetId;
+  chain: AnyParachain;
 }
 interface XcmPaymentFeeProps {
-    isAssetReserveChain: boolean;
-    shouldTransferAssetPrecedeFeeAsset?: boolean;
+  isAssetReserveChain: boolean;
+  shouldTransferAssetPrecedeAsset?: boolean;
 }
 interface MoonbeamRuntimeXcmConfigAssetType extends Enum {
-    readonly isXcm: boolean;
-    readonly asXcm: StagingXcmV3MultiLocation;
-    readonly type: 'Xcm';
+  readonly isXcm: boolean;
+  readonly asXcm: StagingXcmV3MultiLocation;
+  readonly type: 'Xcm';
 }
 
 declare function FeeBuilder(): {
-    xcmPaymentApi: typeof xcmPaymentApi;
+  xcmPaymentApi: typeof xcmPaymentApi;
 };
 declare function xcmPaymentApi(): {
-    xcmPaymentFee: ({ isAssetReserveChain, shouldTransferAssetPrecedeFeeAsset, }: XcmPaymentFeeProps) => FeeConfigBuilder;
+  xcmPaymentFee: ({
+    isAssetReserveChain,
+    shouldTransferAssetPrecedeAsset,
+  }: XcmPaymentFeeProps) => FeeConfigBuilder;
 };
 
-declare function wormhole$1(): {
-    tokenTransfer: () => MrlConfigBuilder;
+export {
+  AssetMinBuilder,
+  type AssetMinConfigBuilder,
+  type AssetMinConfigBuilderPrams,
+  BalanceBuilder,
+  type BalanceConfigBuilder,
+  type BalanceConfigBuilderPrams,
+  BaseConfig,
+  type BaseConfigConstructorParams,
+  CallType,
+  ContractBuilder,
+  ContractConfig,
+  type ContractConfigBuilder,
+  type ContractConfigBuilderPrams,
+  type ContractConfigConstructorParams,
+  type EquilibriumSystemBalanceData,
+  ExtrinsicBuilder,
+  ExtrinsicConfig,
+  type ExtrinsicConfigBuilder,
+  type ExtrinsicConfigBuilderPrams,
+  type ExtrinsicConfigConstructorParams,
+  FeeBuilder,
+  type FeeConfigBuilder,
+  type FeeConfigBuilderPrams,
+  type MoonbeamRuntimeXcmConfigAssetType,
+  type PalletBalancesAccountDataOld,
+  type Parents,
+  type QueryConfigConstructorParams,
+  SubstrateQueryConfig,
+  type TokensPalletAccountData,
+  type XcmPaymentFeeProps,
+  XcmVersion,
+  calculateSystemAccountBalance,
+  evm,
+  substrate,
 };
-
-type WormholeTransferFunctions = 'tokenTransfer';
-type WormholeFunctionArgs = Parameters<Wormhole<Network>[WormholeTransferFunctions]>;
-interface WormholeConfigConstructorParams {
-    args: WormholeFunctionArgs;
-    func: WormholeTransferFunctions;
-}
-declare class WormholeConfig {
-    readonly args: WormholeFunctionArgs;
-    readonly func: WormholeTransferFunctions;
-    static is(obj: unknown): obj is WormholeConfig;
-    constructor({ args, func }: WormholeConfigConstructorParams);
-}
-
-declare function wormholeFactory(chain: AnyChain): Wormhole<"Mainnet" | "Testnet">;
-
-type MrlConfigBuilder = ConfigBuilder<ContractConfig | ExtrinsicConfig | WormholeConfig, MrlBuilderParams>;
-type MrlRedeemConfigBuilder = ConfigBuilder<ContractConfig, MrlRedeemBuilderParams>;
-interface MrlBuilderParams extends BuilderParams<AnyChain> {
-    isAutomatic: boolean;
-    moonApi: ApiPromise;
-    moonAsset: ChainAsset;
-    moonChain: EvmParachain;
-    moonGasLimit?: bigint;
-    transact?: Transact;
-}
-interface MrlRedeemBuilderParams {
-    bytes?: Uint8Array;
-}
-interface Transact {
-    call: HexString;
-    txWeight: {
-        refTime: bigint;
-        proofSize: bigint;
-    };
-}
-
-declare function Batch(): {
-    transferAssetsAndMessage: () => MrlConfigBuilder;
-};
-
-declare function Gmp(): {
-    wormholeTransferERC20: () => MrlRedeemConfigBuilder;
-};
-
-declare function TokenBridge(): {
-    transferTokens: () => MrlConfigBuilder;
-};
-
-declare function TokenBridgeRelayer(): {
-    transferTokensWithRelay: () => MrlConfigBuilder;
-};
-
-declare function contract(): {
-    Batch: typeof Batch;
-    Gmp: typeof Gmp;
-    TokenBridge: typeof TokenBridge;
-    TokenBridgeRelayer: typeof TokenBridgeRelayer;
-};
-
-declare function ethereumXcm(): {
-    transact: () => MrlConfigBuilder;
-};
-
-declare function polkadotXcm(): {
-    send: () => MrlConfigBuilder;
-};
-
-declare function extrinsic(): {
-    ethereumXcm: typeof ethereumXcm;
-    polkadotXcm: typeof polkadotXcm;
-};
-
-declare const BATCH_CONTRACT_ABI: readonly [{
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: false;
-        readonly internalType: "uint256";
-        readonly name: "index";
-        readonly type: "uint256";
-    }];
-    readonly name: "SubcallFailed";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: false;
-        readonly internalType: "uint256";
-        readonly name: "index";
-        readonly type: "uint256";
-    }];
-    readonly name: "SubcallSucceeded";
-    readonly type: "event";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address[]";
-        readonly name: "to";
-        readonly type: "address[]";
-    }, {
-        readonly internalType: "uint256[]";
-        readonly name: "value";
-        readonly type: "uint256[]";
-    }, {
-        readonly internalType: "bytes[]";
-        readonly name: "callData";
-        readonly type: "bytes[]";
-    }, {
-        readonly internalType: "uint64[]";
-        readonly name: "gasLimit";
-        readonly type: "uint64[]";
-    }];
-    readonly name: "batchAll";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address[]";
-        readonly name: "to";
-        readonly type: "address[]";
-    }, {
-        readonly internalType: "uint256[]";
-        readonly name: "value";
-        readonly type: "uint256[]";
-    }, {
-        readonly internalType: "bytes[]";
-        readonly name: "callData";
-        readonly type: "bytes[]";
-    }, {
-        readonly internalType: "uint64[]";
-        readonly name: "gasLimit";
-        readonly type: "uint64[]";
-    }];
-    readonly name: "batchSome";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address[]";
-        readonly name: "to";
-        readonly type: "address[]";
-    }, {
-        readonly internalType: "uint256[]";
-        readonly name: "value";
-        readonly type: "uint256[]";
-    }, {
-        readonly internalType: "bytes[]";
-        readonly name: "callData";
-        readonly type: "bytes[]";
-    }, {
-        readonly internalType: "uint64[]";
-        readonly name: "gasLimit";
-        readonly type: "uint64[]";
-    }];
-    readonly name: "batchSomeUntilFailure";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}];
-
-declare function wormhole(): {
-    contract: typeof contract;
-    extrinsic: typeof extrinsic;
-    wormhole: typeof wormhole$1;
-};
-
-declare function MrlBuilder(): {
-    wormhole: typeof wormhole;
-};
-
-declare const BATCH_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000808";
-
-export { AssetMinBuilder, type AssetMinConfigBuilder, type AssetMinConfigBuilderParams, BATCH_CONTRACT_ABI, BATCH_CONTRACT_ADDRESS, BalanceBuilder, type BalanceBuilderParams, type BalanceConfigBuilder, type BuilderParams, type ConfigBuilder, ContractBuilder, ContractConfig, type ContractConfigBuilder, type ContractConfigConstructorParams, ERC20_ABI, type EquilibriumSystemBalanceData, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlRedeemBuilderParams, type MrlRedeemConfigBuilder, type PalletBalancesAccountDataOld, type Parents, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };