Wxdefi 473 pool rework

test/components/lp_stable/_hooks.mjs

@@ -19,16 +19,18 @@ const seedWordsCount = 5;
 const ridePath = '../ride';
 const mockRidePath = 'components/lp_stable/mock';
 const lpStablePath = format({ dir: ridePath, base: 'lp_stable.ride' });
+const lpStableImplPath = format({ dir: ridePath, base: 'lp_stable_impl.ride' });
 const factoryV2Path = format({ dir: ridePath, base: 'factory_v2.ride' });
 const stakingPath = format({ dir: mockRidePath, base: 'staking.mock.ride' });
 const slippagePath = format({ dir: mockRidePath, base: 'slippage.mock.ride' });
 const assetsStorePath = format({ dir: mockRidePath, base: 'assets_store.mock.ride' });
 const gwxRewardPath = format({ dir: mockRidePath, base: 'gwx_reward.mock.ride' });
+const swapPath = format({ dir: mockRidePath, base: 'swap.mock.ride' });
 const restPath = format({ dir: ridePath, base: 'rest.ride' });
 
 export const mochaHooks = {
   async beforeAll() {
-    const names = ['lpStable', 'factoryV2', 'staking', 'slippage', 'gwxReward', 'manager', 'store', 'feeCollector', 'rest', 'user1'];
+    const names = ['lpStable', 'lpStableImpl', 'factoryV2', 'staking', 'slippage', 'gwxReward', 'manager', 'store', 'feeCollector', 'rest', 'swap', 'user1'];
     this.accounts = Object.fromEntries(names.map((item) => [item, randomSeed(seedWordsCount)]));
     const seeds = Object.values(this.accounts);
     const amount = 1e10;
@@ -40,11 +42,13 @@ export const mochaHooks = {
     await waitForTx(massTransferTx.id, { apiBase });
 
     await setScriptFromFile(lpStablePath, this.accounts.lpStable);
+    await setScriptFromFile(lpStableImplPath, this.accounts.lpStableImpl);
     await setScriptFromFile(factoryV2Path, this.accounts.factoryV2);
     await setScriptFromFile(stakingPath, this.accounts.staking);
     await setScriptFromFile(slippagePath, this.accounts.slippage);
     await setScriptFromFile(assetsStorePath, this.accounts.store);
     await setScriptFromFile(gwxRewardPath, this.accounts.gwxReward);
+    await setScriptFromFile(swapPath, this.accounts.swap);
     await setScriptFromFile(restPath, this.accounts.rest);
 
     const usdnIssueTx = issue({
@@ -60,7 +64,7 @@ export const mochaHooks = {
 
     const usdnAmount = 1e16;
     const massTransferTxUSDN = massTransfer({
-      transfers: names.slice(-1).map((name) => ({
+      transfers: names.slice(-2).map((name) => ({
         recipient: address(this.accounts[name], chainId), amount: usdnAmount,
       })),
       assetId: this.usdnAssetId,
@@ -82,7 +86,7 @@ export const mochaHooks = {
 
     const usdtAmount = 1e16;
     const massTransferTxUSDT = massTransfer({
-      transfers: names.slice(-1).map((name) => ({
+      transfers: names.slice(-2).map((name) => ({
         recipient: address(this.accounts[name], chainId), amount: usdtAmount,
       })),
       assetId: this.usdtAssetId,
@@ -242,6 +246,16 @@ export const mochaHooks = {
         key: '%s__managerPublicKey',
         type: 'string',
         value: publicKey(this.accounts.manager),
+      },
+      {
+        key: '%s__lpStableImpl',
+        type: 'string',
+        value: address(this.accounts.lpStableImpl, chainId),
+      },
+      {
+        key: '%s__swapContract',
+        type: 'string',
+        value: address(this.accounts.swap, chainId),
       }],
       chainId,
     }, this.accounts.factoryV2);
@@ -314,10 +328,36 @@ export const mochaHooks = {
         key: '%s__managerPublicKey',
         type: 'string',
         value: publicKey(this.accounts.manager),
+      },
+      {
+        key: '%s__factoryContract',
+        type: 'string',
+        value: address(this.accounts.factoryV2, chainId),
+      }, {
+        key: '%s__refreshDLpDelay',
+        type: 'integer',
+        value: 2,
       }],
       chainId,
     }, this.accounts.lpStable);
     await api.transactions.broadcast(setManagerLpStableTx, {});
     await waitForTx(setManagerLpStableTx.id, { apiBase });
+
+    const setLpStableImplStateTx = data({
+      additionalFee: 4e5,
+      data: [{
+        key: '%s__factoryContract',
+        type: 'string',
+        value: address(this.accounts.factoryV2, chainId),
+      },
+      {
+        key: '%s__swap',
+        type: 'string',
+        value: address(this.accounts.factoryV2, chainId),
+      }],
+      chainId,
+    }, this.accounts.lpStableImpl);
+    await api.transactions.broadcast(setLpStableImplStateTx, {});
+    await waitForTx(setLpStableImplStateTx.id, { apiBase });
   },
 };

test/components/lp_stable/calcPriceBigIntWrapperREADONLY.mjs

@@ -0,0 +1,56 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import { address } from '@waves/ts-lib-crypto';
+import { invokeScript, nodeInteraction as ni } from '@waves/waves-transactions';
+import { create } from '@waves/node-api-js';
+
+chai.use(chaiAsPromised);
+const { expect } = chai;
+
+const apiBase = process.env.API_NODE_URL;
+const chainId = 'R';
+
+const api = create(apiBase);
+
+describe('lp_stable: calcPriceBigIntWrapperREADONLY.mjs', /** @this {MochaSuiteModified} */() => {
+  it(
+    'should successfully calcPriceBigIntWrapperREADONLY',
+    async function () {
+      const usdnAmount = 1e8;
+      const usdtAmount = 1e8;
+      const shouldAutoStake = false;
+
+      const lpStable = address(this.accounts.lpStable, chainId);
+
+      const put = invokeScript({
+        dApp: lpStable,
+        payment: [
+          { assetId: this.usdtAssetId, amount: usdtAmount },
+          { assetId: this.usdnAssetId, amount: usdnAmount },
+        ],
+        call: {
+          function: 'put',
+          args: [
+            { type: 'integer', value: 0 },
+            { type: 'boolean', value: shouldAutoStake },
+          ],
+        },
+        chainId,
+      }, this.accounts.user1);
+      await api.transactions.broadcast(put, {});
+      await ni.waitForTx(put.id, { apiBase });
+
+      const expr1 = `calcPriceBigIntWrapperREADONLY("12345678000", "10000000000")`; /* eslint-disable-line */
+      const response1 = await api.utils.fetchEvaluate(
+        lpStable,
+        expr1,
+      );
+      const evaluateData1 = response1.result.value._2; /* eslint-disable-line */
+
+      expect(evaluateData1).to.eql({
+        type: 'String',
+        value: '1234567800000000000',
+      });
+    },
+  );
+});

test/components/lp_stable/calcPricesWrapperREADONLY.mjs

@@ -0,0 +1,69 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import { address } from '@waves/ts-lib-crypto';
+import { invokeScript, nodeInteraction as ni } from '@waves/waves-transactions';
+import { create } from '@waves/node-api-js';
+
+chai.use(chaiAsPromised);
+const { expect } = chai;
+
+const apiBase = process.env.API_NODE_URL;
+const chainId = 'R';
+
+const api = create(apiBase);
+
+describe('lp_stable: calcPricesWrapperREADONLY.mjs', /** @this {MochaSuiteModified} */() => {
+  it(
+    'should successfully calcPricesWrapperREADONLY',
+    async function () {
+      const usdnAmount = 1e8;
+      const usdtAmount = 1e8;
+      const shouldAutoStake = false;
+
+      const lpStable = address(this.accounts.lpStable, chainId);
+
+      const put = invokeScript({
+        dApp: lpStable,
+        payment: [
+          { assetId: this.usdtAssetId, amount: usdtAmount },
+          { assetId: this.usdnAssetId, amount: usdnAmount },
+        ],
+        call: {
+          function: 'put',
+          args: [
+            { type: 'integer', value: 0 },
+            { type: 'boolean', value: shouldAutoStake },
+          ],
+        },
+        chainId,
+      }, this.accounts.user1);
+      await api.transactions.broadcast(put, {});
+      await ni.waitForTx(put.id, { apiBase });
+
+      const expr1 = `calcPricesWrapperREADONLY(1000000, 1100000, 100000000)`; /* eslint-disable-line */
+      const response1 = await api.utils.fetchEvaluate(
+        lpStable,
+        expr1,
+      );
+      const evaluateData1 = response1.result.value._2; /* eslint-disable-line */
+
+      expect(evaluateData1).to.eql({
+        type: 'Array',
+        value: [
+          {
+            type: 'String',
+            value: '1100000000000000000',
+          },
+          {
+            type: 'String',
+            value: '1000000000000000000',
+          },
+          {
+            type: 'String',
+            value: '1100000000000000000',
+          },
+        ],
+      });
+    },
+  );
+});

test/components/lp_stable/calculateAmountOutForSwapAndSendTokens.mjs

@@ -0,0 +1,87 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { address } from '@waves/ts-lib-crypto';
+import { invokeScript, nodeInteraction as ni } from '@waves/waves-transactions';
+import { create } from '@waves/node-api-js';
+
+chai.use(chaiAsPromised);
+const { expect } = chai;
+
+const apiBase = process.env.API_NODE_URL;
+const chainId = 'R';
+const api = create(apiBase);
+
+describe('lp_stable: calculateAmountOutForSwapAndSendTokens.mjs', /** @this {MochaSuiteModified} */() => {
+  it('should successfully calculateAmountOutForSwapAndSendTokens', async function () {
+    const usdnAmount = 10e8;
+    const usdtAmount = 10e8;
+    const shouldAutoStake = false;
+    const user1Address = address(this.accounts.user1, chainId);
+
+    const expected1 = {
+      address: address(this.accounts.user1, chainId),
+      amount: 29996411,
+      asset: this.usdnAssetId,
+    };
+
+    const lpStable = address(this.accounts.lpStable, chainId);
+    const swapAmount = 30e6;
+    const feePoolAmount = 3e6;
+
+    const put = invokeScript({
+      dApp: lpStable,
+      payment: [
+        { assetId: this.usdtAssetId, amount: usdtAmount },
+        { assetId: this.usdnAssetId, amount: usdnAmount },
+      ],
+      call: {
+        function: 'put',
+        args: [
+          { type: 'integer', value: 0 },
+          { type: 'boolean', value: shouldAutoStake },
+        ],
+      },
+      chainId,
+    }, this.accounts.user1);
+    await api.transactions.broadcast(put, {});
+    await ni.waitForTx(put.id, { apiBase });
+
+    const poolUsdtBalanceBeforeInvoke = (
+      await api.assets.fetchBalanceAddressAssetId(
+        user1Address,
+        this.usdnAssetId,
+      )
+    ).balance;
+
+    const invokeTx = invokeScript({
+      dApp: lpStable,
+      payment: [
+        { assetId: this.usdtAssetId, amount: swapAmount },
+      ],
+      call: {
+        function: 'calculateAmountOutForSwapAndSendTokens',
+        args: [
+          { type: 'integer', value: swapAmount },
+          { type: 'boolean', value: false },
+          { type: 'integer', value: 0 },
+          { type: 'string', value: address(this.accounts.user1, chainId) },
+          { type: 'integer', value: feePoolAmount },
+        ],
+      },
+      chainId,
+    }, this.accounts.swap);
+    await api.transactions.broadcast(invokeTx, {});
+    await ni.waitForTx(invokeTx.id, { apiBase });
+
+    const poolUsdtBalanceAfterInvoke = (
+      await api.assets.fetchBalanceAddressAssetId(
+        user1Address,
+        this.usdnAssetId,
+      )
+    ).balance;
+
+    expect(Number(poolUsdtBalanceAfterInvoke))
+      .to.be.eql(Number(poolUsdtBalanceBeforeInvoke) + expected1.amount);
+  });
+});

test/components/lp_stable/calculateAmountOutForSwapREADONLY.mjs

@@ -0,0 +1,52 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { address } from '@waves/ts-lib-crypto';
+import { invokeScript, nodeInteraction as ni } from '@waves/waves-transactions';
+import { create } from '@waves/node-api-js';
+
+chai.use(chaiAsPromised);
+const { expect } = chai;
+
+const apiBase = process.env.API_NODE_URL;
+const chainId = 'R';
+const api = create(apiBase);
+
+describe('lp_stable: calculateAmountOutForSwapREADONLY.mjs', /** @this {MochaSuiteModified} */() => {
+  it('should successfully calculateAmountOutForSwapREADONLY', async function () {
+    const usdnAmount = 1e8;
+    const usdtAmount = 1e8;
+    const shouldAutoStake = false;
+
+    const expected1 = { type: 'Int', value: 99257041 };
+
+    const lpStable = address(this.accounts.lpStable, chainId);
+    const swapAmount = 123e6;
+    const feePoolAmount = 3e6;
+
+    const put = invokeScript({
+      dApp: lpStable,
+      payment: [
+        { assetId: this.usdtAssetId, amount: usdtAmount },
+        { assetId: this.usdnAssetId, amount: usdnAmount },
+      ],
+      call: {
+        function: 'put',
+        args: [
+          { type: 'integer', value: 0 },
+          { type: 'boolean', value: shouldAutoStake },
+        ],
+      },
+      chainId,
+    }, this.accounts.user1);
+    await api.transactions.broadcast(put, {});
+    await ni.waitForTx(put.id, { apiBase });
+
+    const expr = `calculateAmountOutForSwapREADONLY(${swapAmount}, false, ${feePoolAmount})`; /* eslint-disable-line */
+    const response = await api.utils.fetchEvaluate(lpStable, expr);
+    console.log(response.result);
+    const checkData = response.result.value._2; /* eslint-disable-line */
+
+    expect(checkData).to.eql(expected1); /* eslint-disable-line */
+  });
+});