@paraspell/sdk 0.0.19 → 0.0.21

package/README.md

@@ -1,5 +1,6 @@
 
 # @paraspell/sdk
+![Full name (3)](https://user-images.githubusercontent.com/55763425/197985791-fc7afa52-061d-413a-bbe9-bf1123f16a50.png)
 
   
 
@@ -12,9 +13,9 @@
 
 SDK For XCM & XCMP handling made with ❤️ by ParaSpell✨. It is no longer necessary to construct calls manually. @paraspell/sdk handles this for you. Feel free to become magician and try your paraSPELLS 🧙✨. 
 
-#####  Currently supporting 42 Polkadot & Kusama nodes list [here](https://github.com/paraspell/sdk/blob/beta-pre-release/docs/supportedNodes.md). 
+#####  Currently supporting 42 Polkadot & Kusama nodes list [here](https://github.com/paraspell/sdk/blob/beta-pre-release/docs/supporxxtedNodes.md). 
 
-  
+### Check out our brand new Wiki documentation! [Wiki docs](https://paraspell.github.io/docs/)
 
 ## Usage
 
@@ -41,25 +42,45 @@ pnpm install @paraspell/sdk
 
  ##### Importing package to your project:
 
- 
+If you wish to use XCM, HRMP, XYK Pallets only you can import Builder like this:
 ```js
+import { Builder } from '@paraspell/sdk'
+```
 
+Old function like import (With assets):
+```js
 // ESM
 import  *  as  paraspell  from  '@paraspell/sdk'
 
 // CommonJS
 const paraspell = require('@paraspell/sdk')
-
 ```
 
   
 
 ## Currently implemented pallets
+XCM pallet (Combined xTokens, polkadotXCM, ormlXTokens, XcmPallet & relayerXCM):
 
+Builder pattern XCM & HRMP construction
 ```ts
+//Transfer tokens from Parachain to Parachain
+Builder(api).from(NODE).to(NODE).currency(CurrencyString).currencyId(currencyId).amount(amount).address(address).build()
+
+//Transfer tokens from Relay chain to Parachain
+Builder(api).to(NODE).amount(amount).address(address).build()
+      
+//Transfer tokens from Parachain to Relay chain
+Builder(api).from(NODE).currency(CurrencyString).currencyId(currencyId).amount(amount).address(address).build()
+
+//Close HRMP channels
+Builder(api).from(NODE).closeChannel().inbound(inbound).outbound(outbound).build()
 
-//XCM pallet (Combined xTokens, polkadotXCM, ormlXTokens, XcmPallet & relayerXCM):
+//Open HRMP channels
+Builder(api).from(NODE).to(NODE).openChannel().maxSize(maxSize).maxMessageSize(maxMsgSize).build()'
+```
 
+Function pattern XCM & HRMP construction
+```ts
 //Transfer tokens from Parachain to Parachain
 paraspell.xcmPallet.send(api: ApiPromise, origin: origin  Parachain  name  string, currency: currency  symbol  string, currencyID: number (If applicable), amount: any, to: destination  address  string, destination: destination  Parachain  ID)
 
@@ -70,19 +91,16 @@ paraspell.xcmPallet.send(api: ApiPromise, origin: origin  Parachain  name  strin
 paraspell.xcmPallet.transferRelayToPara(api: ApiPromise, destination: destination  Parachain  ID, amount: any, to: destination  address  string)
 
 //hrmp pallet:
-
 //Close HRMP channels
 paraspell.closeChannels.closeChannel(api: ApiPromise, origin: origin  Parachain  ID, inbound: number, outbound: number)
 
-
 //parasSudoWrapper pallet:
-
 //Open HRMP channels
 paraspell.openChannels.openChannel(api: ApiPromise, origin: origin  Parachain  ID, destination: destination  Parachain  ID, maxSize: number, maxMessageSize: number)
+```
+Asset pallet contruction:
 
-
-//Asset pallet
-
+```ts
 //Returns assets object from assets.json for particular node including information about native and foreign assets
 paraspell.assets.getAssetsObject(node: TNode)
 
@@ -112,7 +130,42 @@ paraspell.assets.getParaId(node: TNode)
 
 //Import all compatible nodes as constant:
 paraspell.NODE_NAMES
+```
+Basilisk XYK pallet contruction
+
+Builder patternn XYK construction
+```ts
+//Add liquidity to specific pool
+Builder(api).addLiquidity().assetA(assetA).assetB(assetB).amountA(amountA).amountBMaxLimit(maxLimit).build()
 
+//Remove liquidity from specific pool
+Builder(api).removeLiquidity().assetA(assetA).assetB(assetB).liquidityAmount(liquidity).build()
+
+//Create pool
+Builder(api).createPool().assetA(assetA).amountA(amountA).assetB(assetB).amountB(amountB).build()
+
+//Buy specific asset from pool
+Builder(api).buy().assetOut(out).assetIn(in).amount(amount).maxLimit(maxLimit).discount(discount).build()
+
+//Sell specific asset from pool
+Builder(api).sell().assetIn(in).assetOut(out).amount(amount).maxLimit(maxLimit).discount(discount).build()
+```
+Function pattern XYK contruction
+```ts
+//Add liquidity to specific pool
+paraspell.xyk.addLiquidity(api: ApiPromise, assetA: number, assetB: number, amountA: any, amountBMaxLimit: any)
+
+//Remove liquidity from specific pool
+paraspell.xyk.removeLiquidity(api: ApiPromise, assetA: number, assetB: number, liquidityAmount: any)
+
+//Create pool
+paraspell.xyk.createPool(api: ApiPromise, assetA: number, amountA: any, assetB: number, amountB: any)
+
+//Buy specific asset from pool
+paraspell.xyk.buy(api: ApiPromise, assetOut: number, assetIn: number, amount: any, maxLimit: any, discount: Bool)
+
+//Sell specific asset from pool
+paraspell.xyk.sell(api: ApiPromise, assetIn: number, assetOut: number, amount: any, maxLimit: any, discount: Bool)
 ```
 
  ##### Example of usage can be found in the UI repository [here](https://github.com/paraspell/ui) or in the Astarot repository [here](https://github.com/paraspell/astarot)
@@ -139,8 +192,11 @@ paraspell.NODE_NAMES
 
 
 ## Founded by
+[<img width="245" alt="web3 foundation_grants_badge_black" src="https://user-images.githubusercontent.com/55763425/211145923-f7ee2a57-3e63-4b7d-9674-2da9db46b2ee.png">](https://github.com/w3f/Grants-Program/pull/1245)
+[<img width="245" alt="web3 foundation_grants_badge_white (1)" src="https://user-images.githubusercontent.com/55763425/211069914-bbec9e28-7a0d-417b-8149-087b7f04e57e.png">](https://github.com/w3f/Grants-Program/pull/1245)
+
 [![logo-v1](https://user-images.githubusercontent.com/55763425/204865221-90d2b3cd-f2ac-48a2-a367-08722aa8e923.svg)](https://bsx.fi/)
-  
+
 
 
 ## License

package/dist/index.cjs

@@ -3509,40 +3509,39 @@ const assets = {
 const assetsMap = {
   __proto__: null,
   Acala: Acala,
-  Astar: Astar,
-  BifrostPolkadot: BifrostPolkadot,
-  Bitgreen: Bitgreen,
-  Centrifuge: Centrifuge,
-  Clover: Clover,
-  ComposableFinance: ComposableFinance,
-  Darwinia: Darwinia,
-  HydraDX: HydraDX,
-  Interlay: Interlay,
-  Kylin: Kylin,
-  Litentry: Litentry,
-  Moonbeam: Moonbeam,
-  Parallel: Parallel,
-  Statemint: Statemint,
   Altair: Altair,
   Amplitude: Amplitude,
+  Astar: Astar,
   Bajun: Bajun,
   Basilisk: Basilisk,
   BifrostKusama: BifrostKusama,
+  BifrostPolkadot: BifrostPolkadot,
+  Bitgreen: Bitgreen,
   Calamari: Calamari,
+  Centrifuge: Centrifuge,
+  Clover: Clover,
+  ComposableFinance: ComposableFinance,
   Crab: Crab,
   CrustShadow: CrustShadow,
+  Darwinia: Darwinia,
   Dorafactory: Dorafactory,
   Encointer: Encointer,
+  HydraDX: HydraDX,
   Imbue: Imbue,
   Integritee: Integritee,
+  Interlay: Interlay,
   InvArchTinker: InvArchTinker,
-  Kico: Kico,
   Karura: Karura,
+  Kico: Kico,
   Kintsugi: Kintsugi,
+  Kylin: Kylin,
   Listen: Listen,
+  Litentry: Litentry,
   Litmus: Litmus,
   Mangata: Mangata,
+  Moonbeam: Moonbeam,
   Moonriver: Moonriver,
+  Parallel: Parallel,
   ParallelHeiko: ParallelHeiko,
   Picasso: Picasso,
   Pichiu: Pichiu,
@@ -3551,6 +3550,7 @@ const assetsMap = {
   Robonomics: Robonomics,
   Shiden: Shiden,
   Statemine: Statemine,
+  Statemint: Statemint,
   Turing: Turing,
   default: assets
 };
@@ -3597,17 +3597,17 @@ function getParaId(node) {
   return getAssetsObject(node).paraId;
 }
 
-const index$3 = {
+const index$4 = {
   __proto__: null,
-  getAssetsObject: getAssetsObject,
+  getAllAssetsSymbols: getAllAssetsSymbols,
+  getAssetDecimals: getAssetDecimals,
   getAssetId: getAssetId,
-  getRelayChainSymbol: getRelayChainSymbol,
+  getAssetsObject: getAssetsObject,
   getNativeAssets: getNativeAssets,
   getOtherAssets: getOtherAssets,
-  getAllAssetsSymbols: getAllAssetsSymbols,
-  hasSupportForAsset: hasSupportForAsset,
-  getAssetDecimals: getAssetDecimals,
-  getParaId: getParaId
+  getParaId: getParaId,
+  getRelayChainSymbol: getRelayChainSymbol,
+  hasSupportForAsset: hasSupportForAsset
 };
 
 class InvalidCurrencyError extends Error {
@@ -3702,12 +3702,63 @@ function transferRelayToPara(api, destination, amount, to) {
   );
 }
 
-const index$2 = {
+const index$3 = {
   __proto__: null,
   send: send,
   transferRelayToPara: transferRelayToPara
 };
 
+function addLiquidity(api, assetA, assetB, amountA, amountBMaxLimit) {
+  return api.tx.xyk.addLiquidity(
+    assetA,
+    assetB,
+    amountA,
+    amountBMaxLimit
+  );
+}
+function buy(api, assetOut, assetIn, amount, maxLimit, discount) {
+  return api.tx.xyk.buy(
+    assetOut,
+    assetIn,
+    amount,
+    maxLimit,
+    discount
+  );
+}
+function createPool(api, assetA, amountA, assetB, amountB) {
+  return api.tx.xyk.createPool(
+    assetA,
+    amountA,
+    assetB,
+    amountB
+  );
+}
+function removeLiquidity(api, assetA, assetB, liquidityAmount) {
+  return api.tx.xyk.removeLiquidity(
+    assetA,
+    assetB,
+    liquidityAmount
+  );
+}
+function sell(api, assetIn, assetOut, amount, maxLimit, discount) {
+  return api.tx.xyk.sell(
+    assetIn,
+    assetOut,
+    amount,
+    maxLimit,
+    discount
+  );
+}
+
+const index$2 = {
+  __proto__: null,
+  addLiquidity: addLiquidity,
+  buy: buy,
+  createPool: createPool,
+  removeLiquidity: removeLiquidity,
+  sell: sell
+};
+
 function openChannel(api, origin, destination, maxSize, maxMessageSize) {
   return api.tx.sudo.sudo(
     api.tx.parasSudoWrapper.sudoEstablishHrmpChannel(
@@ -3733,8 +3784,315 @@ const index = {
   closeChannel: closeChannel
 };
 
+class AddLiquidityBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new AddLiquidityBuilder(api);
+  }
+  assetA(assetA) {
+    this._assetA = assetA;
+    return this;
+  }
+  assetB(assetB) {
+    this._assetB = assetB;
+    return this;
+  }
+  amountA(amountA) {
+    this._amountA = amountA;
+    return this;
+  }
+  amountBMaxLimit(amountBMaxLimit) {
+    this._amountBMaxLimit = amountBMaxLimit;
+    return this;
+  }
+  build() {
+    return addLiquidity(this.api, this._assetA, this._assetB, this._amountA, this._amountBMaxLimit);
+  }
+}
+const AddLiquidityBuilder$1 = AddLiquidityBuilder;
+
+class BuyBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new BuyBuilder(api);
+  }
+  assetOut(assetOut) {
+    this._assetOut = assetOut;
+    return this;
+  }
+  assetIn(assetIn) {
+    this._assetIn = assetIn;
+    return this;
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  maxLimit(maxLimit) {
+    this._maxLimit = maxLimit;
+    return this;
+  }
+  discount(discount) {
+    this._discount = discount;
+    return this;
+  }
+  build() {
+    return buy(this.api, this._assetOut, this._assetIn, this._amount, this._maxLimit, this._discount);
+  }
+}
+const BuyBuilder$1 = BuyBuilder;
+
+class CloseChannelBuilder {
+  constructor(api, from) {
+    this.api = api;
+    this.from = from;
+  }
+  static create(api, from) {
+    return new CloseChannelBuilder(api, from);
+  }
+  inbound(inbound) {
+    this._inbound = inbound;
+    return this;
+  }
+  outbound(outbound) {
+    this._outbound = outbound;
+    return this;
+  }
+  build() {
+    return closeChannel(this.api, this.from, this._inbound, this._outbound);
+  }
+}
+const CloseChannelBuilder$1 = CloseChannelBuilder;
+
+class CreatePoolBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new CreatePoolBuilder(api);
+  }
+  assetA(assetA) {
+    this._assetA = assetA;
+    return this;
+  }
+  amountA(amountA) {
+    this._amountA = amountA;
+    return this;
+  }
+  assetB(assetB) {
+    this._assetB = assetB;
+    return this;
+  }
+  amountB(amountB) {
+    this._amountB = amountB;
+    return this;
+  }
+  build() {
+    return createPool(this.api, this._assetA, this._amountA, this._assetB, this._amountB);
+  }
+}
+const CreatePoolBuilder$1 = CreatePoolBuilder;
+
+class OpenChannelBuilder {
+  constructor(api, from, to) {
+    this.api = api;
+    this.from = from;
+    this.to = to;
+  }
+  static create(api, from, to) {
+    return new OpenChannelBuilder(api, from, to);
+  }
+  maxSize(size) {
+    this._maxSize = size;
+    return this;
+  }
+  maxMessageSize(size) {
+    this._maxMessageSize = size;
+    return this;
+  }
+  build() {
+    return openChannel(this.api, this.from, this.to, this._maxSize, this._maxMessageSize);
+  }
+}
+const OpenChannelBuilder$1 = OpenChannelBuilder;
+
+class RelayToParaBuilder {
+  constructor(api, to) {
+    this.api = api;
+    this.to = to;
+  }
+  static create(api, to) {
+    return new RelayToParaBuilder(api, to);
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  address(address) {
+    this._address = address;
+    return this;
+  }
+  build() {
+    return transferRelayToPara(this.api, this.to, this._amount, this._address);
+  }
+}
+const RelayToParaBuilder$1 = RelayToParaBuilder;
+
+class RemoveLiquidityBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new RemoveLiquidityBuilder(api);
+  }
+  assetA(assetA) {
+    this._assetA = assetA;
+    return this;
+  }
+  assetB(assetB) {
+    this._assetB = assetB;
+    return this;
+  }
+  liquidityAmount(liquidityAmount) {
+    this._liquidityAmount = liquidityAmount;
+    return this;
+  }
+  build() {
+    return removeLiquidity(this.api, this._assetA, this._assetB, this._liquidityAmount);
+  }
+}
+const RemoveLiquidityBuilder$1 = RemoveLiquidityBuilder;
+
+class SellBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new SellBuilder(api);
+  }
+  assetIn(assetIn) {
+    this._assetIn = assetIn;
+    return this;
+  }
+  assetOut(assetOut) {
+    this._assetOut = assetOut;
+    return this;
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  maxLimit(maxLimit) {
+    this._maxLimit = maxLimit;
+    return this;
+  }
+  discount(discount) {
+    this._discount = discount;
+    return this;
+  }
+  build() {
+    return sell(this.api, this._assetIn, this._assetOut, this._amount, this._maxLimit, this._discount);
+  }
+}
+const SellBuilder$1 = SellBuilder;
+
+class SendBuilder {
+  constructor(api, from, to, currency) {
+    this.api = api;
+    this.from = from;
+    this.to = to;
+    this.currency = currency;
+  }
+  static createParaToRelay(api, from, currency) {
+    return new SendBuilder(api, from, void 0, currency);
+  }
+  static createParaToPara(api, from, to, currency) {
+    return new SendBuilder(api, from, to, currency);
+  }
+  currencyId(currencyId) {
+    this._currencyId = currencyId;
+    return this;
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  address(address) {
+    this._address = address;
+    return this;
+  }
+  build() {
+    return send(this.api, this.from, this.currency, this._currencyId, this._amount, this._address, this.to);
+  }
+}
+const SendBuilder$1 = SendBuilder;
+
+class ToGeneralBuilder {
+  constructor(api, from, to) {
+    this.api = api;
+    this.from = from;
+    this.to = to;
+  }
+  currency(currency) {
+    return SendBuilder$1.createParaToPara(this.api, this.from, this.to, currency);
+  }
+  openChannel() {
+    return OpenChannelBuilder$1.create(this.api, this.from, this.to);
+  }
+}
+class FromGeneralBuilder {
+  constructor(api, from) {
+    this.api = api;
+    this.from = from;
+  }
+  to(node) {
+    return new ToGeneralBuilder(this.api, this.from, node);
+  }
+  currency(currency) {
+    return SendBuilder$1.createParaToRelay(this.api, this.from, currency);
+  }
+  closeChannel() {
+    return CloseChannelBuilder$1.create(this.api, this.from);
+  }
+}
+class GeneralBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  from(node) {
+    return new FromGeneralBuilder(this.api, node);
+  }
+  to(node) {
+    return RelayToParaBuilder$1.create(this.api, node);
+  }
+  addLiquidity() {
+    return AddLiquidityBuilder$1.create(this.api);
+  }
+  removeLiquidity() {
+    return RemoveLiquidityBuilder$1.create(this.api);
+  }
+  buy() {
+    return BuyBuilder$1.create(this.api);
+  }
+  sell() {
+    return SellBuilder$1.create(this.api);
+  }
+  createPool() {
+    return CreatePoolBuilder$1.create(this.api);
+  }
+}
+function Builder(api) {
+  return new GeneralBuilder(api);
+}
+
+exports.Builder = Builder;
 exports.NODE_NAMES = NODE_NAMES;
-exports.assets = index$3;
+exports.assets = index$4;
 exports.closeChannels = index;
 exports.openChannels = index$1;
-exports.xcmPallet = index$2;
+exports.xcmPallet = index$3;
+exports.xyk = index$2;

package/dist/index.d.ts

@@ -27,16 +27,38 @@ type TNodeAssets = {
 };
 type TAssetJsonMap = Record<TNode, TNodeAssets>;
 type TScenario = 'ParaToRelay' | 'ParaToPara' | 'RelayToPara';
+type Bool = 'Yes' | 'No';
 
 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,27 +90,182 @@ 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,
   };
 }
 
-export { 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 };
+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;
+}
+interface AddressRelayToParaBuilder {
+    address(address: string): FinalRelayToParaBuilder$1;
+}
+interface AmountRelayToParaBuilder {
+    amount(amount: number): AddressRelayToParaBuilder;
+}
+
+interface FinalCloseChannelBuilder {
+    build(): Extrinsic;
+}
+interface OutboundCloseChannelBuilder {
+    outbound(inbound: number): FinalCloseChannelBuilder;
+}
+interface InboundCloseChannelBuilder {
+    inbound(inbound: number): OutboundCloseChannelBuilder;
+}
+
+interface FinalOpenChannelBuilder {
+    build(): Extrinsic;
+}
+interface MaxMessageSizeOpenChannelBuilder {
+    maxMessageSize(size: number): FinalOpenChannelBuilder;
+}
+interface MaxSizeOpenChannelBuilder {
+    maxSize(size: number): MaxMessageSizeOpenChannelBuilder;
+}
+
+interface FinalRelayToParaBuilder {
+    build(): Extrinsic | never;
+}
+interface AddressSendBuilder {
+    address(address: string): FinalRelayToParaBuilder;
+}
+interface AmountSendBuilder {
+    amount(amount: any): AddressSendBuilder;
+}
+interface CurrencyIdSendBuilder {
+    currencyId(currencyId: number): AmountSendBuilder;
+}
+
+declare class ToGeneralBuilder {
+    private api;
+    private from;
+    private to;
+    constructor(api: ApiPromise, from: TNode, to: TNode);
+    currency(currency: string): CurrencyIdSendBuilder;
+    openChannel(): MaxSizeOpenChannelBuilder;
+}
+declare class FromGeneralBuilder {
+    private api;
+    private from;
+    constructor(api: ApiPromise, from: TNode);
+    to(node: TNode): ToGeneralBuilder;
+    currency(currency: string): CurrencyIdSendBuilder;
+    closeChannel(): InboundCloseChannelBuilder;
+}
+declare class GeneralBuilder {
+    private api;
+    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 { Bool, 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$4 as xcmPallet, index$3 as xyk };

package/dist/index.mjs

@@ -3507,40 +3507,39 @@ const assets = {
 const assetsMap = {
   __proto__: null,
   Acala: Acala,
-  Astar: Astar,
-  BifrostPolkadot: BifrostPolkadot,
-  Bitgreen: Bitgreen,
-  Centrifuge: Centrifuge,
-  Clover: Clover,
-  ComposableFinance: ComposableFinance,
-  Darwinia: Darwinia,
-  HydraDX: HydraDX,
-  Interlay: Interlay,
-  Kylin: Kylin,
-  Litentry: Litentry,
-  Moonbeam: Moonbeam,
-  Parallel: Parallel,
-  Statemint: Statemint,
   Altair: Altair,
   Amplitude: Amplitude,
+  Astar: Astar,
   Bajun: Bajun,
   Basilisk: Basilisk,
   BifrostKusama: BifrostKusama,
+  BifrostPolkadot: BifrostPolkadot,
+  Bitgreen: Bitgreen,
   Calamari: Calamari,
+  Centrifuge: Centrifuge,
+  Clover: Clover,
+  ComposableFinance: ComposableFinance,
   Crab: Crab,
   CrustShadow: CrustShadow,
+  Darwinia: Darwinia,
   Dorafactory: Dorafactory,
   Encointer: Encointer,
+  HydraDX: HydraDX,
   Imbue: Imbue,
   Integritee: Integritee,
+  Interlay: Interlay,
   InvArchTinker: InvArchTinker,
-  Kico: Kico,
   Karura: Karura,
+  Kico: Kico,
   Kintsugi: Kintsugi,
+  Kylin: Kylin,
   Listen: Listen,
+  Litentry: Litentry,
   Litmus: Litmus,
   Mangata: Mangata,
+  Moonbeam: Moonbeam,
   Moonriver: Moonriver,
+  Parallel: Parallel,
   ParallelHeiko: ParallelHeiko,
   Picasso: Picasso,
   Pichiu: Pichiu,
@@ -3549,6 +3548,7 @@ const assetsMap = {
   Robonomics: Robonomics,
   Shiden: Shiden,
   Statemine: Statemine,
+  Statemint: Statemint,
   Turing: Turing,
   default: assets
 };
@@ -3595,17 +3595,17 @@ function getParaId(node) {
   return getAssetsObject(node).paraId;
 }
 
-const index$3 = {
+const index$4 = {
   __proto__: null,
-  getAssetsObject: getAssetsObject,
+  getAllAssetsSymbols: getAllAssetsSymbols,
+  getAssetDecimals: getAssetDecimals,
   getAssetId: getAssetId,
-  getRelayChainSymbol: getRelayChainSymbol,
+  getAssetsObject: getAssetsObject,
   getNativeAssets: getNativeAssets,
   getOtherAssets: getOtherAssets,
-  getAllAssetsSymbols: getAllAssetsSymbols,
-  hasSupportForAsset: hasSupportForAsset,
-  getAssetDecimals: getAssetDecimals,
-  getParaId: getParaId
+  getParaId: getParaId,
+  getRelayChainSymbol: getRelayChainSymbol,
+  hasSupportForAsset: hasSupportForAsset
 };
 
 class InvalidCurrencyError extends Error {
@@ -3700,12 +3700,63 @@ function transferRelayToPara(api, destination, amount, to) {
   );
 }
 
-const index$2 = {
+const index$3 = {
   __proto__: null,
   send: send,
   transferRelayToPara: transferRelayToPara
 };
 
+function addLiquidity(api, assetA, assetB, amountA, amountBMaxLimit) {
+  return api.tx.xyk.addLiquidity(
+    assetA,
+    assetB,
+    amountA,
+    amountBMaxLimit
+  );
+}
+function buy(api, assetOut, assetIn, amount, maxLimit, discount) {
+  return api.tx.xyk.buy(
+    assetOut,
+    assetIn,
+    amount,
+    maxLimit,
+    discount
+  );
+}
+function createPool(api, assetA, amountA, assetB, amountB) {
+  return api.tx.xyk.createPool(
+    assetA,
+    amountA,
+    assetB,
+    amountB
+  );
+}
+function removeLiquidity(api, assetA, assetB, liquidityAmount) {
+  return api.tx.xyk.removeLiquidity(
+    assetA,
+    assetB,
+    liquidityAmount
+  );
+}
+function sell(api, assetIn, assetOut, amount, maxLimit, discount) {
+  return api.tx.xyk.sell(
+    assetIn,
+    assetOut,
+    amount,
+    maxLimit,
+    discount
+  );
+}
+
+const index$2 = {
+  __proto__: null,
+  addLiquidity: addLiquidity,
+  buy: buy,
+  createPool: createPool,
+  removeLiquidity: removeLiquidity,
+  sell: sell
+};
+
 function openChannel(api, origin, destination, maxSize, maxMessageSize) {
   return api.tx.sudo.sudo(
     api.tx.parasSudoWrapper.sudoEstablishHrmpChannel(
@@ -3731,4 +3782,309 @@ const index = {
   closeChannel: closeChannel
 };
 
-export { NODE_NAMES, index$3 as assets, index as closeChannels, index$1 as openChannels, index$2 as xcmPallet };
+class AddLiquidityBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new AddLiquidityBuilder(api);
+  }
+  assetA(assetA) {
+    this._assetA = assetA;
+    return this;
+  }
+  assetB(assetB) {
+    this._assetB = assetB;
+    return this;
+  }
+  amountA(amountA) {
+    this._amountA = amountA;
+    return this;
+  }
+  amountBMaxLimit(amountBMaxLimit) {
+    this._amountBMaxLimit = amountBMaxLimit;
+    return this;
+  }
+  build() {
+    return addLiquidity(this.api, this._assetA, this._assetB, this._amountA, this._amountBMaxLimit);
+  }
+}
+const AddLiquidityBuilder$1 = AddLiquidityBuilder;
+
+class BuyBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new BuyBuilder(api);
+  }
+  assetOut(assetOut) {
+    this._assetOut = assetOut;
+    return this;
+  }
+  assetIn(assetIn) {
+    this._assetIn = assetIn;
+    return this;
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  maxLimit(maxLimit) {
+    this._maxLimit = maxLimit;
+    return this;
+  }
+  discount(discount) {
+    this._discount = discount;
+    return this;
+  }
+  build() {
+    return buy(this.api, this._assetOut, this._assetIn, this._amount, this._maxLimit, this._discount);
+  }
+}
+const BuyBuilder$1 = BuyBuilder;
+
+class CloseChannelBuilder {
+  constructor(api, from) {
+    this.api = api;
+    this.from = from;
+  }
+  static create(api, from) {
+    return new CloseChannelBuilder(api, from);
+  }
+  inbound(inbound) {
+    this._inbound = inbound;
+    return this;
+  }
+  outbound(outbound) {
+    this._outbound = outbound;
+    return this;
+  }
+  build() {
+    return closeChannel(this.api, this.from, this._inbound, this._outbound);
+  }
+}
+const CloseChannelBuilder$1 = CloseChannelBuilder;
+
+class CreatePoolBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new CreatePoolBuilder(api);
+  }
+  assetA(assetA) {
+    this._assetA = assetA;
+    return this;
+  }
+  amountA(amountA) {
+    this._amountA = amountA;
+    return this;
+  }
+  assetB(assetB) {
+    this._assetB = assetB;
+    return this;
+  }
+  amountB(amountB) {
+    this._amountB = amountB;
+    return this;
+  }
+  build() {
+    return createPool(this.api, this._assetA, this._amountA, this._assetB, this._amountB);
+  }
+}
+const CreatePoolBuilder$1 = CreatePoolBuilder;
+
+class OpenChannelBuilder {
+  constructor(api, from, to) {
+    this.api = api;
+    this.from = from;
+    this.to = to;
+  }
+  static create(api, from, to) {
+    return new OpenChannelBuilder(api, from, to);
+  }
+  maxSize(size) {
+    this._maxSize = size;
+    return this;
+  }
+  maxMessageSize(size) {
+    this._maxMessageSize = size;
+    return this;
+  }
+  build() {
+    return openChannel(this.api, this.from, this.to, this._maxSize, this._maxMessageSize);
+  }
+}
+const OpenChannelBuilder$1 = OpenChannelBuilder;
+
+class RelayToParaBuilder {
+  constructor(api, to) {
+    this.api = api;
+    this.to = to;
+  }
+  static create(api, to) {
+    return new RelayToParaBuilder(api, to);
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  address(address) {
+    this._address = address;
+    return this;
+  }
+  build() {
+    return transferRelayToPara(this.api, this.to, this._amount, this._address);
+  }
+}
+const RelayToParaBuilder$1 = RelayToParaBuilder;
+
+class RemoveLiquidityBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new RemoveLiquidityBuilder(api);
+  }
+  assetA(assetA) {
+    this._assetA = assetA;
+    return this;
+  }
+  assetB(assetB) {
+    this._assetB = assetB;
+    return this;
+  }
+  liquidityAmount(liquidityAmount) {
+    this._liquidityAmount = liquidityAmount;
+    return this;
+  }
+  build() {
+    return removeLiquidity(this.api, this._assetA, this._assetB, this._liquidityAmount);
+  }
+}
+const RemoveLiquidityBuilder$1 = RemoveLiquidityBuilder;
+
+class SellBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  static create(api) {
+    return new SellBuilder(api);
+  }
+  assetIn(assetIn) {
+    this._assetIn = assetIn;
+    return this;
+  }
+  assetOut(assetOut) {
+    this._assetOut = assetOut;
+    return this;
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  maxLimit(maxLimit) {
+    this._maxLimit = maxLimit;
+    return this;
+  }
+  discount(discount) {
+    this._discount = discount;
+    return this;
+  }
+  build() {
+    return sell(this.api, this._assetIn, this._assetOut, this._amount, this._maxLimit, this._discount);
+  }
+}
+const SellBuilder$1 = SellBuilder;
+
+class SendBuilder {
+  constructor(api, from, to, currency) {
+    this.api = api;
+    this.from = from;
+    this.to = to;
+    this.currency = currency;
+  }
+  static createParaToRelay(api, from, currency) {
+    return new SendBuilder(api, from, void 0, currency);
+  }
+  static createParaToPara(api, from, to, currency) {
+    return new SendBuilder(api, from, to, currency);
+  }
+  currencyId(currencyId) {
+    this._currencyId = currencyId;
+    return this;
+  }
+  amount(amount) {
+    this._amount = amount;
+    return this;
+  }
+  address(address) {
+    this._address = address;
+    return this;
+  }
+  build() {
+    return send(this.api, this.from, this.currency, this._currencyId, this._amount, this._address, this.to);
+  }
+}
+const SendBuilder$1 = SendBuilder;
+
+class ToGeneralBuilder {
+  constructor(api, from, to) {
+    this.api = api;
+    this.from = from;
+    this.to = to;
+  }
+  currency(currency) {
+    return SendBuilder$1.createParaToPara(this.api, this.from, this.to, currency);
+  }
+  openChannel() {
+    return OpenChannelBuilder$1.create(this.api, this.from, this.to);
+  }
+}
+class FromGeneralBuilder {
+  constructor(api, from) {
+    this.api = api;
+    this.from = from;
+  }
+  to(node) {
+    return new ToGeneralBuilder(this.api, this.from, node);
+  }
+  currency(currency) {
+    return SendBuilder$1.createParaToRelay(this.api, this.from, currency);
+  }
+  closeChannel() {
+    return CloseChannelBuilder$1.create(this.api, this.from);
+  }
+}
+class GeneralBuilder {
+  constructor(api) {
+    this.api = api;
+  }
+  from(node) {
+    return new FromGeneralBuilder(this.api, node);
+  }
+  to(node) {
+    return RelayToParaBuilder$1.create(this.api, node);
+  }
+  addLiquidity() {
+    return AddLiquidityBuilder$1.create(this.api);
+  }
+  removeLiquidity() {
+    return RemoveLiquidityBuilder$1.create(this.api);
+  }
+  buy() {
+    return BuyBuilder$1.create(this.api);
+  }
+  sell() {
+    return SellBuilder$1.create(this.api);
+  }
+  createPool() {
+    return CreatePoolBuilder$1.create(this.api);
+  }
+}
+function Builder(api) {
+  return new GeneralBuilder(api);
+}
+
+export { Builder, NODE_NAMES, index$4 as assets, index as closeChannels, index$1 as openChannels, index$3 as xcmPallet, index$2 as xyk };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paraspell/sdk",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "SDK for ParaSpell XCM/XCMP tool for developers",
   "repository": "@paraspell/sdk",
   "license": "MIT",