@paraspell/sdk 0.0.20 → 0.0.22

package/dist/index.d.ts

@@ -2,17 +2,17 @@ import { ApiPromise } from '@polkadot/api';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
 
 declare const NODE_NAMES: readonly ["Statemint", "Acala", "Astar", "BifrostPolkadot", "Bitgreen", "Centrifuge", "Clover", "ComposableFinance", "Darwinia", "HydraDX", "Interlay", "Kylin", "Litentry", "Moonbeam", "Parallel", "Statemine", "Encointer", "Altair", "Amplitude", "Bajun", "Basilisk", "BifrostKusama", "Pioneer", "Calamari", "CrustShadow", "Crab", "Dorafactory", "Imbue", "Integritee", "InvArchTinker", "Karura", "Kico", "Kintsugi", "Listen", "Litmus", "Mangata", "Moonriver", "ParallelHeiko", "Picasso", "Pichiu", "Quartz", "Robonomics", "Shiden", "Turing"];
+declare const SUPPORTED_PALLETS: readonly ["XTokens", "OrmlXTokens", "PolkadotXcm", "RelayerXcm"];
 
 type UpdateFunction = (name: string, index: number) => string;
 type Extrinsic = SubmittableExtrinsic<'promise'>;
 type ExtrinsicFunction<T> = (arg: T) => Extrinsic;
-type TPalletType = 'xTokens' | 'polkadotXCM' | 'ormlXTokens' | 'relayerXcm';
 type TRelayChainType = 'polkadot' | 'kusama';
 type TNodeDetails = {
     name: string;
     type: TRelayChainType;
 };
-type TNode = typeof NODE_NAMES[number];
+type TNode = (typeof NODE_NAMES)[number];
 type TAssetDetails = {
     assetId: string;
     symbol: string;
@@ -27,16 +27,44 @@ type TNodeAssets = {
 };
 type TAssetJsonMap = Record<TNode, TNodeAssets>;
 type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
+type Bool = 'Yes' | 'No';
+type TPallet = (typeof SUPPORTED_PALLETS)[number];
+type TPalletMap = {
+    defaultPallet: TPallet;
+    supportedPallets: TPallet[];
+};
+type TPalletJsonMap = Record<TNode, TPalletMap>;
 
 declare function send(api: ApiPromise, origin: TNode, currency: string, currencyID: number, amount: any, to: string, destination?: TNode): Extrinsic;
 declare function transferRelayToPara(api: ApiPromise, destination: TNode, amount: any, to: string): Extrinsic | never;
 
-declare const index$3_send: typeof send;
-declare const index$3_transferRelayToPara: typeof transferRelayToPara;
+declare const index$4_send: typeof send;
+declare const index$4_transferRelayToPara: typeof transferRelayToPara;
+declare namespace index$4 {
+  export {
+    index$4_send as send,
+    index$4_transferRelayToPara as transferRelayToPara,
+  };
+}
+
+declare function addLiquidity(api: ApiPromise, assetA: number, assetB: number, amountA: any, amountBMaxLimit: any): Extrinsic;
+declare function buy(api: ApiPromise, assetOut: number, assetIn: number, amount: any, maxLimit: any, discount: Bool): Extrinsic;
+declare function createPool(api: ApiPromise, assetA: number, amountA: any, assetB: number, amountB: any): Extrinsic;
+declare function removeLiquidity(api: ApiPromise, assetA: number, assetB: number, liquidityAmount: any): Extrinsic;
+declare function sell(api: ApiPromise, assetIn: number, assetOut: number, amount: any, maxLimit: any, discount: Bool): Extrinsic;
+
+declare const index$3_addLiquidity: typeof addLiquidity;
+declare const index$3_buy: typeof buy;
+declare const index$3_createPool: typeof createPool;
+declare const index$3_removeLiquidity: typeof removeLiquidity;
+declare const index$3_sell: typeof sell;
 declare namespace index$3 {
   export {
-    index$3_send as send,
-    index$3_transferRelayToPara as transferRelayToPara,
+    index$3_addLiquidity as addLiquidity,
+    index$3_buy as buy,
+    index$3_createPool as createPool,
+    index$3_removeLiquidity as removeLiquidity,
+    index$3_sell as sell,
   };
 }
 
@@ -68,29 +96,112 @@ declare function hasSupportForAsset(node: TNode, symbol: string): boolean;
 declare function getAssetDecimals(node: TNode, symbol: string): number | null;
 declare function getParaId(node: TNode): number;
 
-declare const index_getAssetsObject: typeof getAssetsObject;
+declare const index_getAllAssetsSymbols: typeof getAllAssetsSymbols;
+declare const index_getAssetDecimals: typeof getAssetDecimals;
 declare const index_getAssetId: typeof getAssetId;
-declare const index_getRelayChainSymbol: typeof getRelayChainSymbol;
+declare const index_getAssetsObject: typeof getAssetsObject;
 declare const index_getNativeAssets: typeof getNativeAssets;
 declare const index_getOtherAssets: typeof getOtherAssets;
-declare const index_getAllAssetsSymbols: typeof getAllAssetsSymbols;
-declare const index_hasSupportForAsset: typeof hasSupportForAsset;
-declare const index_getAssetDecimals: typeof getAssetDecimals;
 declare const index_getParaId: typeof getParaId;
+declare const index_getRelayChainSymbol: typeof getRelayChainSymbol;
+declare const index_hasSupportForAsset: typeof hasSupportForAsset;
 declare namespace index {
   export {
-    index_getAssetsObject as getAssetsObject,
+    index_getAllAssetsSymbols as getAllAssetsSymbols,
+    index_getAssetDecimals as getAssetDecimals,
     index_getAssetId as getAssetId,
-    index_getRelayChainSymbol as getRelayChainSymbol,
+    index_getAssetsObject as getAssetsObject,
     index_getNativeAssets as getNativeAssets,
     index_getOtherAssets as getOtherAssets,
-    index_getAllAssetsSymbols as getAllAssetsSymbols,
-    index_hasSupportForAsset as hasSupportForAsset,
-    index_getAssetDecimals as getAssetDecimals,
     index_getParaId as getParaId,
+    index_getRelayChainSymbol as getRelayChainSymbol,
+    index_hasSupportForAsset as hasSupportForAsset,
   };
 }
 
+interface FinalCreatePoolBuilder {
+    build(): Extrinsic;
+}
+interface AmountBCreatePoolBuilder {
+    amountB(amountB: number): FinalCreatePoolBuilder;
+}
+interface AssetBCreatePoolBuilder {
+    assetB(assetB: number): AmountBCreatePoolBuilder;
+}
+interface AmountACreatePoolBuilder {
+    amountA(amountA: number): AssetBCreatePoolBuilder;
+}
+interface AssetACreatePoolBuilder {
+    assetA(assetA: number): AmountACreatePoolBuilder;
+}
+
+interface FinalSellBuilder {
+    build(): Extrinsic;
+}
+interface DiscountSellBuilder {
+    discount(discount: Bool): FinalSellBuilder;
+}
+interface MaxLimitSellBuilder {
+    maxLimit(maxLimit: number): DiscountSellBuilder;
+}
+interface AmountSellBuilder {
+    amount(amount: number): MaxLimitSellBuilder;
+}
+interface AssetOutSellBuilder {
+    assetOut(assetOut: number): AmountSellBuilder;
+}
+interface AssetInSellBuilder {
+    assetIn(assetIn: number): AssetOutSellBuilder;
+}
+
+interface FinalBuyBuilder {
+    build(): Extrinsic;
+}
+interface DiscountBuyBuilder {
+    discount(discount: Bool): FinalBuyBuilder;
+}
+interface MaxLimitBuyBuilder {
+    maxLimit(maxLimit: number): DiscountBuyBuilder;
+}
+interface AmountBuyBuilder {
+    amount(amount: number): MaxLimitBuyBuilder;
+}
+interface AssetInBuyBuilder {
+    assetIn(assetIn: number): AmountBuyBuilder;
+}
+interface AssetOutBuyBuilder {
+    assetOut(assetOut: number): AssetInBuyBuilder;
+}
+
+interface FinalRemoveLiquidityBuilder {
+    build(): Extrinsic;
+}
+interface LiquidityAmountRemoveLiquidityBuilder {
+    liquidityAmount(liquidityAmount: number): FinalRemoveLiquidityBuilder;
+}
+interface AssetBRemoveLiquidityBuilder {
+    assetB(assetB: number): LiquidityAmountRemoveLiquidityBuilder;
+}
+interface AssetARemoveLiquidityBuilder {
+    assetA(assetA: number): AssetBRemoveLiquidityBuilder;
+}
+
+interface FinalAddLiquidityBuilder {
+    build(): Extrinsic;
+}
+interface AmountBMaxLimitAddLiquidityBuilder {
+    amountBMaxLimit(amountBMaxLimit: number): FinalAddLiquidityBuilder;
+}
+interface AmountAAddLiquidityBuilder {
+    amountA(amountA: number): AmountBMaxLimitAddLiquidityBuilder;
+}
+interface AssetBAddLiquidityBuilder {
+    assetB(assetB: number): AmountAAddLiquidityBuilder;
+}
+interface AssetAAddLiquidityBuilder {
+    assetA(assetA: number): AssetBAddLiquidityBuilder;
+}
+
 interface FinalRelayToParaBuilder$1 {
     build(): Extrinsic | never;
 }
@@ -155,7 +266,12 @@ declare class GeneralBuilder {
     constructor(api: ApiPromise);
     from(node: TNode): FromGeneralBuilder;
     to(node: TNode): AmountRelayToParaBuilder;
+    addLiquidity(): AssetAAddLiquidityBuilder;
+    removeLiquidity(): AssetARemoveLiquidityBuilder;
+    buy(): AssetOutBuyBuilder;
+    sell(): AssetInSellBuilder;
+    createPool(): AssetACreatePoolBuilder;
 }
 declare function Builder(api: ApiPromise): GeneralBuilder;
 
-export { Builder, Extrinsic, ExtrinsicFunction, NODE_NAMES, TAssetDetails, TAssetJsonMap, TNativeAssetDetails, TNode, TNodeAssets, TNodeDetails, TPalletType, TRelayChainType, TScenario, UpdateFunction, index as assets, index$1 as closeChannels, index$2 as openChannels, index$3 as xcmPallet };
+export { Bool, Builder, Extrinsic, ExtrinsicFunction, NODE_NAMES, SUPPORTED_PALLETS, TAssetDetails, TAssetJsonMap, TNativeAssetDetails, TNode, TNodeAssets, TNodeDetails, TPallet, TPalletJsonMap, TPalletMap, TRelayChainType, TScenario, UpdateFunction, index as assets, index$1 as closeChannels, index$2 as openChannels, index$4 as xcmPallet, index$3 as xyk };