@paraspell/assets 10.11.10 → 11.0.0

package/dist/index.d.ts

@@ -1,58 +1,58 @@
-import { TMultiLocation, TRelayChainSymbol, TNodeWithRelayChains, TNodeDotKsmWithRelayChains, Version } from '@paraspell/sdk-common';
+import { TLocation, TChain, Version } from '@paraspell/sdk-common';
+
+type TAsset<T = bigint> = TAssetV3<T> | TAssetV4<T>;
+interface TAssetV3<T = bigint> {
+    id: {
+        Concrete: TLocation;
+    };
+    fun: {
+        Fungible: T;
+    };
+}
+interface TAssetV4<T = bigint> {
+    id: TLocation;
+    fun: {
+        Fungible: T;
+    };
+}
 
 type AtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
 }[Keys];
-type TBaseAsset = {
+type TBaseAssetInfo = {
     symbol: string;
-    decimals?: number;
+    decimals: number;
     manuallyAdded?: boolean;
     alias?: string;
     existentialDeposit?: string;
     isFeeAsset?: boolean;
 };
-type TNativeAsset = TBaseAsset & {
+type TNativeAssetInfo = TBaseAssetInfo & {
     isNative: true;
-    multiLocation?: TMultiLocation;
+    location?: TLocation;
 };
-type TForeignAsset = TBaseAsset & AtLeastOne<{
+type TForeignAssetInfo = TBaseAssetInfo & AtLeastOne<{
     assetId?: string;
-    multiLocation?: TMultiLocation;
+    location?: TLocation;
 }>;
-type TForeignAssetWithId = TForeignAsset & {
+type TForeignAssetWithId = TForeignAssetInfo & {
     assetId: string;
 };
-type TAsset = TNativeAsset | TForeignAsset;
-type TAssetWithLocation = TAsset & {
-    multiLocation: TMultiLocation;
+type TAssetInfo = TNativeAssetInfo | TForeignAssetInfo;
+type TAssetWithLocation = TAssetInfo & {
+    location: TLocation;
 };
-type TNodeAssets = {
-    relayChainAssetSymbol: TRelayChainSymbol;
+type TChainAssetsInfo = {
+    relaychainSymbol: string;
     nativeAssetSymbol: string;
     isEVM: boolean;
     ss58Prefix: number;
     supportsDryRunApi: boolean;
     supportsXcmPaymentApi: boolean;
-    nativeAssets: TNativeAsset[];
-    otherAssets: TForeignAsset[];
+    nativeAssets: TNativeAssetInfo[];
+    otherAssets: TForeignAssetInfo[];
 };
-type TAssetJsonMap = Record<TNodeWithRelayChains, TNodeAssets>;
-
-type TMultiAsset<T = bigint> = TMultiAssetV3<T> | TMultiAssetV4<T>;
-interface TMultiAssetV3<T = bigint> {
-    id: {
-        Concrete: TMultiLocation;
-    };
-    fun: {
-        Fungible: T;
-    };
-}
-interface TMultiAssetV4<T = bigint> {
-    id: TMultiLocation;
-    fun: {
-        Fungible: T;
-    };
-}
+type TAssetJsonMap = Record<TChain, TChainAssetsInfo>;
 
 type TAmount = string | number | bigint;
 type TCurrency = string | number | bigint;
@@ -60,9 +60,9 @@ type TSymbolSpecifier = {
     type: 'Native' | 'Foreign' | 'ForeignAbstract';
     value: string;
 };
-type TOverrideMultiLocationSpecifier = {
+type TOverrideLocationSpecifier = {
     type: 'Override';
-    value: TMultiLocation;
+    value: TLocation;
 };
 type TCurrencySymbolValue = string | TSymbolSpecifier;
 type TCurrencySymbol = {
@@ -71,152 +71,148 @@ type TCurrencySymbol = {
 type TCurrencyCore = TCurrencySymbol | {
     id: TCurrency;
 } | {
-    multilocation: TMultiLocationValue;
+    location: TLocationValue;
 };
-type TMultiAssetWithFee = TMultiAsset & {
+type TAssetWithFee = TAsset & {
     isFeeAsset?: boolean;
 };
-type TMultiLocationValue = string | TMultiLocation;
-type TMultiLocationValueWithOverride = TMultiLocationValue | TOverrideMultiLocationSpecifier;
+type TLocationValue = string | TLocation;
+type TLocationValueWithOverride = TLocationValue | TOverrideLocationSpecifier;
 type TCurrencyInputWithAmount = WithComplexAmount<TCurrencySymbol | {
     id: TCurrency;
 } | {
-    multilocation: TMultiLocationValueWithOverride;
-}> | {
-    multiasset: TMultiAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
-};
+    location: TLocationValueWithOverride;
+}> | TAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
 type TCurrencyInput = TCurrencySymbol | {
     id: TCurrency;
 } | {
-    multilocation: TMultiLocationValueWithOverride;
-} | {
-    multiasset: TMultiAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
-};
+    location: TLocationValueWithOverride;
+} | TAsset<TAmount>[] | WithComplexAmount<TCurrencyCore>[];
 type WithAmount<TBase, T = bigint> = TBase & {
     amount: T;
 };
 type WithComplexAmount<TBase> = WithAmount<TBase, TAmount>;
 
 /**
- * Retrieves the existential deposit value for a given node.
+ * Retrieves the existential deposit value for a given chain.
  *
- * @param node - The node for which to get the existential deposit.
- * @returns The existential deposit as a string if available; otherwise, null.
+ * @param chain - The chain for which to get the existential deposit.
+ * @returns The existential deposit as a bigint if available; otherwise, null.
  */
-declare const getExistentialDeposit: (node: TNodeWithRelayChains, currency?: TCurrencyCore) => string | null;
-declare const getExistentialDepositOrThrow: (node: TNodeWithRelayChains, currency?: TCurrencyCore) => bigint;
+declare const getExistentialDeposit: (chain: TChain, currency?: TCurrencyCore) => bigint | null;
+declare const getExistentialDepositOrThrow: (chain: TChain, currency?: TCurrencyCore) => bigint;
 
-declare const getFeeAssets: (node: TNodeDotKsmWithRelayChains) => Omit<TAsset, "isFeeAsset">[];
+declare const getFeeAssets: (chain: TChain) => Omit<TAssetInfo, "isFeeAsset">[];
 
 /**
- * Retrieves the assets object for a given node containing the native and foreign assets.
+ * Retrieves the assets object for a given chain containing the native and foreign assets.
  *
- * @param node - The node for which to retrieve the assets object.
- * @returns The assets object associated with the given node.
+ * @param chain - The chain for which to retrieve the assets object.
+ * @returns The assets object associated with the given chain.
  */
-declare const getAssetsObject: (node: TNodeWithRelayChains) => TNodeAssets;
-declare const isNodeEvm: (node: TNodeWithRelayChains) => boolean;
+declare const getAssetsObject: (chain: TChain) => TChainAssetsInfo;
+declare const isChainEvm: (chain: TChain) => boolean;
 /**
- * Retrieves the asset ID for a given symbol on a specified node.
+ * Retrieves the asset ID for a given symbol on a specified chain.
  *
- * @param node - The node to search for the asset.
+ * @param chain - The chain to search for the asset.
  * @param symbol - The symbol of the asset.
  * @returns The asset ID if found; otherwise, null.
  */
-declare const getAssetId: (node: TNodeWithRelayChains, symbol: string) => string | null;
+declare const getAssetId: (chain: TChain, symbol: string) => string | null;
 /**
- * Retrieves the relay chain asset symbol for a specified node.
+ * Retrieves the relay chain asset symbol for a specified chain.
  *
- * @param node - The node for which to get the relay chain symbol.
+ * @param chain - The chain for which to get the relay chain symbol.
  * @returns The relay chain asset symbol.
  */
-declare const getRelayChainSymbol: (node: TNodeWithRelayChains) => TRelayChainSymbol;
+declare const getRelayChainSymbol: (chain: TChain) => string;
 /**
- * Retrieves the list of native assets for a specified node.
+ * Retrieves the list of native assets for a specified chain.
  *
- * @param node - The node for which to get native assets.
+ * @param chain - The chain for which to get native assets.
  * @returns An array of native asset details.
  */
-declare const getNativeAssets: (node: TNodeWithRelayChains) => TNativeAsset[];
+declare const getNativeAssets: (chain: TChain) => TNativeAssetInfo[];
 /**
- * Retrieves the list of other (non-native) assets for a specified node.
+ * Retrieves the list of other (non-native) assets for a specified chain.
  *
- * @param node - The node for which to get other assets.
+ * @param chain - The chain for which to get other assets.
  * @returns An array of other asset details.
  */
-declare const getOtherAssets: (node: TNodeWithRelayChains) => TForeignAsset[];
+declare const getOtherAssets: (chain: TChain) => TForeignAssetInfo[];
 /**
- * Retrieves the complete list of assets for a specified node, including relay chain asset, native, and other assets.
+ * Retrieves the complete list of assets for a specified chain, including relay chain asset, native, and other assets.
  *
- * @param node - The node for which to get the assets.
- * @returns An array of objects of all assets associated with the node.
+ * @param chain - The chain for which to get the assets.
+ * @returns An array of objects of all assets associated with the chain.
  */
-declare const getAssets: (node: TNodeWithRelayChains) => TAsset[];
+declare const getAssets: (chain: TChain) => TAssetInfo[];
 /**
- * Retrieves the symbols of all assets (relay chain, native, and other assets) for a specified node.
+ * Retrieves the symbols of all assets (relay chain, native, and other assets) for a specified chain.
  *
- * @param node - The node for which to get asset symbols.
+ * @param chain - The chain for which to get asset symbols.
  * @returns An array of asset symbols.
  */
-declare const getAllAssetsSymbols: (node: TNodeWithRelayChains) => string[];
+declare const getAllAssetsSymbols: (chain: TChain) => string[];
 /**
- * Retrieves the symbol of the native asset for a specified node.
+ * Retrieves the symbol of the native asset for a specified chain.
  *
- * @param node - The node for which to get the native asset symbol.
+ * @param chain - The chain for which to get the native asset symbol.
  * @returns The symbol of the native asset.
  */
-declare const getNativeAssetSymbol: (node: TNodeWithRelayChains) => string;
+declare const getNativeAssetSymbol: (chain: TChain) => string;
 /**
- * Determines whether a specified node supports an asset with the given symbol.
+ * Determines whether a specified chain supports an asset with the given symbol.
  *
- * @param node - The node to check for asset support.
+ * @param chain - The chain to check for asset support.
  * @param symbol - The symbol of the asset to check.
  * @returns True if the asset is supported; otherwise, false.
  */
-declare const hasSupportForAsset: (node: TNodeWithRelayChains, symbol: string) => boolean;
+declare const hasSupportForAsset: (chain: TChain, symbol: string) => boolean;
 /**
- * Retrieves the number of decimals for an asset with the given symbol on a specified node.
+ * Retrieves the number of decimals for an asset with the given symbol on a specified chain.
  *
- * @param node - The node where the asset is located.
+ * @param chain - The chain where the asset is located.
  * @param symbol - The symbol of the asset.
  * @returns The number of decimals if the asset is found; otherwise, null.
  */
-declare const getAssetDecimals: (node: TNodeWithRelayChains, symbol: string) => number | null;
-declare const hasDryRunSupport: (node: TNodeWithRelayChains) => boolean;
-declare const hasXcmPaymentApiSupport: (node: TNodeWithRelayChains) => boolean;
+declare const getAssetDecimals: (chain: TChain, symbol: string) => number | null;
+declare const hasDryRunSupport: (chain: TChain) => boolean;
+declare const hasXcmPaymentApiSupport: (chain: TChain) => boolean;
 
 declare const Native: (symbol: string) => TSymbolSpecifier;
 declare const Foreign: (symbol: string) => TSymbolSpecifier;
 declare const ForeignAbstract: (symbol: string) => TSymbolSpecifier;
-declare const Override: (multiLocation: TMultiLocation) => TOverrideMultiLocationSpecifier;
+declare const Override: (location: TLocation) => TOverrideLocationSpecifier;
 
-declare const filterEthCompatibleAssets: (assets: TForeignAsset[]) => TForeignAsset[];
+declare const filterEthCompatibleAssets: (assets: TForeignAssetInfo[]) => TForeignAssetInfo[];
 
 /**
- * Retrieves the list of assets that are supported for transfers between two specified nodes.
+ * Retrieves the list of assets that are supported for transfers between two specified chains.
  *
- * @param origin - The origin node.
- * @param destination - The destination node.
- * @returns An array of assets supported between the origin and destination nodes.
+ * @param origin - The origin chain.
+ * @param destination - The destination chain.
+ * @returns An array of assets supported between the origin and destination chains.
  */
-declare const getSupportedAssets: (origin: TNodeWithRelayChains, destination: TNodeWithRelayChains) => TAsset[];
+declare const getSupportedAssets: (origin: TChain, destination: TChain) => TAssetInfo[];
 
-declare const getSupportedDestinations: (origin: TNodeWithRelayChains, currency: TCurrencyCore) => TNodeWithRelayChains[];
+declare const getSupportedDestinations: (origin: TChain, currency: TCurrencyCore) => TChain[];
 
-declare const isAssetEqual: (asset1: TAsset, asset2: TAsset) => boolean;
+declare const isAssetEqual: (asset1: TAssetInfo, asset2: TAssetInfo) => boolean;
 
 declare const isSymbolMatch: (symbolA: string, symbolB: string) => boolean;
 
 /**
- * Converts a multi-location to a specific XCM version . Defaults to XCM v4.
+ * Converts a location to a specific XCM version
  *
  * In XCM v3, `interior.X1` is a single `Object`. In XCM V4, `interior.X1` is an `Array<Object>`.
  *
- * @param multiLocation - The multi-location to normalize.
- * @param version - The target XCM version: `'V3'`, `'V4'` or `'V5'`. Defaults to `'V4'`.
- * @returns A new transformed `TMultiLocation`
+ * @param location - The location to normalize.
+ * @param version - The target XCM version: `'V3'`, `'V4'` or `'V5'`. Defaults to `'V5'`.
+ * @returns A new transformed `TLocation`
  */
-declare const normalizeMultiLocation: (multiLocation: TMultiLocation, version?: Version) => TMultiLocation;
+declare const normalizeLocation: (location: TLocation, version?: Version) => TLocation;
 
 /**
  * Normalizes an asset symbol by stripping the 'xc' prefix (if present) and converting it to lowercase.
@@ -226,18 +222,18 @@ declare const normalizeMultiLocation: (multiLocation: TMultiLocation, version?:
  */
 declare const normalizeSymbol: (symbol: string | undefined) => string;
 
-declare const findAsset: (node: TNodeWithRelayChains, currency: TCurrencyInput, destination: TNodeWithRelayChains | null) => TAsset | null;
+declare const findAssetInfo: (chain: TChain, currency: TCurrencyInput, destination: TChain | null) => TAssetInfo | null;
 
-declare const findAssetById: (assets: TForeignAsset[], assetId: TCurrency) => TForeignAsset | undefined;
+declare const findAssetInfoById: (assets: TForeignAssetInfo[], assetId: TCurrency) => TForeignAssetInfo | undefined;
 
-declare const findAssetByMultiLocation: (foreignAssets: TForeignAsset[], multiLocation: string | TMultiLocation) => TForeignAsset | undefined;
+declare const findAssetInfoByLoc: (foreignAssets: TForeignAssetInfo[], location: string | TLocation) => TForeignAssetInfo | undefined;
 
-declare const findAssetBySymbol: (destination: TNodeWithRelayChains | null, otherAssets: TForeignAsset[], nativeAssets: TNativeAsset[], symbol: TCurrencySymbolValue) => TAsset | undefined;
+declare const findAssetInfoBySymbol: (destination: TChain | null, otherAssets: TForeignAssetInfo[], nativeAssets: TNativeAssetInfo[], symbol: TCurrencySymbolValue) => TAssetInfo | undefined;
 
-declare const findAssetForNodeOrThrow: (node: TNodeWithRelayChains, currency: TCurrencyInput, destination: TNodeWithRelayChains | null) => TAsset;
+declare const findAssetInfoOnDest: (origin: TChain, destination: TChain, currency: TCurrencyInput, originAsset?: TAssetInfo | null) => TAssetInfo | null;
+declare const findAssetOnDestOrThrow: (origin: TChain, destination: TChain, currency: TCurrencyInput) => TAssetInfo;
 
-declare const findAssetOnDest: (origin: TNodeWithRelayChains, destination: TNodeWithRelayChains, currency: TCurrencyInput, originAsset?: TAsset | null) => TAsset | null;
-declare const findAssetOnDestOrThrow: (origin: TNodeWithRelayChains, destination: TNodeWithRelayChains, currency: TCurrencyInput) => TAsset;
+declare const findAssetInfoOrThrow: (chain: TChain, currency: TCurrencyInput, destination: TChain | null) => TAssetInfo;
 
 declare const findBestMatches: <T extends {
     symbol: string;
@@ -280,19 +276,19 @@ declare class InvalidCurrencyError extends Error {
     constructor(message: string);
 }
 
-declare const isForeignAsset: (asset: TAsset) => asset is TForeignAsset;
+declare const isForeignAsset: (asset: TAssetInfo) => asset is TForeignAssetInfo;
 
-declare const isOverrideMultiLocationSpecifier: (multiLocationSpecifier: TMultiLocationValueWithOverride) => multiLocationSpecifier is TOverrideMultiLocationSpecifier;
+declare const isOverrideLocationSpecifier: (locationSpecifier: TLocationValueWithOverride) => locationSpecifier is TOverrideLocationSpecifier;
 
 declare const isSymbolSpecifier: (currencySymbolValue: TCurrencySymbolValue) => currencySymbolValue is TSymbolSpecifier;
 
-declare const isTMultiAsset: <T = bigint>(value: unknown) => value is TMultiAsset<T>;
+declare const isTAsset: <T = bigint>(value: unknown) => value is TAsset<T>;
 
-declare const compareMultiLocations: (input: string, asset: TForeignAsset) => boolean;
+declare const compareLocations: (input: string, asset: TForeignAssetInfo) => boolean;
 
-declare const extractMultiAssetLoc: <T = bigint>(multiAsset: TMultiAsset<T>) => TMultiLocation;
+declare const extractAssetLocation: <T = bigint>(asset: TAsset<T>) => TLocation;
 
-declare const getAssetMultiLocation: (node: TNodeWithRelayChains, currency: TCurrencyInput) => TMultiLocation | null;
+declare const getAssetLocation: (chain: TChain, currency: TCurrencyInput) => TLocation | null;
 
-export { DuplicateAssetError, DuplicateAssetIdError, Foreign, ForeignAbstract, InvalidCurrencyError, Native, Override, compareMultiLocations, extractMultiAssetLoc, filterEthCompatibleAssets, findAsset, findAssetById, findAssetByMultiLocation, findAssetBySymbol, findAssetForNodeOrThrow, findAssetOnDest, findAssetOnDestOrThrow, findBestMatches, getAllAssetsSymbols, getAssetDecimals, getAssetId, getAssetMultiLocation, getAssets, getAssetsObject, getExistentialDeposit, getExistentialDepositOrThrow, getFeeAssets, getNativeAssetSymbol, getNativeAssets, getOtherAssets, getRelayChainSymbol, getSupportedAssets, getSupportedDestinations, hasDryRunSupport, hasSupportForAsset, hasXcmPaymentApiSupport, isAssetEqual, isForeignAsset, isNodeEvm, isOverrideMultiLocationSpecifier, isSymbolMatch, isSymbolSpecifier, isTMultiAsset, normalizeMultiLocation, normalizeSymbol };
-export type { TAmount, TAsset, TAssetJsonMap, TAssetWithLocation, TCurrency, TCurrencyCore, TCurrencyInput, TCurrencyInputWithAmount, TCurrencySymbol, TCurrencySymbolValue, TForeignAsset, TForeignAssetWithId, TMultiAsset, TMultiAssetV3, TMultiAssetV4, TMultiAssetWithFee, TMultiLocationValue, TMultiLocationValueWithOverride, TNativeAsset, TNodeAssets, TOverrideMultiLocationSpecifier, TSymbolSpecifier, WithAmount, WithComplexAmount };
+export { DuplicateAssetError, DuplicateAssetIdError, Foreign, ForeignAbstract, InvalidCurrencyError, Native, Override, compareLocations, extractAssetLocation, filterEthCompatibleAssets, findAssetInfo, findAssetInfoById, findAssetInfoByLoc, findAssetInfoBySymbol, findAssetInfoOnDest, findAssetInfoOrThrow, findAssetOnDestOrThrow, findBestMatches, getAllAssetsSymbols, getAssetDecimals, getAssetId, getAssetLocation, getAssets, getAssetsObject, getExistentialDeposit, getExistentialDepositOrThrow, getFeeAssets, getNativeAssetSymbol, getNativeAssets, getOtherAssets, getRelayChainSymbol, getSupportedAssets, getSupportedDestinations, hasDryRunSupport, hasSupportForAsset, hasXcmPaymentApiSupport, isAssetEqual, isChainEvm, isForeignAsset, isOverrideLocationSpecifier, isSymbolMatch, isSymbolSpecifier, isTAsset, normalizeLocation, normalizeSymbol };
+export type { TAmount, TAsset, TAssetInfo, TAssetJsonMap, TAssetV3, TAssetV4, TAssetWithFee, TAssetWithLocation, TChainAssetsInfo, TCurrency, TCurrencyCore, TCurrencyInput, TCurrencyInputWithAmount, TCurrencySymbol, TCurrencySymbolValue, TForeignAssetInfo, TForeignAssetWithId, TLocationValue, TLocationValueWithOverride, TNativeAssetInfo, TOverrideLocationSpecifier, TSymbolSpecifier, WithAmount, WithComplexAmount };