@moonbeam-network/xcm-builder 1.0.0-dev.16 → 1.0.0-dev.161

package/build/index.d.ts

@@ -1,277 +1,618 @@
-import { ChainAssetId, AnyChain } from '@moonbeam-network/xcm-types';
-import { SetOptional } from 'type-fest';
-import { Struct, u128 } from '@polkadot/types';
-import { SubmittableExtrinsicFunction } from '@polkadot/api/types';
+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 { 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';
 
-declare enum CallType {
-  Evm = 'Evm',
-  Substrate = 'Substrate',
+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;
 }
 
 interface BaseConfigConstructorParams {
-  module: string;
-  func: string;
-  type: CallType;
+    module: string;
+    func: string;
 }
 declare class BaseConfig {
-  readonly module: string;
-  readonly func: string;
-  readonly type: CallType;
-  constructor({ module, func, type }: BaseConfigConstructorParams);
+    readonly module: string;
+    readonly func: string;
+    constructor({ module, func }: BaseConfigConstructorParams);
 }
 
-interface QueryConfigConstructorParams
-  extends SetOptional<BaseConfigConstructorParams, 'type'> {
-  args?: any[];
-  transform: (data: any) => Promise<bigint>;
+interface QueryConfigConstructorParams extends BaseConfigConstructorParams {
+    args?: unknown[];
+    transform: (data: any) => Promise<bigint>;
 }
 declare class SubstrateQueryConfig extends BaseConfig {
-  readonly args: any[];
-  readonly transform: (data: any) => Promise<bigint>;
-  constructor({
-    args,
-    transform,
-    type,
-    ...other
-  }: QueryConfigConstructorParams);
+    readonly args: unknown[];
+    readonly transform: (data: unknown) => Promise<bigint>;
+    static is(obj: unknown): obj is SubstrateQueryConfig;
+    constructor({ args, transform, ...other }: QueryConfigConstructorParams);
 }
 
-interface AssetMinConfigBuilder {
-  build: (params: AssetMinConfigBuilderPrams) => SubstrateQueryConfig;
-}
-interface AssetMinConfigBuilderPrams {
-  asset: ChainAssetId;
+type AssetMinConfigBuilder = ConfigBuilder<SubstrateQueryConfig, AssetMinConfigBuilderParams>;
+interface AssetMinConfigBuilderParams {
+    address?: string;
+    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 Omit<BaseConfigConstructorParams, 'type'> {
-  args: any[];
-  address?: string;
+interface ContractConfigConstructorParams extends BaseConfigConstructorParams {
+    address: string;
+    abi: Abi;
+    args: any[];
 }
 declare class ContractConfig extends BaseConfig {
-  readonly args: any[];
-  readonly address?: string;
-  constructor({ args, address, ...other }: ContractConfigConstructorParams);
+    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}`;
 }
 
-interface ContractConfigBuilder {
-  build: (params: ContractConfigBuilderPrams) => ContractConfig;
-}
-interface ContractConfigBuilderPrams {
-  address: string;
-  amount: bigint;
-  asset: ChainAssetId;
-  destination: AnyChain;
-  fee: bigint;
-  feeAsset: ChainAssetId;
-}
+type ContractConfigBuilder = ConfigBuilder<ContractConfig>;
 
 declare function Xtokens(): {
-  transfer: (weight?: number) => ContractConfigBuilder;
-  transferMultiCurrencies: (weight?: number) => ContractConfigBuilder;
+    transfer: (weight?: bigint) => ContractConfigBuilder;
+    transferMultiCurrencies: (weight?: bigint) => ContractConfigBuilder;
+    transferWithEvmTo32: (weight?: bigint) => ContractConfigBuilder;
 };
 
 declare function ContractBuilder(): {
-  Xtokens: typeof Xtokens;
+    Xtokens: typeof Xtokens;
 };
 
-interface BalanceConfigBuilder {
-  build: (
-    params: BalanceConfigBuilderPrams,
-  ) => SubstrateQueryConfig | ContractConfig;
+type EvmQueryFunctions = 'getBalance';
+type EvmFunctionArgs = Parameters<PublicClient<HttpTransport>[EvmQueryFunctions]>;
+interface EvmQueryConfigParams {
+    readonly args: EvmFunctionArgs;
+    readonly func: EvmQueryFunctions;
 }
-interface BalanceConfigBuilderPrams {
-  address: string;
-  asset: ChainAssetId;
+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 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;
+    erc20: typeof erc20;
+    native: typeof native;
 };
+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;
+    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";
+}];
 
-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[];
-  constructor({ getArgs, ...other }: ExtrinsicConfigConstructorParams);
+    getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
+    static is(obj: unknown): obj is ExtrinsicConfig;
+    constructor({ getArgs, ...other }: ExtrinsicConfigConstructorParams);
 }
 
-interface ExtrinsicConfigBuilder {
-  build: (params: ExtrinsicConfigBuilderPrams) => ExtrinsicConfig;
-}
-interface ExtrinsicConfigBuilderPrams {
-  address: string;
-  amount: bigint;
-  asset: ChainAssetId;
-  destination: AnyChain;
-  fee: bigint;
-  feeAsset: ChainAssetId;
-  palletInstance?: number;
-  source: AnyChain;
-}
+type ExtrinsicConfigBuilder = ConfigBuilder<ExtrinsicConfig>;
 declare enum XcmVersion {
-  v1 = 'V1',
-  v2 = 'V2',
-  v3 = 'V3',
+    v1 = "V1",
+    v2 = "V2",
+    v3 = "V3",
+    v4 = "V4",
+    v5 = "V5"
 }
 type Parents = 0 | 1;
 
 declare function eqBalances(): {
-  xcmTransfer: () => ExtrinsicConfigBuilder;
-  transferXcm: () => ExtrinsicConfigBuilder;
+    xcmTransfer: () => ExtrinsicConfigBuilder;
+    transferXcm: () => ExtrinsicConfigBuilder;
 };
 
-declare function polkadotXcm(): {
-  limitedReserveTransferAssets: () => {
-    here: () => ExtrinsicConfigBuilder;
-    X1: () => ExtrinsicConfigBuilder;
-    X2: () => ExtrinsicConfigBuilder;
-  };
-  limitedReserveWithdrawAssets: () => {
-    X2: () => ExtrinsicConfigBuilder;
-  };
+declare function polkadotXcm$1(): {
+    limitedReserveTransferAssets: () => {
+        here: () => ExtrinsicConfigBuilder;
+        X1: () => ExtrinsicConfigBuilder;
+        X2: () => ExtrinsicConfigBuilder;
+    };
+    limitedReserveWithdrawAssets: () => {
+        X2: () => ExtrinsicConfigBuilder;
+    };
+    transferAssets: () => {
+        here: () => ExtrinsicConfigBuilder;
+    };
+    transferAssetsUsingTypeAndThen: () => {
+        globalConsensusEthereum: () => ExtrinsicConfigBuilder;
+    };
 };
 
 declare function xTokens(): {
-  transfer: () => ExtrinsicConfigBuilder;
-  transferMultiAsset: (originParachainId: number) => {
-    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;
-  };
+    limitedReserveTransferAssets: (parents?: Parents) => {
+        here: () => ExtrinsicConfigBuilder;
+    };
+    transferAssetsUsingTypeAndThen: () => {
+        here: () => ExtrinsicConfigBuilder;
+    };
 };
 
 declare function ExtrinsicBuilder(): {
-  eqBalances: typeof eqBalances;
-  xTokens: typeof xTokens;
-  xTransfer: typeof xTransfer;
-  polkadotXcm: typeof polkadotXcm;
-  xcmPallet: typeof xcmPallet;
+    eqBalances: typeof eqBalances;
+    xTokens: typeof xTokens;
+    xTransfer: typeof xTransfer;
+    polkadotXcm: typeof polkadotXcm$1;
+    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>;
-  readonly type = CallType.Substrate;
-  constructor({ api, call }: SubstrateCallConfigConstructorParams);
+    readonly api: ApiPromise;
+    readonly call: () => Promise<any>;
+    static is(obj: unknown): obj is SubstrateCallConfig;
+    constructor({ api, call }: SubstrateCallConfigConstructorParams);
 }
 
-interface FeeConfigBuilder {
-  build: (params: FeeConfigBuilderPrams) => SubstrateCallConfig;
+type FeeConfigBuilder = ConfigBuilder<SubstrateCallConfig, FeeConfigBuilderParams>;
+interface FeeConfigBuilderParams {
+    address: string;
+    api: ApiPromise;
+    asset: ChainAsset;
+    destination: AnyParachain;
+    feeAsset: ChainAsset;
+}
+interface XcmPaymentFeeProps {
+    isAssetReserveChain: boolean;
+    shouldTransferAssetPrecedeFeeAsset?: boolean;
 }
-interface FeeConfigBuilderPrams {
-  asset: ChainAssetId;
-  api: ApiPromise;
+interface MoonbeamRuntimeXcmConfigAssetType extends Enum {
+    readonly isXcm: boolean;
+    readonly asXcm: StagingXcmV3MultiLocation;
+    readonly type: 'Xcm';
 }
 
 declare function FeeBuilder(): {
-  assetManager: typeof assetManager;
-};
-declare function assetManager(): {
-  assetTypeUnitsPerSecond: (weight?: number) => FeeConfigBuilder;
-};
-
-export {
-  AssetMinBuilder,
-  AssetMinConfigBuilder,
-  AssetMinConfigBuilderPrams,
-  BalanceBuilder,
-  BalanceConfigBuilder,
-  BalanceConfigBuilderPrams,
-  BaseConfig,
-  BaseConfigConstructorParams,
-  CallType,
-  ContractBuilder,
-  ContractConfig,
-  ContractConfigBuilder,
-  ContractConfigBuilderPrams,
-  ContractConfigConstructorParams,
-  EquilibriumSystemBalanceData,
-  ExtrinsicBuilder,
-  ExtrinsicConfig,
-  ExtrinsicConfigBuilder,
-  ExtrinsicConfigBuilderPrams,
-  ExtrinsicConfigConstructorParams,
-  FeeBuilder,
-  FeeConfigBuilder,
-  FeeConfigBuilderPrams,
-  PalletBalancesAccountDataOld,
-  Parents,
-  QueryConfigConstructorParams,
-  SubstrateQueryConfig,
-  TokensPalletAccountData,
-  XcmVersion,
-  evm,
-  substrate,
+    xcmPaymentApi: typeof xcmPaymentApi;
+};
+declare function xcmPaymentApi(): {
+    xcmPaymentFee: ({ isAssetReserveChain, shouldTransferAssetPrecedeFeeAsset, }: XcmPaymentFeeProps) => FeeConfigBuilder;
+};
+
+declare function wormhole$1(): {
+    tokenTransfer: () => MrlConfigBuilder;
+};
+
+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;
+    sendOnlyRemoteExecution?: boolean;
+    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 };