@moonbeam-network/xcm-sdk 2.7.8 → 3.0.0

package/build/index.d.ts

@@ -1,328 +1,195 @@
-import {
-  SubstrateQueryConfig,
-  ExtrinsicConfig,
-  BalanceConfigBuilder,
-  ContractConfig,
-} from '@moonbeam-network/xcm-builder';
-import {
-  IConfigService,
-  AssetConfig,
-  FeeAssetConfig,
-  TransferConfig,
-  DestinationFeeConfig,
-} from '@moonbeam-network/xcm-config';
-import {
-  AnyParachain,
-  Asset,
-  AssetAmount,
-  ChainAssetId,
-  AnyChain,
-  EvmParachain,
-  Ecosystem,
-} from '@moonbeam-network/xcm-types';
+import { ContractConfig, ExtrinsicConfig, BalanceConfigBuilder, AssetMinConfigBuilder, FeeConfigBuilder, SubstrateQueryConfig, EvmQueryConfig } from '@moonbeam-network/xcm-builder';
+import { AssetRoute, FeeConfig, ConfigService } from '@moonbeam-network/xcm-config';
+import * as _moonbeam_network_xcm_types from '@moonbeam-network/xcm-types';
+import { AssetAmount, AnyChain, AnyParachain, ChainAsset, Asset, EvmChain, EvmParachain, Ecosystem, AnyAsset } from '@moonbeam-network/xcm-types';
+import { Signer, SubmittableExtrinsic } from '@polkadot/api/types';
+import { IKeyringPair, ISubmittableResult } from '@polkadot/types/types';
+import { WalletClient, PublicClient, HttpTransport, Hash } from 'viem';
 import { ApiPromise } from '@polkadot/api';
-import { Signer } from '@polkadot/api/types';
-import { IKeyringPair } from '@polkadot/types/types';
-import { Signer as Signer$1 } from 'ethers';
-import { WalletClient } from 'viem';
+import { RuntimeDispatchInfo } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
 
-declare class PolkadotService {
-  #private;
-  readonly api: ApiPromise;
-  readonly chain: AnyParachain;
-  readonly configService: IConfigService;
-  constructor(
-    api: ApiPromise,
-    chain: AnyParachain,
-    configService: IConfigService,
-  );
-  static create(
-    chain: AnyParachain,
-    configService: IConfigService,
-  ): Promise<PolkadotService>;
-  static createMulti(
-    chains: AnyParachain[],
-    configService: IConfigService,
-  ): Promise<PolkadotService[]>;
-  get decimals(): number;
-  get asset(): Asset;
-  get existentialDeposit(): AssetAmount;
-  getAssetMeta(asset: ChainAssetId): Promise<
-    | {
-        symbol: string;
-        decimals: number;
-      }
-    | undefined
-  >;
-  getAssetDecimalsFromQuery(asset: ChainAssetId): Promise<number | undefined>;
-  getAssetDecimals(asset: Asset): Promise<number>;
-  query(config: SubstrateQueryConfig): Promise<bigint>;
-  getFee(account: string, config: ExtrinsicConfig): Promise<bigint>;
-  transfer(
-    account: string,
-    config: ExtrinsicConfig,
-    signer: Signer | IKeyringPair,
-  ): Promise<string>;
-}
-
-type EvmSigner = Signer$1 | WalletClient;
+type EvmSigner = WalletClient;
 interface Signers {
-  /**
-   * @deprecated ethersSigner - is deprecated and will be removed in v2, use evmSigner instead
-   */
-  ethersSigner?: Signer$1;
-  evmSigner?: EvmSigner;
-  polkadotSigner: Signer | IKeyringPair;
+    evmSigner?: EvmSigner;
+    polkadotSigner?: Signer | IKeyringPair;
 }
 interface TransferData {
-  destination: DestinationChainTransferData;
-  getEstimate(amount: number | string): AssetAmount;
-  isSwapPossible: boolean;
-  max: AssetAmount;
-  min: AssetAmount;
-  source: SourceChainTransferData;
-  swap(): Promise<TransferData | undefined>;
-  transfer(amount: bigint | number | string): Promise<string>;
+    destination: DestinationChainTransferData;
+    getEstimate(amount: number | string): AssetAmount;
+    max: AssetAmount;
+    min: AssetAmount;
+    source: SourceChainTransferData;
+    transfer(amount: bigint | number | string, signers: Signers): Promise<string>;
 }
 interface SourceChainTransferData extends ChainTransferData {
-  destinationFee: AssetAmount;
-  destinationFeeBalance: AssetAmount;
-  feeBalance: AssetAmount;
-  max: AssetAmount;
+    destinationFee: AssetAmount;
+    destinationFeeBalance: AssetAmount;
+    feeBalance: AssetAmount;
+    max: AssetAmount;
 }
 interface SovereignAccountBalance {
-  feeAssetBalance: bigint | undefined;
-  transferAssetBalance: bigint;
+    feeAssetBalance: bigint | undefined;
+    transferAssetBalance: bigint;
 }
 interface DestinationChainTransferData extends ChainTransferData {
-  sovereignAccountBalances?: SovereignAccountBalance;
+    sovereignAccountBalances?: SovereignAccountBalance;
 }
 interface ChainTransferData {
-  balance: AssetAmount;
-  chain: AnyChain;
-  existentialDeposit: AssetAmount;
-  fee: AssetAmount;
-  min: AssetAmount;
-}
-
-interface BaseParams {
-  address: string;
-  chain: AnyChain;
-  polkadot: PolkadotService;
-}
-interface GetBalancesParams extends BaseParams {
-  asset: Asset;
-  balanceBuilder: BalanceConfigBuilder;
-  decimals: number;
+    balance: AssetAmount;
+    chain: AnyChain;
+    existentialDeposit?: AssetAmount;
+    fee: AssetAmount;
+    min: AssetAmount;
 }
-interface GetDecimalsParams extends BaseParams {
-  asset?: Asset;
-  config: AssetConfig | FeeAssetConfig;
-  assetBuiltConfig?: SubstrateQueryConfig | ContractConfig;
-}
-declare function getBalance({
-  address,
-  chain,
-  balanceBuilder,
-  asset,
-  decimals,
-  polkadot,
-}: GetBalancesParams): Promise<bigint>;
-declare function getDecimals({
-  address,
-  asset,
-  config,
-  polkadot,
-  chain,
-  assetBuiltConfig,
-}: GetDecimalsParams): Promise<number>;
-declare function getMin(
-  config: AssetConfig,
-  polkadot: PolkadotService,
-): Promise<bigint>;
-interface ValidateSovereignAccountBalancesProps {
-  amount: bigint;
-  destination: DestinationChainTransferData;
-  source: SourceChainTransferData;
-}
-declare function validateSovereignAccountBalances({
-  amount,
-  source,
-  destination,
-}: ValidateSovereignAccountBalancesProps): void;
 
 interface GetSourceDataParams {
-  transferConfig: TransferConfig;
-  destinationAddress: string;
-  destinationFee: AssetAmount;
-  evmSigner?: EvmSigner;
-  polkadot: PolkadotService;
-  sourceAddress: string;
+    route: AssetRoute;
+    destinationAddress: string;
+    destinationFee: AssetAmount;
+    sourceAddress: string;
 }
-declare function getSourceData({
-  transferConfig,
-  destinationAddress,
-  destinationFee,
-  polkadot,
-  sourceAddress,
-  evmSigner,
-}: GetSourceDataParams): Promise<SourceChainTransferData>;
-interface GetFeeBalanceParams extends BaseParams {
-  balance: bigint;
-  feeConfig: FeeAssetConfig | undefined;
-  decimals: number;
-}
-declare function getFeeBalance({
-  address,
-  balance,
-  chain,
-  decimals,
-  feeConfig,
-  polkadot,
-}: GetFeeBalanceParams): Promise<bigint>;
+declare function getSourceData({ route, destinationAddress, destinationFee, sourceAddress, }: GetSourceDataParams): Promise<SourceChainTransferData>;
 interface GetFeeParams {
-  balance: bigint;
-  contract?: ContractConfig;
-  chain: AnyChain;
-  decimals: number;
-  evmSigner?: EvmSigner;
-  extrinsic?: ExtrinsicConfig;
-  feeConfig?: FeeAssetConfig;
-  destinationFeeConfig?: DestinationFeeConfig;
-  destinationFeeBalanceAmount?: AssetAmount;
-  polkadot: PolkadotService;
-  sourceAddress: string;
-}
-declare function getFee({
-  balance,
-  chain,
-  contract,
-  decimals,
-  destinationFeeConfig,
-  destinationFeeBalanceAmount,
-  evmSigner,
-  extrinsic,
-  feeConfig,
-  polkadot,
-  sourceAddress,
-}: GetFeeParams): Promise<bigint>;
-declare function getContractFee({
-  balance,
-  config,
-  decimals,
-  evmSigner,
-  chain,
-}: {
-  balance: bigint;
-  config: ContractConfig;
-  decimals: number;
-  evmSigner: EvmSigner;
-  chain: EvmParachain;
-}): Promise<bigint>;
-declare function getExtrinsicFee(
-  balance: bigint,
-  extrinsic: ExtrinsicConfig,
-  polkadot: PolkadotService,
-  sourceAddress: string,
-): Promise<bigint>;
-interface GetMaxParams {
-  balanceAmount: AssetAmount;
-  existentialDeposit: AssetAmount;
-  feeAmount: AssetAmount;
-  minAmount: AssetAmount;
-}
-declare function getMax({
-  balanceAmount,
-  existentialDeposit,
-  feeAmount,
-  minAmount,
-}: GetMaxParams): AssetAmount;
+    balance: AssetAmount;
+    feeBalance: AssetAmount;
+    contract?: ContractConfig;
+    chain: AnyParachain;
+    destinationFee: AssetAmount;
+    extrinsic?: ExtrinsicConfig;
+    feeConfig?: FeeConfig;
+    sourceAddress: string;
+}
+declare function getFee({ balance, feeBalance, chain, contract, destinationFee, extrinsic, feeConfig, sourceAddress, }: GetFeeParams): Promise<AssetAmount>;
 interface GetAssetsBalancesParams {
-  address: string;
-  chain: AnyChain;
-  assets: AssetConfig[];
-  evmSigner?: EvmSigner;
-  polkadot: PolkadotService;
+    address: string;
+    chain: AnyParachain;
+    routes: AssetRoute[];
+    evmSigner?: EvmSigner;
+}
+declare function getAssetsBalances({ address, chain, routes, }: GetAssetsBalancesParams): Promise<AssetAmount[]>;
+
+interface GetDestinationDataParams {
+    route: AssetRoute;
+    destinationAddress: string;
 }
-declare function getAssetsBalances({
-  address,
-  chain,
-  assets,
-  polkadot,
-}: GetAssetsBalancesParams): Promise<AssetAmount[]>;
+declare function getDestinationData({ route, destinationAddress, }: GetDestinationDataParams): Promise<DestinationChainTransferData>;
 
-interface SdkOptions extends Partial<Signers> {
-  configService?: IConfigService;
+interface GetBalancesParams {
+    address: string;
+    asset: ChainAsset;
+    builder: BalanceConfigBuilder;
+    chain: AnyChain;
+}
+declare function getBalance({ address, asset, builder, chain, }: GetBalancesParams): Promise<AssetAmount>;
+interface GetMinParams {
+    asset: Asset;
+    builder?: AssetMinConfigBuilder;
+    chain: AnyChain;
+}
+declare function getAssetMin({ asset, builder, chain, }: GetMinParams): Promise<AssetAmount>;
+declare function getMin({ balance, existentialDeposit, fee, min, }: DestinationChainTransferData): AssetAmount;
+interface GetMaxParams {
+    balance: AssetAmount;
+    existentialDeposit?: AssetAmount;
+    fee: AssetAmount;
+    min: AssetAmount;
+}
+declare function getMax({ balance, existentialDeposit, fee, min, }: GetMaxParams): AssetAmount;
+interface GetDestinationFeeParams {
+    address: string;
+    asset: Asset;
+    feeAsset: Asset;
+    destination: AnyChain;
+    fee: number | FeeConfigBuilder;
+}
+declare function getDestinationFee({ address, asset, destination, fee, feeAsset, }: GetDestinationFeeParams): Promise<AssetAmount>;
+interface ConvertToChainDecimalsParams {
+    asset: AssetAmount;
+    target: ChainAsset;
+}
+declare function convertToChainDecimals({ asset, target, }: ConvertToChainDecimalsParams): AssetAmount;
+declare function getExistentialDeposit(chain: AnyChain): Promise<AssetAmount | undefined>;
+interface GetDestinationFeeBalanceParams {
+    balance: AssetAmount;
+    feeBalance: AssetAmount;
+    route: AssetRoute;
+    sourceAddress: string;
+}
+declare function getDestinationFeeBalance({ balance, feeBalance, route, sourceAddress, }: GetDestinationFeeBalanceParams): Promise<AssetAmount>;
+interface GetExtrinsicFeeParams {
+    address: string;
+    balance: AssetAmount;
+    chain: AnyParachain;
+    extrinsic: ExtrinsicConfig;
+    feeBalance: AssetAmount;
+    feeConfig?: FeeConfig;
+}
+declare function getExtrinsicFee({ address, balance, chain, extrinsic, feeBalance, feeConfig, }: GetExtrinsicFeeParams): Promise<AssetAmount>;
+interface GetContractFeeParams {
+    address: string;
+    balance: AssetAmount;
+    chain: EvmChain | EvmParachain;
+    contract: ContractConfig;
+    destinationFee: AssetAmount;
+    feeBalance: AssetAmount;
+    feeConfig?: FeeConfig;
+}
+declare function getContractFee({ address, balance, chain, contract, destinationFee, feeBalance, feeConfig, }: GetContractFeeParams): Promise<AssetAmount>;
+interface ValidateSovereignAccountBalancesProps {
+    amount: bigint;
+    destinationData: DestinationChainTransferData;
+    sourceData: SourceChainTransferData;
 }
-declare function Sdk(options?: SdkOptions): {
-  assets(ecosystem?: Ecosystem): {
-    assets: Asset[];
-    asset(keyOrAsset: string | Asset): {
-      sourceChains: AnyChain[];
-      source(keyOrChain: string | AnyChain): {
-        destinationChains: AnyChain[];
-        destination(destKeyOrChain: string | AnyChain): {
-          accounts(
-            sourceAddress: string,
-            destinationAddress: string,
-            signers?: Partial<Signers>,
-          ): Promise<TransferData>;
+declare function validateSovereignAccountBalances({ amount, sourceData, destinationData, }: ValidateSovereignAccountBalancesProps): void;
+
+interface SdkOptions {
+    configService?: ConfigService;
+    ecosystem?: Ecosystem;
+}
+declare function Sdk({ configService, ecosystem }?: SdkOptions): {
+    assets: _moonbeam_network_xcm_types.Asset[];
+    setAsset(asset: string | AnyAsset): {
+        sources: AnyChain[];
+        setSource(source: string | AnyChain): {
+            destinations: AnyChain[];
+            setDestination(destination: string | AnyChain): {
+                setAddresses({ sourceAddress, destinationAddress, }: {
+                    sourceAddress: string;
+                    destinationAddress: string;
+                }): Promise<TransferData>;
+            };
         };
-      };
     };
-  };
-  getTransferData({
-    destinationAddress,
-    destinationKeyOrChain,
-    ethersSigner,
-    evmSigner,
-    keyOrAsset,
-    polkadotSigner,
-    sourceAddress,
-    sourceKeyOrChain,
-  }: SdkTransferParams): Promise<TransferData>;
 };
-declare function getParachainBalances(
-  chain: AnyChain,
-  address: string,
-): Promise<AssetAmount[]>;
-interface SdkTransferParams extends Partial<Signers> {
-  destinationAddress: string;
-  destinationKeyOrChain: string | AnyChain;
-  keyOrAsset: string | Asset;
-  sourceAddress: string;
-  sourceKeyOrChain: string | AnyChain;
+declare function getParachainBalances(chain: AnyParachain, address: string, service?: ConfigService): Promise<AssetAmount[]>;
+
+declare class PolkadotService {
+    #private;
+    readonly api: ApiPromise;
+    readonly chain: AnyParachain;
+    constructor(api: ApiPromise, chain: AnyParachain);
+    static create(chain: AnyParachain): Promise<PolkadotService>;
+    static createMulti(chains: AnyParachain[]): Promise<PolkadotService[]>;
+    get decimals(): number;
+    get existentialDeposit(): AssetAmount;
+    query(config: SubstrateQueryConfig): Promise<bigint>;
+    getExtrinsic(config: ExtrinsicConfig): SubmittableExtrinsic<'promise', ISubmittableResult>;
+    getExtrinsicCallHash(config: ExtrinsicConfig): HexString;
+    getPaymentInfo(account: string, config: ExtrinsicConfig): Promise<RuntimeDispatchInfo>;
+    getFee(account: string, config: ExtrinsicConfig): Promise<bigint>;
+    transfer(account: string, config: ExtrinsicConfig, signer: Signer | IKeyringPair, statusCallback?: (params: ISubmittableResult) => void): Promise<string>;
 }
 
-export {
-  type BaseParams,
-  type ChainTransferData,
-  type DestinationChainTransferData,
-  type EvmSigner,
-  type GetAssetsBalancesParams,
-  type GetBalancesParams,
-  type GetDecimalsParams,
-  type GetFeeBalanceParams,
-  type GetFeeParams,
-  type GetMaxParams,
-  type GetSourceDataParams,
-  Sdk,
-  type SdkOptions,
-  type SdkTransferParams,
-  type Signers,
-  type SourceChainTransferData,
-  type SovereignAccountBalance,
-  type TransferData,
-  getAssetsBalances,
-  getBalance,
-  getContractFee,
-  getDecimals,
-  getExtrinsicFee,
-  getFee,
-  getFeeBalance,
-  getMax,
-  getMin,
-  getParachainBalances,
-  getSourceData,
-  validateSovereignAccountBalances,
-};
+declare class EvmService {
+    readonly chain: EvmChain | EvmParachain;
+    readonly client: PublicClient<HttpTransport>;
+    static create(chain: EvmChain | EvmParachain): EvmService;
+    constructor(chain: EvmChain | EvmParachain);
+    query(query: EvmQueryConfig): Promise<bigint>;
+    getFee(address: string, contract: ContractConfig): Promise<bigint>;
+    getBalance(address: string, contract: ContractConfig): Promise<bigint>;
+    transfer(signer: EvmSigner, contract: ContractConfig): Promise<Hash>;
+}
+
+export { type ChainTransferData, type ConvertToChainDecimalsParams, type DestinationChainTransferData, EvmService, type EvmSigner, type GetAssetsBalancesParams, type GetBalancesParams, type GetContractFeeParams, type GetDestinationDataParams, type GetDestinationFeeBalanceParams, type GetDestinationFeeParams, type GetExtrinsicFeeParams, type GetFeeParams, type GetMaxParams, type GetMinParams, type GetSourceDataParams, PolkadotService, Sdk, type SdkOptions, type Signers, type SourceChainTransferData, type SovereignAccountBalance, type TransferData, convertToChainDecimals, getAssetMin, getAssetsBalances, getBalance, getContractFee, getDestinationData, getDestinationFee, getDestinationFeeBalance, getExistentialDeposit, getExtrinsicFee, getFee, getMax, getMin, getParachainBalances, getSourceData, validateSovereignAccountBalances };