@moonbeam-network/xcm-config 0.5.0 → 1.0.1

package/build/index.d.ts

@@ -1,1771 +1,256 @@
-import { Type, u128, Struct } from '@polkadot/types';
-import { PalletBalancesAccountData } from '@polkadot/types/lookup';
-import { SubmittableExtrinsicFunction } from '@polkadot/api/types';
-
-declare enum AssetSymbol {
-  ACA = 'ACA',
-  ASTR = 'ASTR',
-  AUQ = 'AUQ',
-  AUSD = 'AUSD',
-  BIT = 'BIT',
-  BNC = 'BNC',
-  CRAB = 'CRAB',
-  CSM = 'CSM',
-  DEV = 'DEV',
-  DOT = 'DOT',
-  EQ = 'EQ',
-  EQD = 'EQD',
-  GLMR = 'GLMR',
-  HDX = 'HDX',
-  HKO = 'HKO',
-  IBTC = 'IBTC',
-  INTR = 'INTR',
-  KAR = 'KAR',
-  KBTC = 'KBTC',
-  KINT = 'KINT',
-  KMA = 'KMA',
-  KSM = 'KSM',
-  KUSD = 'KUSD',
-  LIT = 'LIT',
-  MOVR = 'MOVR',
-  NEER = 'NEER',
-  PARA = 'PARA',
-  PARING = 'PARING',
-  PHA = 'PHA',
-  RING = 'RING',
-  RMRK = 'RMRK',
-  SDN = 'SDN',
-  TEER = 'TEER',
-  TT1 = 'TT1',
-  UNIT = 'UNIT',
-  USDT = 'USDT',
-  XRT = 'XRT',
-}
-
-type AssetId = number | bigint | string;
-interface Asset<Symbols extends AssetSymbol = AssetSymbol> {
-  id: string;
-  /**
-   * Foreign assets id -> erc20Id
-   * `0xffffffff${BigInt(id).toString(16).padStart(32, '0')}`
-   * Local assets id -> erc20Id
-   * `0xfffffffe${BigInt(id).toString(16).padStart(32, '0')}`
-   * exceptions are native tokens, for them we use
-   * Erc20BalancesPrecompile 0x0000000000000000000000000000000000000802
-   */
-  erc20Id: string;
-  foreignIds?: Partial<Record<ChainKey, AssetId>>;
-  originSymbol: Symbols;
-  isNative?: boolean;
-  isLocalAsset?: boolean;
-}
-interface ChainBase<ChainKeys extends ChainKey | MoonChainKey> {
-  key: ChainKeys;
-  name: string;
-  ws: string;
-  parachainId: number;
-  weights?: {
-    descendOriginWeight: bigint;
-    withdrawAssetWeight: bigint;
-    buyExecutionWeight: bigint;
-    transactWeight: bigint;
-  };
-}
-interface MoonChain extends ChainBase<MoonChainKey> {
-  chainId: number;
-  decimals: number;
-  unitsPerSecond: bigint;
-}
-interface Chain<ChainKeys extends ChainKey = ChainKey>
-  extends ChainBase<ChainKeys> {
-  weight: number;
-  moonAssetId?: number | bigint;
-  palletInstance?: number;
-  /**
-   * units per second - a number of units per second
-   * unitsPerSecond = weightPerSecond * baseExtrinsicCost / baseExtrinsicWeight
-   */
-  unitsPerSecond?: bigint;
-  ss58Format?: number;
-  usesEthereumAccounts?: boolean;
-  genesisHash: string;
-  assetsDecimals?: Record<string, number>;
-}
-interface XcmFeeAsset<Symbols extends AssetSymbol = AssetSymbol> {
-  balance: BalanceConfig<Symbols>;
-  asset: Asset<Symbols>;
-}
-
-declare enum MoonChainKey {
-  MoonbaseAlpha = 'MoonbaseAlpha',
-  Moonbeam = 'Moonbeam',
-  Moonriver = 'Moonriver',
-}
-declare const MOON_CHAINS: Record<MoonChainKey, MoonChain>;
-declare enum ChainKey {
-  Acala = 'Acala',
-  AlphanetRelay = 'AlphanetRelay',
-  Astar = 'Astar',
-  Bifrost = 'Bifrost',
-  BitCountryPioneer = 'BitCountryPioneer',
-  BifrostPolkadot = 'BifrostPolkadot',
-  Calamari = 'Calamari',
-  Crab = 'Crab',
-  CrustShadow = 'CrustShadow',
-  Darwinia = 'Darwinia',
-  DarwiniaPangoro = 'DarwiniaPangoro',
-  Equilibrium = 'Equilibrium',
-  EquilibriumAlphanet = 'EquilibriumAlphanet',
-  HydraDX = 'HydraDX',
-  Integritee = 'Integritee',
-  Interlay = 'Interlay',
-  Karura = 'Karura',
-  Khala = 'Khala',
-  Kintsugi = 'Kintsugi',
-  Kusama = 'Kusama',
-  LitentryAlphanet = 'LitentryAlphanet',
-  Litmus = 'Litmus',
-  MoonbaseBeta = 'MoonbaseBeta',
-  Parallel = 'Parallel',
-  ParallelHeiko = 'ParallelHeiko',
-  Phala = 'Phala',
-  Polkadot = 'Polkadot',
-  Robonomics = 'Robonomics',
-  Shiden = 'Shiden',
-  Statemine = 'Statemine',
-  StatemineAlphanet = 'StatemineAlphanet',
-  Statemint = 'Statemint',
-  UniqueAlpha = 'UniqueAlpha',
-}
-
-declare enum BalancePallet {
-  Assets = 'assets',
-  AssetRegistry = 'assetRegistry',
-  OrmlTokens = 'ormlTokens',
-  System = 'system',
-  Tokens = 'tokens',
-}
-declare enum BalanceFunction {
-  Account = 'account',
-  Accounts = 'accounts',
-  Asset = 'asset',
-  AssetMetadatas = 'assetMetadatas',
-  CurrencyMetadatas = 'currencyMetadatas',
-}
-declare enum BalanceCurrencyTypes {
-  Token = 'Token',
-  Token2 = 'Token2',
-  ForeignAsset = 'ForeignAsset',
-  NativeToken = 'NativeToken',
-  MiningResource = 'MiningResource',
-  FungibleToken = 'FungibleToken',
-}
-
-type BalanceConfig<Symbols extends AssetSymbol = AssetSymbol> =
-  | SystemBalanceConfig
-  | AssetsBalanceConfig
-  | EquilibriumSystemBalanceConfig
-  | OrmlTokensBalanceConfig
-  | TokensBalanceConfig<Symbols>;
-interface SystemBalanceConfig<Data = PalletBalancesAccountData> {
-  pallet: BalancePallet.System;
-  function: BalanceFunction.Account;
-  path: ['data'];
-  getParams: (account: string) => [string];
-  calc: (data: Data) => bigint;
-}
-type EquilibriumSystemBalanceConfig = SystemBalanceConfig<Type>;
-type EquilibriumSystemBalanceData = Array<
-  [
-    number,
-    {
-      positive: number;
-    },
-  ]
->;
-interface AssetsBalanceConfig {
-  pallet: BalancePallet.Assets;
-  function: BalanceFunction.Account;
-  path: ['balance'];
-  getParams: (account: string) => [AssetId, string];
-  calc: (balance: u128) => bigint;
-}
-interface TokensPalletAccountData {
-  free: u128;
-  reserved: u128;
-  frozen: u128;
-}
-interface OrmlTokensBalanceConfig {
-  pallet: BalancePallet.OrmlTokens;
-  function: BalanceFunction.Accounts;
-  path: [];
-  getParams: (account: string) => [
-    string,
-    {
-      ForeignAsset: AssetId;
-    },
-  ];
-  calc: (data: TokensPalletAccountData) => bigint;
-}
-interface TokensBalanceConfig<Symbols extends AssetSymbol = AssetSymbol> {
-  pallet: BalancePallet.Tokens;
-  function: BalanceFunction.Accounts;
-  path: [];
-  getParams: (account: string) => [string, TokensBalanceParamAsset<Symbols>];
-  calc: (data: TokensPalletAccountData) => bigint;
-}
-type TokensBalanceParamAsset<Symbols extends AssetSymbol = AssetSymbol> =
-  | {
-      [BalanceCurrencyTypes.Token]: Symbols | AssetSymbol.KUSD;
-    }
-  | {
-      [BalanceCurrencyTypes.ForeignAsset]: AssetId;
-    }
-  | {
-      [BalanceCurrencyTypes.MiningResource]: AssetId;
-    }
-  | {
-      [BalanceCurrencyTypes.FungibleToken]: AssetId;
-    }
-  | {
-      [BalanceCurrencyTypes.Token2]: AssetId;
-    }
-  | AssetId;
-type MinBalanceConfig = MinBalanceAssetsConfig | MinBalanceAssetRegistryConfig;
-interface MinBalanceAssetsConfig {
-  pallet: BalancePallet.Assets;
-  function: BalanceFunction.Asset;
-  path: ['minBalance'];
-  params: [AssetId];
-}
-interface MinBalanceAssetRegistryConfig {
-  pallet: BalancePallet.AssetRegistry;
-  function: BalanceFunction.AssetMetadatas | BalanceFunction.CurrencyMetadatas;
-  path: ['minimalBalance'];
-  params: [
-    | {
-        ForeignAssetId: AssetId;
-      }
-    | {
-        Token2: AssetId;
-      },
-  ];
-}
-interface PalletBalancesAccountDataOld extends Struct {
-  readonly free: u128;
-  readonly reserved: u128;
-  readonly miscFrozen: u128;
-  readonly feeFrozen: u128;
-}
-
-declare function createBalanceBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
->(): {
-  assets: typeof assets;
-  minAssetPallet: typeof minAssetPallet;
-  minAssetRegistryPallet: typeof minAssetRegistryPallet;
-  minCurrencyMetadata: typeof minCurrencyMetadata;
-  ormlTokens: typeof ormlTokens;
-  system: typeof system;
-  systemEquilibrium: typeof systemEquilibrium;
-  tokens: () => {
-    tokensBase: (asset: AssetId | Symbols) => TokensBalanceConfig<Symbols>;
-    foreignAsset: (asset: AssetId | Symbols) => TokensBalanceConfig<Symbols>;
-    fungibleToken: (asset: AssetId) => TokensBalanceConfig<Symbols>;
-    miningResource: (asset: AssetId) => TokensBalanceConfig<Symbols>;
-    token: (asset: AssetSymbol.KUSD | Symbols) => TokensBalanceConfig<Symbols>;
-    token2: (asset: AssetId) => TokensBalanceConfig<Symbols>;
-  };
-};
-declare function assets(asset: AssetId): AssetsBalanceConfig;
-declare function minAssetPallet(asset: AssetId): MinBalanceAssetsConfig;
-declare function minAssetRegistryPallet(
-  asset: AssetId,
-): MinBalanceAssetRegistryConfig;
-declare function minCurrencyMetadata(
-  asset: AssetId,
-): MinBalanceAssetRegistryConfig;
-declare function ormlTokens(asset: AssetId): OrmlTokensBalanceConfig;
-declare function system(): SystemBalanceConfig;
-declare function systemEquilibrium(id: number): EquilibriumSystemBalanceConfig;
-
-type Parents = 0 | 1;
-interface XcmExtrinsicGetParams {
-  account: string;
-  amount: bigint;
-  extrinsicCall?: SubmittableExtrinsicFunction<'promise'>;
-  fee?: bigint;
-}
-declare enum XcmVersion {
-  v1 = 'V1',
-  v2 = 'V2',
-  v3 = 'V3',
-}
-
-declare enum ExtrinsicPallet {
-  PolkadotXcm = 'polkadotXcm',
-  XcmPallet = 'xcmPallet',
-  XTokens = 'xTokens',
-  XTransfer = 'xTransfer',
-  EqBalances = 'eqBalances',
-}
-
-declare enum PolkadotXcmExtrinsic {
-  LimitedReserveTransferAssets = 'limitedReserveTransferAssets',
-  LimitedReserveWithdrawAssets = 'limitedReserveWithdrawAssets',
-}
-declare enum PolkadotXcmExtrinsicSuccessEvent {
-  Attempted = 'Attempted',
-}
-
-interface PolkadotXcmPallet {
-  pallet: ExtrinsicPallet.PolkadotXcm;
-  extrinsic: PolkadotXcmExtrinsic;
-  successEvent: PolkadotXcmExtrinsicSuccessEvent;
-  getParams: (params: XcmExtrinsicGetParams) => PolkadotXcmPalletParams;
-}
-type PolkadotXcmPalletParams = [
-  /**
-   * destination
-   */
-  {
-    [v in XcmVersion]?: {
-      parents: Parents;
-      interior: {
-        X1: {
-          Parachain: number;
-        };
-      };
-    };
-  },
-  /**
-   * beneficiary
-   */
-  {
-    [v in XcmVersion]?: {
-      parents: 0;
-      interior: {
-        X1: {
-          AccountKey20: {
-            network: 'Any';
-            /**
-             * account
-             */
-            key: string;
-          };
-        };
-      };
-    };
-  },
-  /**
-   * asset
-   */
-  {
-    [v in XcmVersion]?: PolkadotXcmAssetParam[];
-  },
-  /**
-   * fee
-   */
-  0,
-  /**
-   * weight
-   */
-  'Unlimited',
-];
-type PolkadotXcmAssetParam = {
-  id: {
-    Concrete: {
-      parents: Parents;
-      interior:
-        | 'Here'
-        | PolkadotXcmAssetParamInteriorX1
-        | PolkadotXcmAssetParamInteriorX2;
-    };
-  };
-  fun: {
-    Fungible: bigint;
-  };
-};
-interface PolkadotXcmAssetParamInteriorX1 {
-  X1: {
-    PalletInstance: number;
-  };
-}
-interface PolkadotXcmAssetParamInteriorX2 {
-  X2:
-    | [
-        {
-          PalletInstance: number;
-        },
-        {
-          GeneralIndex: AssetId;
-        },
-      ]
-    | [
-        {
-          Parachain: number;
-        },
-        {
-          PalletInstance: number;
-        },
-      ];
-}
-
-declare function polkadotXcm(chain: MoonChain): {
-  limitedReserveTransferAssets: () => {
-    successEvent: (event: PolkadotXcmExtrinsicSuccessEvent) => {
-      V1V2: () => {
-        here: () => PolkadotXcmPallet;
-        X1: () => PolkadotXcmPallet;
-        X2: (palletInstance: number, assetId: AssetId) => PolkadotXcmPallet;
-      };
-    };
-  };
-  limitedReserveWithdrawAssets: () => {
-    successEvent: (event: PolkadotXcmExtrinsicSuccessEvent) => {
-      V1V2: () => {
-        X2: (palletInstance: number) => PolkadotXcmPallet;
-      };
-    };
-  };
-};
-
-declare function getCreateV1V2Extrinsic(
-  extrinsic: PolkadotXcmExtrinsic,
-  event: PolkadotXcmExtrinsicSuccessEvent,
-  config: MoonChain,
-  parents?: Parents,
-): (getAsset: (amount: bigint) => PolkadotXcmAssetParam[]) => PolkadotXcmPallet;
-
-declare function xcmPallet(chain: MoonChain): {
-  limitedReserveTransferAssets: () => {
-    successEvent: (event: PolkadotXcmExtrinsicSuccessEvent) => {
-      pallet: ExtrinsicPallet;
-      extrinsic: PolkadotXcmExtrinsic;
-      successEvent: PolkadotXcmExtrinsicSuccessEvent;
-      getParams: (params: XcmExtrinsicGetParams) => PolkadotXcmPalletParams;
-    };
-  };
-};
-
-interface XcmPallet extends Omit<PolkadotXcmPallet, 'pallet'> {
-  pallet: ExtrinsicPallet.XcmPallet;
-}
-
-declare enum XTokensExtrinsic {
-  Transfer = 'transfer',
-  TransferMultiAsset = 'transferMultiasset',
-  TransferMultiCurrencies = 'transferMulticurrencies',
-}
-declare enum XTokensExtrinsicSuccessEvent {
-  Transferred = 'Transferred',
-  TransferredMultiAssets = 'TransferredMultiAssets',
-  TransferredMultiCurrencies = 'TransferredMultiCurrencies',
-}
-declare enum XTokensExtrinsicCurrencyTypes {
-  ForeignAsset = 'ForeignAsset',
-  FungibleToken = 'FungibleToken',
-  MantaCurrency = 'MantaCurrency',
-  MiningResource = 'MiningResource',
-  Native = 'Native',
-  NativeAssetId = 'NativeAssetId',
-  NativeToken = 'NativeToken',
-  OtherReserve = 'OtherReserve',
-  Token = 'Token',
-  Token2 = 'Token2',
-}
-
-type XTokensPallet<Symbols extends AssetSymbol = AssetSymbol> =
-  | XTokensTransferExtrinsic<Symbols>
-  | XTokensTransferMultiAssetExtrinsic<Symbols>
-  | XTokensTransferMultiCurrenciesExtrinsic<Symbols>;
-type XTokensTransferExtrinsic<Symbols extends AssetSymbol = AssetSymbol> =
-  XTokensBaseExtrinsic<XTokensExtrinsic.Transfer, Symbols>;
-type XTokensTransferMultiAssetExtrinsic<
-  Symbols extends AssetSymbol = AssetSymbol,
-> = XTokensBaseExtrinsic<XTokensExtrinsic.TransferMultiAsset, Symbols>;
-type XTokensTransferMultiCurrenciesExtrinsic<
-  Symbols extends AssetSymbol = AssetSymbol,
-> = XTokensBaseExtrinsic<XTokensExtrinsic.TransferMultiCurrencies, Symbols>;
-type XTokensWeightLimit =
-  | number
-  | {
-      Limited: number;
-    }
-  | {
-      Limited: {
-        refTime: number;
-        proofSize: number;
-      };
-    };
-interface XTokensBaseExtrinsic<
-  Extrinsic extends XTokensExtrinsic,
-  Symbols extends AssetSymbol = AssetSymbol,
-> {
-  pallet: ExtrinsicPallet.XTokens;
-  extrinsic: Extrinsic;
-  successEvent: XTokensExtrinsicSuccessEvent;
-  getParams: (
-    params: XcmExtrinsicGetParams,
-  ) => XTokensParamsByExtrinsic<Symbols>[Extrinsic];
-}
-interface XTokensParamsByExtrinsic<Symbols extends AssetSymbol = AssetSymbol> {
-  [XTokensExtrinsic.Transfer]: XTokensTransferExtrinsicParams<Symbols>;
-  [XTokensExtrinsic.TransferMultiAsset]: XTokensTransferMultiAssetExtrinsicParams<Symbols>;
-  [XTokensExtrinsic.TransferMultiCurrencies]: XTokensTransferMultiCurrenciesExtrinsicParams<Symbols>;
-}
-type XTokensTransferExtrinsicParams<Symbols extends AssetSymbol = AssetSymbol> =
-  [
-    /**
-     * asset
-     */
-    XTokensTransferExtrinsicParamsAsset<Symbols>,
-    /**
-     * amount
-     */
-    bigint,
-    /**
-     * destination
-     */
-    {
-      [Key in XcmVersion]?: {
-        parents: 1;
-        interior: {
-          X2: [
-            {
-              Parachain: number;
-            },
-            {
-              AccountKey20: {
-                network: 'Any';
-                /**
-                 * account
-                 */
-                key: string;
-              };
-            },
-          ];
-        };
-      };
-    },
-    /**
-     * weight
-     */
-    XTokensWeightLimit,
-  ];
-type XTokensTransferMultiAssetExtrinsicParams<
-  Symbols extends AssetSymbol = AssetSymbol,
-> = [
-  /**
-   * asset
-   */
-  {
-    V1: {
-      id: {
-        Concrete: {
-          parents: 1;
-          interior: {
-            X2: [
-              {
-                Parachain: number;
-              },
-              {
-                GeneralKey: Symbols;
-              },
-            ];
-          };
-        };
-      };
-      fun: {
-        /**
-         * amount
-         */
-        Fungible: bigint;
-      };
-    };
-  },
-  /**
-   * destination
-   */
-  {
-    V1: {
-      parents: 1;
-      interior: {
-        X2: [
-          {
-            Parachain: number;
-          },
-          {
-            AccountKey20: {
-              network: 'Any';
-              key: string;
-            };
-          },
-        ];
-      };
-    };
-  },
-  /**
-   * weight
-   */
-  XTokensWeightLimit,
-];
-type XTokensTransferMultiCurrenciesExtrinsicParams<
-  Symbols extends AssetSymbol = AssetSymbol,
-> = [
-  [
-    [
-      XTokensTransferExtrinsicParamsAsset<Symbols>,
-      /**
-       * amount
-       */
-      bigint,
-    ],
-    [
-      XTokensTransferExtrinsicParamsAsset<Symbols>,
-      /**
-       * fee
-       */
-      bigint,
-    ],
-  ],
-  /**
-   * fee item
-   */
-  1,
-  {
-    V1: {
-      parents: 1;
-      interior: {
-        X2: [
-          {
-            Parachain: number;
-          },
-          {
-            AccountKey20: {
-              network: 'Any';
-              /**
-               * account
-               */
-              key: string;
-            };
-          },
-        ];
-      };
-    };
-  },
-  /**
-   * weight
-   */
-  XTokensWeightLimit,
-];
-type XTokensTransferExtrinsicParamsAsset<
-  Symbols extends AssetSymbol = AssetSymbol,
-> =
-  | {
-      [XTokensExtrinsicCurrencyTypes.Token]: Symbols | AssetSymbol.KUSD;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.Token2]: AssetId;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.Native]: Symbols;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.NativeAssetId]: 'Here';
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.NativeToken]: AssetId;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.MiningResource]: AssetId;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.ForeignAsset]: AssetId;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.FungibleToken]: AssetId;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.MantaCurrency]: AssetId;
-    }
-  | {
-      [XTokensExtrinsicCurrencyTypes.OtherReserve]: AssetId;
-    }
-  | Symbols
-  | AssetId
-  | 'SelfReserve';
-
-declare function xTokens<
-  Symbols extends AssetSymbol,
-  ChainKeys extends ChainKey,
->(
-  chain: MoonChain,
-): {
-  transfer: () => {
-    successEvent: (event: XTokensExtrinsicSuccessEvent) => {
-      origin: (origin: Chain<ChainKeys>) => {
-        asset: (
-          token: XTokensTransferExtrinsicParamsAsset<Symbols>,
-        ) => XTokensTransferExtrinsic<Symbols>;
-      };
-    };
-  };
-  transferMultiAsset: () => {
-    successEvent: (event: XTokensExtrinsicSuccessEvent) => {
-      origin: (origin: Chain<ChainKeys>) => {
-        asset: (
-          asset: Asset<Symbols>,
-        ) => XTokensTransferMultiAssetExtrinsic<Symbols>;
-      };
-    };
-  };
-  transferMultiCurrencies: () => {
-    successEvent: (event: XTokensExtrinsicSuccessEvent) => {
-      origin: (origin: Chain<ChainKeys>) => {
-        assets: (
-          asset: XTokensTransferExtrinsicParamsAsset<Symbols>,
-          feeAsset: XTokensTransferExtrinsicParamsAsset<Symbols>,
-        ) => XTokensTransferMultiCurrenciesExtrinsic<Symbols>;
-      };
-    };
-  };
-};
-
-declare enum XTransferExtrinsic {
-  Transfer = 'transfer',
-}
-declare enum XTransferExtrinsicSuccessEvent {
-  Deposited = 'Deposited',
-  Withdrawn = 'Withdrawn',
-}
-
-interface XTransferPallet {
-  pallet: ExtrinsicPallet.XTransfer;
-  extrinsic: XTransferExtrinsic;
-  successEvent: XTransferExtrinsicSuccessEvent;
-  getParams: (params: XcmExtrinsicGetParams) => XTransferPalletParams;
-}
-type XTransferPalletParams = [
-  /**
-   * asset
-   */
-  {
-    id: {
-      Concrete: XTransferConcreteParam;
-    };
-    fun: {
-      Fungible: bigint;
-    };
-  },
-  /**
-   * destination
-   */
-  {
-    parents: 1;
-    interior: {
-      X2: [
-        {
-          Parachain: number;
-        },
-        {
-          AccountKey20: {
-            /**
-             * account
-             */
-            key: string;
-          };
-        },
-      ];
-    };
-  },
-  /**
-   * weight
-   */
-  {
-    refTime: 5_000_000_000;
-    proofSize: 0;
-  },
-];
-interface XTransferConcreteParam {
-  parents: Parents;
-  interior: XTransferInteriorParam;
-}
-type XTransferInteriorParam =
-  | 'Here'
-  | {
-      X2: [
-        {
-          Parachain: number;
-        },
-        {
-          PalletInstance: number;
-        },
-      ];
-    };
-
-declare function xTransfer(chain: MoonChain): {
-  transfer: () => {
-    successEvent: (event: XTransferExtrinsicSuccessEvent) => {
-      here: () => XTransferPallet;
-      X2: (palletInstance: number) => XTransferPallet;
-    };
-  };
-};
-
-declare enum EqBalancesExtrinsic {
-  XcmTransfer = 'xcmTransfer',
-  TransferXcm = 'transferXcm',
-}
-declare enum EqBalancesSuccessEvent {
-  ExtrinsicSuccess = 'ExtrinsicSuccess',
-}
-declare enum EqBalancesFee {
-  SovereignAccWillPay = 'SovereignAccWillPay',
-  TargetChainAccWillPay = 'TargetChainAccWillPay',
-  ThisAccWillPay = 'ThisAccWillPay',
-}
-
-interface EqBalancesXcmTransfer {
-  pallet: ExtrinsicPallet.EqBalances;
-  extrinsic: EqBalancesExtrinsic.XcmTransfer;
-  successEvent: EqBalancesSuccessEvent;
-  getParams: (params: XcmExtrinsicGetParams) => EqBalancesXcmTransferParams;
-}
-interface EqBalancesTransferXcm {
-  pallet: ExtrinsicPallet.EqBalances;
-  extrinsic: EqBalancesExtrinsic.TransferXcm;
-  successEvent: EqBalancesSuccessEvent;
-  getParams: (params: XcmExtrinsicGetParams) => EqBalancesTransferXcmParams;
-}
-type EqBalancesXcmTransferParams = [
-  /**
-   * asset
-   */
-  number,
-  /**
-   * amount
-   */
-  bigint,
-  /**
-   * destination
-   */
-  {
-    parents: 1;
-    interior: {
-      X2: [
-        {
-          Parachain: number;
-        },
-        {
-          AccountKey20: {
-            network: 'Any';
-            /**
-             * account
-             */
-            key: string;
-          };
-        },
-      ];
-    };
-  },
-  /**
-   * Fee type
-   */
-  EqBalancesFee,
-];
-type EqBalancesTransferXcmParams = [
-  /**
-   * asset
-   */
-  TransferXcmAsset,
-  /**
-   * Fee
-   */
-  TransferXcmAsset,
-  {
-    parents: 1;
-    interior: {
-      X2: [
-        {
-          Parachain: number;
-        },
-        {
-          AccountKey20: {
-            network: 'Any';
-            /**
-             * account
-             */
-            key: string;
-          };
-        },
-      ];
-    };
-  },
-];
-/**
- * [id, amount]
- */
-type TransferXcmAsset = [number, bigint];
-
-declare function createExtrinsicBuilder<
-  Symbols extends AssetSymbol,
-  ChainKeys extends ChainKey,
->(
-  chain: MoonChain,
-): {
-  polkadotXcm: () => {
-    limitedReserveTransferAssets: () => {
-      successEvent: (event: PolkadotXcmExtrinsicSuccessEvent) => {
-        V1V2: () => {
-          here: () => PolkadotXcmPallet;
-          X1: () => PolkadotXcmPallet;
-          X2: (palletInstance: number, assetId: AssetId) => PolkadotXcmPallet;
-        };
-      };
-    };
-    limitedReserveWithdrawAssets: () => {
-      successEvent: (event: PolkadotXcmExtrinsicSuccessEvent) => {
-        V1V2: () => {
-          X2: (palletInstance: number) => PolkadotXcmPallet;
-        };
-      };
-    };
-  };
-  xcmPallet: () => {
-    limitedReserveTransferAssets: () => {
-      successEvent: (event: PolkadotXcmExtrinsicSuccessEvent) => {
-        pallet: ExtrinsicPallet;
-        extrinsic: PolkadotXcmExtrinsic;
-        successEvent: PolkadotXcmExtrinsicSuccessEvent;
-        getParams: (params: XcmExtrinsicGetParams) => PolkadotXcmPalletParams;
-      };
-    };
-  };
-  xTokens: () => {
-    transfer: () => {
-      successEvent: (event: XTokensExtrinsicSuccessEvent) => {
-        origin: (origin: Chain<ChainKeys>) => {
-          asset: (
-            token: XTokensTransferExtrinsicParamsAsset<Symbols>,
-          ) => XTokensTransferExtrinsic<Symbols>;
-        };
-      };
-    };
-    transferMultiAsset: () => {
-      successEvent: (event: XTokensExtrinsicSuccessEvent) => {
-        origin: (origin: Chain<ChainKeys>) => {
-          asset: (
-            asset: Asset<Symbols>,
-          ) => XTokensTransferMultiAssetExtrinsic<Symbols>;
-        };
-      };
-    };
-    transferMultiCurrencies: () => {
-      successEvent: (event: XTokensExtrinsicSuccessEvent) => {
-        origin: (origin: Chain<ChainKeys>) => {
-          assets: (
-            asset: XTokensTransferExtrinsicParamsAsset<Symbols>,
-            feeAsset: XTokensTransferExtrinsicParamsAsset<Symbols>,
-          ) => XTokensTransferMultiCurrenciesExtrinsic<Symbols>;
-        };
-      };
-    };
-  };
-  xTransfer: () => {
-    transfer: () => {
-      successEvent: (event: XTransferExtrinsicSuccessEvent) => {
-        here: () => XTransferPallet;
-        X2: (palletInstance: number) => XTransferPallet;
-      };
-    };
-  };
-  eqBalances: () => {
-    xcmTransfer: () => {
-      successEvent: (event: EqBalancesSuccessEvent) => {
-        asset: (id: number) => {
-          fee: (fee: EqBalancesFee) => EqBalancesXcmTransfer;
-        };
-      };
-    };
-    transferXcm: () => {
-      successEvent: (event: EqBalancesSuccessEvent) => {
-        asset: (assetId: number) => {
-          feeAsset: (feeAssetId: number) => EqBalancesTransferXcm;
-        };
-      };
-    };
-  };
-};
-
-type ExtrinsicConfig<Symbols extends AssetSymbol = AssetSymbol> =
-  | PolkadotXcmPallet
-  | XcmPallet
-  | XTokensPallet<Symbols>
-  | XTransferPallet;
-
-interface DepositConfig<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  /**
-   * Balance of asset being sent
-   */
-  balance: BalanceConfig<Symbols>;
-  /**
-   * Deposit extrinsic
-   */
-  extrinsic: ExtrinsicConfig<Symbols>;
-  /**
-   * Chain where the asset(s) will be sent from
-   */
-  source: Chain<ChainKeys>;
-  /**
-   * Optional - Balance config for the native token (the one that will pay the
-   * extrinsic fees). Needed if the asset being sent is NOT the native token
-   * of the origin chain (is not the asset paying for the extrinsic fees).
-   */
-  sourceFeeBalance?: BalanceConfig<Symbols>;
-  /**
-   * Optional - Config for querying the minimum balance for the asset in the
-   * foreign chain.
-   */
-  sourceMinBalance?: MinBalanceConfig;
-  /**
-   * Optional - Asset to pay for the XCM fee in Moon*. Needed if the asset being
-   * sent is not accepted as XCM fee payment method.
-   */
-  xcmFeeAsset?: XcmFeeAsset<Symbols>;
-}
-
-interface DestinationMultilocationV1 {
-  V1: {
-    parents: Parents;
-    interior: {
-      X1: {
-        Parachain: number;
-      };
-    };
-  };
-  toPrecompileMultilocation: () => PrecompileDestinationMultilocationV1;
-}
-type PrecompileDestinationMultilocationV1 = [Parents, [string]];
-interface GetterAccountMultilocationV1 {
-  get: (account: string) => AccountMultilocationV1;
-}
-interface AccountMultilocationV1 {
-  parents: Parents;
-  interior: {
-    X2: [
-      {
-        Parachain: number;
-      },
-      {
-        AccountKey20: {
-          network: 'Any';
-          key: string;
-        };
-      },
-    ];
-  };
-}
-
-declare function createMultilocationBuilder(): {
-  v1: () => {
-    destination: (
-      parachainId: number,
-      parents?: Parents,
-    ) => DestinationMultilocationV1;
-    account: (
-      parachainId: number,
-      parents?: Parents,
-    ) => GetterAccountMultilocationV1;
-  };
-};
-
-interface XcmTransactThroughSigned {
-  getParams: (
-    params: XcmTransactThroughSignedGetParams,
-  ) => XcmTransactThroughSignedParams;
-}
-interface XcmTransactThroughSignedMultilocation {
-  getParams: (
-    params: XcmTransactThroughSignedGetParams,
-  ) => PrecompileXcmTransactThroughSignedMultilocationParams;
-}
-interface XcmTransactThroughSignedGetParams {
-  callHash: string;
-  overallFee: bigint;
-  overallWeight: bigint;
-  txWeight: bigint;
-}
-interface PrecompileXcmTransactThroughSignedMultilocationParams {
-  /**
-   * 1 - if transaction is going through a relay chain
-   * `0x0000000${parachainId.toString(16)}`
-   */
-  destination: [1, [string]];
-  /**
-   * 1 - if transaction is going through a relay chain
-   * `0x0000000${parachainId.toString(16)}`
-   * `0x040${palletInstance}`
-   */
-  asset: [1, [string, string]];
-  /**
-   * transaction weight - a weight of the transaction
-   * const call = betaApi.createType('Call', hexToU8a(callHash));
-   * const { weight } = await betaApi.tx(call).paymentInfo(pair.address);
-   * const txWeight = weight.toBigInt();
-   */
-  txWeight: bigint;
-  /**
-   * call hash - a hash of the transaction
-   */
-  callHash: string;
-  /**
-   * fee - a fee of the transaction
-   * (overallWeight * unitsPerSecond) / 1_000_000_000_000n
-   */
-  overallFee: bigint;
-  /**
-   * overall weight - a weight of the transaction
-   * const overallWeight =
-   *   descendOriginWeight +
-   *   withdrawAssetWeight +
-   *   buyExecutionWeight +
-   *   transactWeight +
-   *   baseExtrinsicWeight +
-   *   txWeight;
-   */
-  overallWeight: bigint;
-}
-type XcmTransactThroughSignedParams = [
-  {
-    V1: {
-      parents: 1;
-      interior: {
-        X1: {
-          Parachain: number;
-        };
-      };
-    };
-  },
-  {
-    currency: {
-      AsMultiLocation: {
-        V1: {
-          parents: 1;
-          interior: {
-            X2: [
-              {
-                Parachain: number;
-              },
-              {
-                PalletInstance: number;
-              },
-            ];
-          };
+import {
+  Asset,
+  AnyChain,
+  Ecosystem,
+  Parachain,
+  EvmParachain,
+} from '@moonbeam-network/xcm-types';
+import {
+  BalanceConfigBuilder,
+  ContractConfigBuilder,
+  ExtrinsicConfigBuilder,
+  AssetMinConfigBuilder,
+  FeeConfigBuilder,
+} from '@moonbeam-network/xcm-builder';
+
+interface AssetConfigConstructorParams {
+  asset: Asset;
+  balance: BalanceConfigBuilder;
+  contract?: ContractConfigBuilder;
+  destination: AnyChain;
+  destinationFee: DestinationFeeConfig;
+  extrinsic?: ExtrinsicConfigBuilder;
+  fee?: FeeAssetConfig;
+  min?: AssetMinConfigBuilder;
+}
+interface DestinationFeeConfig {
+  asset: Asset;
+  amount: number | FeeConfigBuilder;
+}
+interface FeeAssetConfig {
+  asset: Asset;
+  balance: BalanceConfigBuilder;
+}
+declare class AssetConfig {
+  readonly asset: Asset;
+  readonly balance: BalanceConfigBuilder;
+  readonly contract?: ContractConfigBuilder;
+  readonly destination: AnyChain;
+  readonly destinationFee: DestinationFeeConfig;
+  readonly extrinsic?: ExtrinsicConfigBuilder;
+  readonly fee?: FeeAssetConfig;
+  readonly min?: AssetMinConfigBuilder;
+  constructor({
+    asset,
+    balance,
+    contract,
+    destination,
+    destinationFee,
+    extrinsic,
+    fee,
+    min,
+  }: AssetConfigConstructorParams);
+}
+
+interface TransferConfig {
+  asset: Asset;
+  source: ChainTransferConfig;
+  destination: ChainTransferConfig;
+}
+interface ChainTransferConfig {
+  chain: AnyChain;
+  config: AssetConfig;
+}
+
+declare function ConfigBuilder(): {
+  assets: (ecosystem?: Ecosystem) => {
+    assets: Asset[];
+    asset: (keyOrAsset: string | Asset) => {
+      sourceChains: AnyChain[];
+      source: (keyOrChain: string | AnyChain) => {
+        destinationChains: AnyChain[];
+        destination: (keyOrChain: string | AnyChain) => {
+          build: () => TransferConfig;
         };
       };
     };
-    /**
-     * fee
-     */
-    feeAmount: bigint;
-  },
-  /**
-   * callHash
-   */
-  string,
-  {
-    /**
-     * txWeight
-     */
-    transactRequiredWeightAtMost: bigint;
-    overallWeight: bigint;
-  },
-];
-
-declare function createTransactBuilder<
-  ChainKeys extends ChainKey = ChainKey,
->(): {
-  xcmTransactor: () => {
-    transactThroughSigned: (
-      chain: Chain<ChainKeys>,
-    ) => XcmTransactThroughSigned;
-    transactThroughSignedMultilocation: (
-      chain: Chain<ChainKeys>,
-    ) => XcmTransactThroughSignedMultilocation;
   };
 };
 
-type WithdrawConfig<Symbols extends AssetSymbol = AssetSymbol> =
-  WithdrawXTokensConfig<Symbols>;
-interface WithdrawXTokensConfig<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  balance: BalanceConfig<Symbols>;
-  destination: Chain<ChainKeys>;
-  feePerWeight: number;
-  sourceMinBalance?: MinBalanceConfig;
-  xcmFeeAsset?: WithdrawXcmFeeAsset<Symbols>;
-  weight: number;
-  getParams: (
-    account: string,
-    usesEthereumAccounts: boolean | undefined,
-  ) => WithdrawXTokensParams;
+declare const aca: Asset;
+declare const astr: Asset;
+declare const auq: Asset;
+declare const ausd: Asset;
+declare const bnc: Asset;
+declare const crab: Asset;
+declare const csm: Asset;
+declare const dev: Asset;
+declare const dot: Asset;
+declare const eq: Asset;
+declare const eqd: Asset;
+declare const glmr: Asset;
+declare const hdx: Asset;
+declare const hko: Asset;
+declare const ibtc: Asset;
+declare const intr: Asset;
+declare const kar: Asset;
+declare const kbtc: Asset;
+declare const kint: Asset;
+declare const kma: Asset;
+declare const ksm: Asset;
+declare const lit: Asset;
+declare const mgx: Asset;
+declare const movr: Asset;
+declare const para: Asset;
+declare const paring: Asset;
+declare const pha: Asset;
+declare const ring: Asset;
+declare const rmrk: Asset;
+declare const sdn: Asset;
+declare const teer: Asset;
+declare const tt1: Asset;
+declare const unit: Asset;
+declare const usdt: Asset;
+declare const xrt: Asset;
+declare const assetsList: Asset[];
+declare const assetsMap: Map<string, Asset>;
+
+declare const acala: Parachain;
+declare const alphanetRelay: Parachain;
+declare const astar: Parachain;
+declare const bifrostKusama: Parachain;
+declare const bifrostPolkadot: Parachain;
+declare const calamari: Parachain;
+declare const crustShadow: Parachain;
+declare const darwinia: EvmParachain;
+declare const darwiniaCrab: EvmParachain;
+declare const darwiniaPangoro: EvmParachain;
+declare const equilibrium: Parachain;
+declare const equilibriumAlphanet: Parachain;
+declare const hydraDX: Parachain;
+declare const interlay: Parachain;
+declare const integritee: Parachain;
+declare const karura: Parachain;
+declare const khala: Parachain;
+declare const kintsugi: Parachain;
+declare const kusama: Parachain;
+declare const litentryAlphanet: Parachain;
+declare const litmus: Parachain;
+declare const mangataKusama: Parachain;
+declare const moonbaseAlpha: EvmParachain;
+declare const moonbaseBeta: EvmParachain;
+declare const moonbeam: EvmParachain;
+declare const moonriver: EvmParachain;
+declare const parallel: Parachain;
+declare const parallelHeiko: Parachain;
+declare const phala: Parachain;
+declare const polkadot: Parachain;
+declare const robonomics: Parachain;
+declare const shiden: Parachain;
+declare const statemine: Parachain;
+declare const statemineAlphanet: Parachain;
+declare const statemint: Parachain;
+declare const uniqueAlpha: Parachain;
+declare const chainsList: AnyChain[];
+declare const chainsMap: Map<string, AnyChain>;
+
+interface ChainConfigConstructorParams {
+  assets: AssetConfig[];
+  chain: AnyChain;
+}
+declare class ChainConfig {
+  #private;
+  readonly chain: AnyChain;
+  constructor({ assets, chain }: ChainConfigConstructorParams);
+  getAssetsConfigs(): AssetConfig[];
+  getAssetConfigs(asset: Asset): AssetConfig[];
+  getAssetDestinations(asset: Asset): AnyChain[];
+  getAssetDestinationConfig(asset: Asset, destination: AnyChain): AssetConfig;
 }
-type WithdrawXTokensParams = [
-  /**
-   * 1 - if transaction is going through a relay chain
-   */
-  1,
-  (
-    | [
-        /**
-         * example '0x00000007DC'
-         * 7DC - parachain id in hex
-         * can be found here:
-         *   - https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fkusama-rpc.polkadot.io#/parachains
-         *   - https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.polkadot.io#/parachains
-         */
-        string,
-        /**
-         * example '0x01%account%00',
-         * enum = 01 (AccountId32)
-         * networkId = 00 (any)
-         */
-        string,
-      ]
-    | [
-        /**
-         * example '0x01%account%00',
-         * enum = 01 (AccountId32)
-         * networkId = 00 (any)
-         */
-        string,
-      ]
-  ),
-];
-interface WithdrawXTokensOptions<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  balance: BalanceConfig<Symbols>;
-  destination: Chain<ChainKeys>;
-  feePerWeight: number;
-  sourceMinBalance?: MinBalanceConfig;
-  weight?: number;
-  xcmFeeAsset?: WithdrawXcmFeeAsset<Symbols>;
-}
-interface WithdrawXcmFeeAsset<Symbols extends AssetSymbol = AssetSymbol> {
-  asset: Asset<Symbols>;
-  balance: {
-    origin: BalanceConfig<Symbols>;
-    destination: BalanceConfig<Symbols>;
-  };
-}
-
-declare function createWithdrawBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
->(): {
-  xTokens: (
-    options: WithdrawXTokensOptions<Symbols>,
-  ) => WithdrawXTokensConfig<Symbols, ChainKey>;
-};
-
-interface CreateConfigParams<
-  Symbols extends AssetSymbol,
-  ChainKeys extends ChainKey,
-> {
-  assets: AssetsMap<Symbols>;
-  moonAsset: Asset<Symbols>;
-  moonChain: MoonChain;
-  chains: ChainsMap<ChainKeys>;
-  configs: ChainXcmConfigs<Symbols, ChainKeys>;
-  transact: ChainTransactConfigs<Symbols, ChainKeys>;
-}
-interface XcmConfigBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  symbols: Symbols[];
-  assets: AssetsMap<Symbols>;
-  moonAsset: Asset<Symbols>;
-  moonChain: MoonChain;
-  deposit: (
-    symbolOrAsset: Symbols | Asset<Symbols>,
-  ) => DepositConfigBuilder<Symbols, ChainKeys>;
-  withdraw: (
-    symbolOrAsset: Symbols | Asset<Symbols>,
-  ) => WithdrawConfigBuilder<Symbols, ChainKeys>;
-  transact: () => TransactConfigBuilder<Symbols, ChainKeys>;
-}
-interface DepositConfigBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  chains: Chain<ChainKeys>[];
-  from: (keyOrChain: ChainKeys | Chain<ChainKeys>) => {
-    asset: Asset<Symbols>;
-    origin: Chain<ChainKeys> | MoonChain;
-    config: DepositConfig<Symbols>;
-  };
-}
-interface WithdrawConfigBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  chains: Chain<ChainKeys>[];
-  to: (keyOrChain: ChainKeys | Chain<ChainKeys>) => {
-    asset: Asset<Symbols>;
-    origin: Chain<ChainKeys> | MoonChain;
-    config: WithdrawConfig<Symbols>;
-  };
-}
-type AssetsMap<Symbols extends AssetSymbol = AssetSymbol> = Record<
-  Symbols,
-  Asset<Symbols>
->;
-type ChainsMap<ChainKeys extends ChainKey = ChainKey> = Record<
-  ChainKeys,
-  Chain<ChainKeys>
->;
-type ChainXcmConfigs<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> = Partial<Record<AssetSymbol, XcmConfig<Symbols, ChainKeys>>>;
-interface XcmConfig<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  asset: Asset<Symbols>;
-  origin: Chain<ChainKeys> | MoonChain;
-  deposit: Partial<Record<ChainKeys, DepositConfig<Symbols>>>;
-  withdraw: Partial<Record<ChainKeys, WithdrawConfig<Symbols>>>;
-}
-type ChainTransactConfigs<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> = Partial<Record<ChainKeys, TransactConfig<Symbols, ChainKeys>>>;
-interface TransactConfigBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  chainsFrom: Chain<ChainKeys>[];
-  chainsTo: Chain<ChainKeys>[];
-  from: (
-    keyOrChain: ChainKeys | Chain<ChainKeys>,
-  ) => TransactConfigFromBuilder<Symbols, ChainKeys>;
-  to: (
-    keyOrChain: ChainKeys | Chain<ChainKeys>,
-  ) => TransactConfigToBuilder<Symbols, ChainKeys>;
-}
-interface TransactConfigFromBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  chain: Chain<ChainKeys>;
-  config: TransactFromConfig;
-  balance: BalanceConfig<Symbols>;
-  getOverallWeight: (txWeight: bigint) => bigint;
-  getOverallFee: (overallWeight: bigint) => bigint;
-}
-interface TransactConfigToBuilder<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  chain: Chain<ChainKeys>;
-  config: TransactToConfig;
-  balance: BalanceConfig<Symbols>;
-  getOverallWeight: (txWeight: bigint) => bigint;
-  getOverallFee: (overallWeight: bigint) => bigint;
-}
-interface TransactConfig<
-  Symbols extends AssetSymbol = AssetSymbol,
-  ChainKeys extends ChainKey = ChainKey,
-> {
-  chain: Chain<ChainKeys>;
-  unitsPerSecond: bigint;
-  balance: BalanceConfig<Symbols>;
-  from?: TransactFromConfig;
-  to?: TransactToConfig;
-}
-interface TransactFromConfig {
-  multilocation: {
-    account: GetterAccountMultilocationV1;
-  };
-  transact: XcmTransactThroughSigned;
-}
-interface TransactToConfig {
-  multilocation: {
-    account: GetterAccountMultilocationV1;
-  };
-  transact: XcmTransactThroughSignedMultilocation;
-}
-
-declare function createConfig<
-  Symbols extends AssetSymbol,
-  ChainKeys extends ChainKey,
->({
-  assets,
-  moonAsset,
-  moonChain,
-  chains,
-  configs,
-  transact,
-}: CreateConfigParams<Symbols, ChainKeys>): XcmConfigBuilder<
-  Symbols,
-  ChainKeys
->;
-declare const moonbase: XcmConfigBuilder<
-  | AssetSymbol.AUQ
-  | AssetSymbol.BIT
-  | AssetSymbol.DEV
-  | AssetSymbol.EQ
-  | AssetSymbol.EQD
-  | AssetSymbol.LIT
-  | AssetSymbol.NEER
-  | AssetSymbol.PARING
-  | AssetSymbol.TT1
-  | AssetSymbol.UNIT,
-  | ChainKey.AlphanetRelay
-  | ChainKey.BitCountryPioneer
-  | ChainKey.DarwiniaPangoro
-  | ChainKey.EquilibriumAlphanet
-  | ChainKey.LitentryAlphanet
-  | ChainKey.MoonbaseBeta
-  | ChainKey.StatemineAlphanet
-  | ChainKey.UniqueAlpha
->;
-declare const moonbeam: XcmConfigBuilder<
-  | AssetSymbol.ACA
-  | AssetSymbol.ASTR
-  | AssetSymbol.AUSD
-  | AssetSymbol.BNC
-  | AssetSymbol.DOT
-  | AssetSymbol.EQ
-  | AssetSymbol.EQD
-  | AssetSymbol.GLMR
-  | AssetSymbol.HDX
-  | AssetSymbol.IBTC
-  | AssetSymbol.INTR
-  | AssetSymbol.PARA
-  | AssetSymbol.PHA
-  | AssetSymbol.RING
-  | AssetSymbol.USDT,
-  | ChainKey.Acala
-  | ChainKey.Astar
-  | ChainKey.BifrostPolkadot
-  | ChainKey.Darwinia
-  | ChainKey.Equilibrium
-  | ChainKey.HydraDX
-  | ChainKey.Interlay
-  | ChainKey.Parallel
-  | ChainKey.Phala
-  | ChainKey.Polkadot
-  | ChainKey.Statemint
->;
-declare const moonriver: XcmConfigBuilder<
-  | AssetSymbol.AUSD
-  | AssetSymbol.BNC
-  | AssetSymbol.CRAB
-  | AssetSymbol.CSM
-  | AssetSymbol.HKO
-  | AssetSymbol.KAR
-  | AssetSymbol.KBTC
-  | AssetSymbol.KINT
-  | AssetSymbol.KMA
-  | AssetSymbol.KSM
-  | AssetSymbol.LIT
-  | AssetSymbol.MOVR
-  | AssetSymbol.PHA
-  | AssetSymbol.RMRK
-  | AssetSymbol.SDN
-  | AssetSymbol.TEER
-  | AssetSymbol.USDT
-  | AssetSymbol.XRT,
-  | ChainKey.Bifrost
-  | ChainKey.Calamari
-  | ChainKey.Crab
-  | ChainKey.CrustShadow
-  | ChainKey.Integritee
-  | ChainKey.Karura
-  | ChainKey.Khala
-  | ChainKey.Kintsugi
-  | ChainKey.Kusama
-  | ChainKey.Litmus
-  | ChainKey.Parallel
-  | ChainKey.Robonomics
-  | ChainKey.Shiden
-  | ChainKey.Statemine
->;
-
-declare function isMultiCurrency<Symbols extends AssetSymbol = AssetSymbol>(
-  extrinsic: ExtrinsicConfig<Symbols>,
-): extrinsic is XTokensTransferMultiCurrenciesExtrinsic<Symbols>;
-
-declare const MOONBASE_ASSETS: readonly [
-  AssetSymbol.AUQ,
-  AssetSymbol.BIT,
-  AssetSymbol.DEV,
-  AssetSymbol.EQ,
-  AssetSymbol.EQD,
-  AssetSymbol.LIT,
-  AssetSymbol.NEER,
-  AssetSymbol.PARING,
-  AssetSymbol.TT1,
-  AssetSymbol.UNIT,
-];
-declare const MOONBASE_ASSETS_MAP: AssetsMap<MoonbaseAssets>;
-
-declare const MOONBASE_CHAINS: readonly [
-  ChainKey.AlphanetRelay,
-  ChainKey.EquilibriumAlphanet,
-  ChainKey.LitentryAlphanet,
-  ChainKey.BitCountryPioneer,
-  ChainKey.DarwiniaPangoro,
-  ChainKey.MoonbaseBeta,
-  ChainKey.StatemineAlphanet,
-  ChainKey.UniqueAlpha,
-];
-declare const MOONBASE_CHAINS_MAP: ChainsMap<MoonbaseChains>;
-
-type MoonbaseAssets = (typeof MOONBASE_ASSETS)[number];
-type MoonbaseChains = (typeof MOONBASE_CHAINS)[number];
-type MoonbaseXcmConfig = XcmConfig<MoonbaseAssets, MoonbaseChains>;
-type MoonbaseXcmConfigs = ChainXcmConfigs<MoonbaseAssets, MoonbaseChains>;
-type MoonbaseTransactConfig = TransactConfig<MoonbaseAssets, MoonbaseChains>;
-type MoonbaseTransactConfigs = ChainTransactConfigs<
-  MoonbaseAssets,
-  MoonbaseChains
->;
-
-declare const MOONBASE_CONFIGS: MoonbaseXcmConfigs;
-
-declare const MOONBASE_TRANSACT_CONFIGS: MoonbaseTransactConfigs;
-
-declare const MOONBEAM_ASSETS: readonly [
-  AssetSymbol.ACA,
-  AssetSymbol.ASTR,
-  AssetSymbol.AUSD,
-  AssetSymbol.BNC,
-  AssetSymbol.EQ,
-  AssetSymbol.EQD,
-  AssetSymbol.DOT,
-  AssetSymbol.GLMR,
-  AssetSymbol.HDX,
-  AssetSymbol.IBTC,
-  AssetSymbol.INTR,
-  AssetSymbol.PARA,
-  AssetSymbol.PHA,
-  AssetSymbol.RING,
-  AssetSymbol.USDT,
-];
-declare const MOONBEAM_ASSETS_MAP: AssetsMap<MoonbeamAssets>;
-
-declare const MOONBEAM_CHAINS: readonly [
-  ChainKey.Acala,
-  ChainKey.Astar,
-  ChainKey.BifrostPolkadot,
-  ChainKey.Darwinia,
-  ChainKey.Equilibrium,
-  ChainKey.HydraDX,
-  ChainKey.Interlay,
-  ChainKey.Parallel,
-  ChainKey.Phala,
-  ChainKey.Polkadot,
-  ChainKey.Statemint,
-];
-declare const MOONBEAM_CHAINS_MAP: ChainsMap<MoonbeamChains>;
-
-type MoonbeamAssets = (typeof MOONBEAM_ASSETS)[number];
-type MoonbeamChains = (typeof MOONBEAM_CHAINS)[number];
-type MoonbeamXcmConfig = XcmConfig<MoonbeamAssets, MoonbeamChains>;
-type MoonbeamXcmConfigs = ChainXcmConfigs<MoonbeamAssets, MoonbeamChains>;
-
-declare const MOONBEAM_CONFIGS: MoonbeamXcmConfigs;
-
-declare const MOONRIVER_ASSETS: readonly [
-  AssetSymbol.AUSD,
-  AssetSymbol.BNC,
-  AssetSymbol.CRAB,
-  AssetSymbol.CSM,
-  AssetSymbol.HKO,
-  AssetSymbol.KAR,
-  AssetSymbol.KBTC,
-  AssetSymbol.KINT,
-  AssetSymbol.KMA,
-  AssetSymbol.KSM,
-  AssetSymbol.LIT,
-  AssetSymbol.MOVR,
-  AssetSymbol.PHA,
-  AssetSymbol.RMRK,
-  AssetSymbol.SDN,
-  AssetSymbol.TEER,
-  AssetSymbol.USDT,
-  AssetSymbol.XRT,
-];
-declare const MOONRIVER_ASSETS_MAP: AssetsMap<MoonriverAssets>;
-
-declare const MOONRIVER_CHAINS: readonly [
-  ChainKey.Bifrost,
-  ChainKey.Calamari,
-  ChainKey.CrustShadow,
-  ChainKey.Crab,
-  ChainKey.Integritee,
-  ChainKey.Karura,
-  ChainKey.Khala,
-  ChainKey.Kintsugi,
-  ChainKey.Kusama,
-  ChainKey.Litmus,
-  ChainKey.Parallel,
-  ChainKey.Robonomics,
-  ChainKey.Shiden,
-  ChainKey.Statemine,
-];
-declare const MOONRIVER_CHAINS_MAP: ChainsMap<MoonriverChains>;
-
-type MoonriverAssets = (typeof MOONRIVER_ASSETS)[number];
-type MoonriverChains = (typeof MOONRIVER_CHAINS)[number];
-type MoonriverXcmConfig = XcmConfig<MoonriverAssets, MoonriverChains>;
-type MoonriverXcmConfigs = ChainXcmConfigs<MoonriverAssets, MoonriverChains>;
-
-declare const MOONRIVER_CONFIGS: MoonriverXcmConfigs;
 
 export {
-  AccountMultilocationV1,
-  Asset,
-  AssetId,
-  AssetSymbol,
-  AssetsBalanceConfig,
-  AssetsMap,
-  BalanceConfig,
-  BalanceCurrencyTypes,
-  BalanceFunction,
-  BalancePallet,
-  Chain,
-  ChainBase,
-  ChainKey,
-  ChainTransactConfigs,
-  ChainXcmConfigs,
-  ChainsMap,
-  CreateConfigParams,
-  DepositConfig,
-  DepositConfigBuilder,
-  DestinationMultilocationV1,
-  EquilibriumSystemBalanceConfig,
-  EquilibriumSystemBalanceData,
-  ExtrinsicConfig,
-  ExtrinsicPallet,
-  GetterAccountMultilocationV1,
-  MOONBASE_ASSETS,
-  MOONBASE_ASSETS_MAP,
-  MOONBASE_CHAINS,
-  MOONBASE_CHAINS_MAP,
-  MOONBASE_CONFIGS,
-  MOONBASE_TRANSACT_CONFIGS,
-  MOONBEAM_ASSETS,
-  MOONBEAM_ASSETS_MAP,
-  MOONBEAM_CHAINS,
-  MOONBEAM_CHAINS_MAP,
-  MOONBEAM_CONFIGS,
-  MOONRIVER_ASSETS,
-  MOONRIVER_ASSETS_MAP,
-  MOONRIVER_CHAINS,
-  MOONRIVER_CHAINS_MAP,
-  MOONRIVER_CONFIGS,
-  MOON_CHAINS,
-  MinBalanceAssetRegistryConfig,
-  MinBalanceAssetsConfig,
-  MinBalanceConfig,
-  MoonChain,
-  MoonChainKey,
-  MoonbaseAssets,
-  MoonbaseChains,
-  MoonbaseTransactConfig,
-  MoonbaseTransactConfigs,
-  MoonbaseXcmConfig,
-  MoonbaseXcmConfigs,
-  MoonbeamAssets,
-  MoonbeamChains,
-  MoonbeamXcmConfig,
-  MoonbeamXcmConfigs,
-  MoonriverAssets,
-  MoonriverChains,
-  MoonriverXcmConfig,
-  MoonriverXcmConfigs,
-  OrmlTokensBalanceConfig,
-  PalletBalancesAccountDataOld,
-  Parents,
-  PolkadotXcmAssetParam,
-  PolkadotXcmAssetParamInteriorX1,
-  PolkadotXcmAssetParamInteriorX2,
-  PolkadotXcmExtrinsic,
-  PolkadotXcmExtrinsicSuccessEvent,
-  PolkadotXcmPallet,
-  PolkadotXcmPalletParams,
-  PrecompileDestinationMultilocationV1,
-  PrecompileXcmTransactThroughSignedMultilocationParams,
-  SystemBalanceConfig,
-  TokensBalanceConfig,
-  TokensBalanceParamAsset,
-  TokensPalletAccountData,
-  TransactConfig,
-  TransactConfigBuilder,
-  TransactConfigFromBuilder,
-  TransactConfigToBuilder,
-  TransactFromConfig,
-  TransactToConfig,
-  WithdrawConfig,
-  WithdrawConfigBuilder,
-  WithdrawXTokensConfig,
-  WithdrawXTokensOptions,
-  WithdrawXTokensParams,
-  XTokensBaseExtrinsic,
-  XTokensExtrinsic,
-  XTokensExtrinsicCurrencyTypes,
-  XTokensExtrinsicSuccessEvent,
-  XTokensPallet,
-  XTokensParamsByExtrinsic,
-  XTokensTransferExtrinsic,
-  XTokensTransferExtrinsicParams,
-  XTokensTransferExtrinsicParamsAsset,
-  XTokensTransferMultiAssetExtrinsic,
-  XTokensTransferMultiAssetExtrinsicParams,
-  XTokensTransferMultiCurrenciesExtrinsic,
-  XTokensTransferMultiCurrenciesExtrinsicParams,
-  XTokensWeightLimit,
-  XTransferConcreteParam,
-  XTransferExtrinsic,
-  XTransferExtrinsicSuccessEvent,
-  XTransferInteriorParam,
-  XTransferPallet,
-  XTransferPalletParams,
-  XcmConfig,
-  XcmConfigBuilder,
-  XcmExtrinsicGetParams,
-  XcmFeeAsset,
-  XcmPallet,
-  XcmTransactThroughSigned,
-  XcmTransactThroughSignedGetParams,
-  XcmTransactThroughSignedMultilocation,
-  XcmTransactThroughSignedParams,
-  XcmVersion,
-  createBalanceBuilder,
-  createConfig,
-  createExtrinsicBuilder,
-  createMultilocationBuilder,
-  createTransactBuilder,
-  createWithdrawBuilder,
-  getCreateV1V2Extrinsic,
-  isMultiCurrency,
-  moonbase,
+  AssetConfig,
+  AssetConfigConstructorParams,
+  ChainConfig,
+  ChainConfigConstructorParams,
+  ChainTransferConfig,
+  ConfigBuilder,
+  DestinationFeeConfig,
+  FeeAssetConfig,
+  TransferConfig,
+  aca,
+  acala,
+  alphanetRelay,
+  assetsList,
+  assetsMap,
+  astar,
+  astr,
+  auq,
+  ausd,
+  bifrostKusama,
+  bifrostPolkadot,
+  bnc,
+  calamari,
+  chainsList,
+  chainsMap,
+  crab,
+  crustShadow,
+  csm,
+  darwinia,
+  darwiniaCrab,
+  darwiniaPangoro,
+  dev,
+  dot,
+  eq,
+  eqd,
+  equilibrium,
+  equilibriumAlphanet,
+  glmr,
+  hdx,
+  hko,
+  hydraDX,
+  ibtc,
+  integritee,
+  interlay,
+  intr,
+  kar,
+  karura,
+  kbtc,
+  khala,
+  kint,
+  kintsugi,
+  kma,
+  ksm,
+  kusama,
+  lit,
+  litentryAlphanet,
+  litmus,
+  mangataKusama,
+  mgx,
+  moonbaseAlpha,
+  moonbaseBeta,
   moonbeam,
   moonriver,
-  polkadotXcm,
-  xTokens,
-  xTransfer,
-  xcmPallet,
+  movr,
+  para,
+  parallel,
+  parallelHeiko,
+  paring,
+  pha,
+  phala,
+  polkadot,
+  ring,
+  rmrk,
+  robonomics,
+  sdn,
+  shiden,
+  statemine,
+  statemineAlphanet,
+  statemint,
+  teer,
+  tt1,
+  uniqueAlpha,
+  unit,
+  usdt,
+  xrt,
 };