@moonbeam-network/xcm-config 0.0.1-dev.4 → 0.0.1-dev.40

package/build/index.d.ts

@@ -0,0 +1,1756 @@
+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',
+  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',
+  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;
+    };
+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: () => {
+    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 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 XcmMLVersion]?: {
+      parents: Parents;
+      interior: {
+        X1: {
+          Parachain: number;
+        };
+      };
+    };
+  },
+  /**
+   * beneficiary
+   */
+  {
+    [v in XcmMLVersion]?: {
+      parents: 0;
+      interior: {
+        X1: {
+          AccountKey20: {
+            network: 'Any';
+            /**
+             * account
+             */
+            key: string;
+          };
+        };
+      };
+    };
+  },
+  /**
+   * asset
+   */
+  {
+    [v in XcmMLVersion]?: PolkadotXcmAssetParam[];
+  },
+  /**
+   * fee
+   */
+  0,
+  /**
+   * weight
+   */
+  'Unlimited',
+];
+declare enum XcmMLVersion {
+  v1 = 'V1',
+  v2 = 'V2',
+}
+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;
+    };
+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
+     */
+    {
+      V1: {
+        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;
+              },
+            ];
+          };
+        };
+      };
+    };
+    /**
+     * 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;
+}
+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.IBTC
+  | AssetSymbol.INTR
+  | AssetSymbol.PARA
+  | AssetSymbol.PHA
+  | AssetSymbol.RING
+  | AssetSymbol.USDT,
+  | ChainKey.Acala
+  | ChainKey.Astar
+  | ChainKey.BifrostPolkadot
+  | ChainKey.Darwinia
+  | ChainKey.Equilibrium
+  | 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.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.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,
+  XcmMLVersion,
+  XcmPallet,
+  XcmTransactThroughSigned,
+  XcmTransactThroughSignedGetParams,
+  XcmTransactThroughSignedMultilocation,
+  XcmTransactThroughSignedParams,
+  createBalanceBuilder,
+  createConfig,
+  createExtrinsicBuilder,
+  createMultilocationBuilder,
+  createTransactBuilder,
+  createWithdrawBuilder,
+  getCreateV1V2Extrinsic,
+  isMultiCurrency,
+  moonbase,
+  moonbeam,
+  moonriver,
+  polkadotXcm,
+  xTokens,
+  xTransfer,
+  xcmPallet,
+};