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

package/build/index.d.ts

@@ -1,194 +1,328 @@
-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 {
+  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 { ApiPromise } from '@polkadot/api';
-import { RuntimeDispatchInfo } from '@polkadot/types/interfaces';
-import { HexString } from '@polkadot/util/types';
+import { Signer } from '@polkadot/api/types';
+import { IKeyringPair } from '@polkadot/types/types';
+import { Signer as Signer$1 } from 'ethers';
+import { WalletClient } from 'viem';
 
-type EvmSigner = WalletClient;
+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;
 interface Signers {
-    evmSigner?: EvmSigner;
-    polkadotSigner?: Signer | IKeyringPair;
+  /**
+   * @deprecated ethersSigner - is deprecated and will be removed in v2, use evmSigner instead
+   */
+  ethersSigner?: Signer$1;
+  evmSigner?: EvmSigner;
+  polkadotSigner: Signer | IKeyringPair;
 }
 interface TransferData {
-    destination: DestinationChainTransferData;
-    getEstimate(amount: number | string): AssetAmount;
-    max: AssetAmount;
-    min: AssetAmount;
-    source: SourceChainTransferData;
-    transfer(amount: bigint | number | string, signers: Signers): Promise<string>;
+  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>;
 }
 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;
+  balance: AssetAmount;
+  chain: AnyChain;
+  existentialDeposit: AssetAmount;
+  fee: AssetAmount;
+  min: AssetAmount;
 }
 
-interface GetSourceDataParams {
-    route: AssetRoute;
-    destinationAddress: string;
-    destinationFee: AssetAmount;
-    sourceAddress: string;
+interface BaseParams {
+  address: string;
+  chain: AnyChain;
+  polkadot: PolkadotService;
 }
-declare function getSourceData({ route, destinationAddress, destinationFee, sourceAddress, }: GetSourceDataParams): Promise<SourceChainTransferData>;
-interface GetFeeParams {
-    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: AnyParachain;
-    routes: AssetRoute[];
-    evmSigner?: EvmSigner;
+interface GetBalancesParams extends BaseParams {
+  asset: Asset;
+  balanceBuilder: BalanceConfigBuilder;
+  decimals: number;
 }
-declare function getAssetsBalances({ address, chain, routes, }: GetAssetsBalancesParams): Promise<AssetAmount[]>;
-
-interface GetDestinationDataParams {
-    route: AssetRoute;
-    destinationAddress: string;
+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 getDestinationData({ route, destinationAddress, }: GetDestinationDataParams): Promise<DestinationChainTransferData>;
+declare function validateSovereignAccountBalances({
+  amount,
+  source,
+  destination,
+}: ValidateSovereignAccountBalancesProps): void;
 
-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 GetSourceDataParams {
+  transferConfig: TransferConfig;
+  destinationAddress: string;
+  destinationFee: AssetAmount;
+  evmSigner?: EvmSigner;
+  polkadot: PolkadotService;
+  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>;
+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 {
-    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;
-    chain: EvmChain | EvmParachain;
-    contract: ContractConfig;
-    destinationFee: AssetAmount;
-    feeBalance: AssetAmount;
-    feeConfig?: FeeConfig;
-}
-declare function getContractFee({ address, chain, contract, destinationFee, feeBalance, feeConfig, }: GetContractFeeParams): Promise<AssetAmount>;
-interface ValidateSovereignAccountBalancesProps {
-    amount: bigint;
-    destinationData: DestinationChainTransferData;
-    sourceData: SourceChainTransferData;
+  balanceAmount: AssetAmount;
+  existentialDeposit: AssetAmount;
+  feeAmount: AssetAmount;
+  minAmount: AssetAmount;
 }
-declare function validateSovereignAccountBalances({ amount, sourceData, destinationData, }: ValidateSovereignAccountBalancesProps): void;
+declare function getMax({
+  balanceAmount,
+  existentialDeposit,
+  feeAmount,
+  minAmount,
+}: GetMaxParams): AssetAmount;
+interface GetAssetsBalancesParams {
+  address: string;
+  chain: AnyChain;
+  assets: AssetConfig[];
+  evmSigner?: EvmSigner;
+  polkadot: PolkadotService;
+}
+declare function getAssetsBalances({
+  address,
+  chain,
+  assets,
+  polkadot,
+}: GetAssetsBalancesParams): Promise<AssetAmount[]>;
 
-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>;
-            };
+interface SdkOptions extends Partial<Signers> {
+  configService?: IConfigService;
+}
+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>;
         };
+      };
     };
+  };
+  getTransferData({
+    destinationAddress,
+    destinationKeyOrChain,
+    ethersSigner,
+    evmSigner,
+    keyOrAsset,
+    polkadotSigner,
+    sourceAddress,
+    sourceKeyOrChain,
+  }: SdkTransferParams): Promise<TransferData>;
 };
-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): Promise<string>;
+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 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 };
+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,
+};