@indigo-labs/indigo-sdk 0.4.4 → 0.5.1

package/tests/stableswap/stableswap-queries.ts

@@ -52,33 +52,21 @@ export async function findSingleStableswapOrder(
   );
 }
 
-export async function findStableswapOrders(
+export async function findAllStableswapOrders(
   lucid: LucidEvolution,
   stableswapScriptHash: ScriptHash,
-  iassetName: string,
-  collateralAsset: AssetClass,
 ): Promise<{ utxo: UTxO; datum: StableswapOrderDatum }[]> {
-  const cdpUtxos = await lucid.utxosAt(
+  const psmUtxos = await lucid.utxosAt(
     createScriptAddress(lucid.config().network!, stableswapScriptHash),
   );
 
   const orders = F.pipe(
-    cdpUtxos.map((utxo) =>
+    psmUtxos.map((utxo) =>
       F.pipe(
         O.fromNullable(utxo.datum),
         O.flatMap(parseStableswapOrderDatum),
-        O.flatMap((datum) => {
-          if (
-            toHex(datum.iasset) === iassetName &&
-            toHex(datum.collateralAsset.currencySymbol) ===
-              toHex(collateralAsset.currencySymbol) &&
-            toHex(datum.collateralAsset.tokenName) ===
-              toHex(collateralAsset.tokenName)
-          ) {
-            return O.some({ utxo, datum: datum });
-          } else {
-            return O.none;
-          }
+        O.map((datum) => {
+          return { utxo, datum: datum };
         }),
       ),
     ),
@@ -87,3 +75,24 @@ export async function findStableswapOrders(
 
   return orders;
 }
+
+export async function findStableswapOrders(
+  lucid: LucidEvolution,
+  stableswapScriptHash: ScriptHash,
+  iassetName: string,
+  collateralAsset: AssetClass,
+): Promise<{ utxo: UTxO; datum: StableswapOrderDatum }[]> {
+  const allPsmOrders = await findAllStableswapOrders(
+    lucid,
+    stableswapScriptHash,
+  );
+
+  return allPsmOrders.filter(
+    (order) =>
+      toHex(order.datum.iasset) === iassetName &&
+      toHex(order.datum.collateralAsset.currencySymbol) ===
+        toHex(collateralAsset.currencySymbol) &&
+      toHex(order.datum.collateralAsset.tokenName) ===
+        toHex(collateralAsset.tokenName),
+  );
+}

package/tests/stableswap/stableswap.test.ts

@@ -1,4 +1,4 @@
-import { assert, beforeEach, test } from 'vitest';
+import { assert, beforeEach, expect, test } from 'vitest';
 import {
   IndigoTestContext,
   repeat,
@@ -8,6 +8,7 @@ import {
 import {
   createIndigoTestContext,
   EXAMPLE_TOKEN_1,
+  EXAMPLE_TOKEN_2,
 } from '../indigo-test-helpers';
 import { benchmarkAndAwaitTx } from '../utils/benchmark-utils';
 import {
@@ -36,11 +37,13 @@ import {
   findStableswapPool,
 } from '../cdp/cdp-queries';
 import {
+  findAllStableswapOrders,
   findSingleStableswapOrder,
   findStableswapOrders,
 } from './stableswap-queries';
 import { feedPriceOracleTx } from '../../src/contracts/price-oracle/transactions';
 import {
+  adaAssetClass,
   addressFromBech32,
   assetClassValueOf,
   lovelacesAmt,
@@ -53,7 +56,10 @@ import { array as A } from 'fp-ts';
 import { runOpenCdp } from '../cdp/actions';
 import { Data } from '@evolution-sdk/evolution';
 import { serialiseStableswapOrderDatum } from '../../src/contracts/stableswap/types-new';
-import { BASE_MAX_EXECUTION_FEE } from '../../src/contracts/stableswap/helpers';
+import {
+  BASE_MAX_EXECUTION_FEE,
+  pickValidSatisfiableOrders,
+} from '../../src/contracts/stableswap/helpers';
 import { StableswapPoolContent } from '../../src/contracts/cdp/types-new';
 import { mutatedBatchProcessStableswapOrders } from './transactions-mutated';
 import { expectScriptFailure } from '../utils/asserts';
@@ -63,6 +69,7 @@ import {
 } from '../../src/contracts/treasury/queries';
 import { createUtxoAtTreasury } from '../endpoints/treasury';
 import { rationalFromInt, rationalZero } from '../../src/types/rational';
+import { refreshPriceOracle } from '../price-oracle/actions';
 
 beforeEach<IndigoTestContext>(async (context: IndigoTestContext) => {
   await createIndigoTestContext(context);
@@ -391,6 +398,335 @@ test<IndigoTestContext>('Stableswap - Batch a single order to mint with no minti
   );
 });
 
+test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    rationalFromInt(1n),
+    { numerator: 5n, denominator: 1000n },
+    { numerator: 5n, denominator: 1000n },
+  );
+
+  const stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await refreshPriceOracle(
+    context,
+    context.systemParams,
+    context.assetConfigs[0],
+    adaAssetClass,
+  );
+  await refreshPriceOracle(
+    context,
+    context.systemParams,
+    context.assetConfigs[1],
+    adaAssetClass,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  // Add some IUSD to wallet
+  await runAndAwaitTx(
+    context.lucid,
+    runOpenCdp(
+      context,
+      context.systemParams,
+      context.assetConfigs[0].iassetTokenNameAscii,
+      adaAssetClass,
+      100_000_000n,
+      50_000_000n,
+    ),
+  );
+
+  // iEUR
+  await runAndAwaitTx(
+    context.lucid,
+    runOpenCdp(
+      context,
+      context.systemParams,
+      context.assetConfigs[1].iassetTokenNameAscii,
+      adaAssetClass,
+      100_000_000n,
+      50_000_000n,
+    ),
+  );
+
+  // mint order
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // mint order, can't process because not enough lovelaces
+  const mintOrderMinLovelacesTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      await context.lucid.wallet().address(),
+      undefined,
+      BASE_MAX_EXECUTION_FEE,
+      -200_000n,
+    ),
+  );
+
+  const mintOtherCollateralTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_2,
+      1_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const mintOtherIassetTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      'IBTC',
+      EXAMPLE_TOKEN_1,
+      1_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // mint order, can't process because max exec fee is low
+  const mintOrderMaxExecFeeTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      3_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      await context.lucid.wallet().address(),
+      undefined,
+      1n,
+    ),
+  );
+
+  // mint order, this one shouldn't be processed because of maxFeeRatio
+  const mintOrderMaxFeeTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      await context.lucid.wallet().address(),
+      undefined,
+      BASE_MAX_EXECUTION_FEE,
+      0n,
+      rationalZero,
+    ),
+  );
+
+  // Redemption order, this can't be processed because of lack of liquidity
+  const redeemOrderTx0 = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      20_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redemption order
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redemption order
+  const redeemOtherCollateralTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_2,
+      1_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const redeemOtherIassetTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[1].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      1_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redemption order, can't be satisfied because of maxFeeRatio
+  const redeemOrderMaxFeeTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      1_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      await context.lucid.wallet().address(),
+      undefined,
+      BASE_MAX_EXECUTION_FEE,
+      0n,
+      rationalZero,
+    ),
+  );
+
+  // redemption order, can't process because max exec fee is low
+  const redemptionOrderMaxExecFeeTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      1_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      await context.lucid.wallet().address(),
+      undefined,
+      1n,
+    ),
+  );
+
+  // redemption order, can't process because not enough lovelaces
+  const redemptionOrderMinLovelacesTx = await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      await context.lucid.wallet().address(),
+      undefined,
+      BASE_MAX_EXECUTION_FEE,
+      -500_000n,
+    ),
+  );
+
+  const stableswapOrders = await findAllStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const satisfiableOrders = pickValidSatisfiableOrders(
+    context.lucid,
+    stableswapOrders,
+    stableswapPool,
+    context.systemParams,
+  );
+
+  expect(satisfiableOrders.length, 'Only 2 orders are satisfiable').toEqual(2);
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      satisfiableOrders.map((o) => o.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  const remainingOrders = await findAllStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+  );
+
+  expect(
+    remainingOrders.map((o) => o.utxo.txHash),
+    'Expected different orders to not be processed',
+  ).toEqual(
+    expect.arrayContaining([
+      mintOtherIassetTx,
+      mintOtherCollateralTx,
+      redeemOtherIassetTx,
+      redeemOtherCollateralTx,
+      redeemOrderMaxFeeTx,
+      redeemOrderTx0,
+      mintOrderMaxFeeTx,
+      mintOrderMaxExecFeeTx,
+      redemptionOrderMaxExecFeeTx,
+      redemptionOrderMinLovelacesTx,
+      mintOrderMinLovelacesTx,
+    ]),
+  );
+});
+
 test<IndigoTestContext>('Stableswap - Batch a single order to mint with collateral asset in the pool', async (context: IndigoTestContext) => {
   context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
@@ -989,7 +1325,6 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem emptying th
       priceOracleUtxo!,
       rationalFromInt(1n),
       context.assetConfigs[0].collateralAssets[0].oracleParams!,
-      context.emulator.slot,
     ),
   );
 
@@ -3549,7 +3884,6 @@ test<IndigoTestContext>('Stableswap - Batch an order to mint with an order to re
       priceOracleUtxo!,
       rationalFromInt(1n),
       context.assetConfigs[0].collateralAssets[0].oracleParams!,
-      context.emulator.slot,
     ),
   );
 

package/tests/staking.test.ts

@@ -67,7 +67,6 @@ test<IndigoTestContext>('Staking - Adjust Position', async ({
       1_000_000n,
       systemParams,
       lucid,
-      emulator.slot,
     ),
     lucid,
     emulator,
@@ -106,12 +105,7 @@ test.todo<IndigoTestContext>(
 
     await benchmarkAndAwaitTx(
       'Staking - Close Position',
-      await closeStakingPosition(
-        myStakingPosition.utxo,
-        systemParams,
-        lucid,
-        emulator.slot,
-      ),
+      await closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
       lucid,
       emulator,
     );
@@ -170,12 +164,7 @@ test<IndigoTestContext>('Staking - Distribute ADA to Stakers', async ({
     () =>
       runAndAwaitTx(
         lucid,
-        closeStakingPosition(
-          myStakingPosition.utxo,
-          systemParams,
-          lucid,
-          emulator.slot,
-        ),
+        closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
       ),
   );
 

package/tests/treasury/treasury.test.ts

@@ -161,11 +161,7 @@ describe('Treasury', () => {
   });
 
   test<MyContext>('Merge (3 lovelace UTxOs)', async (context: MyContext) => {
-    const [sysParams, __] = await init(
-      context.lucid,
-      [iusdInitialAssetCfg()],
-      context.emulator.slot,
-    );
+    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
@@ -182,11 +178,7 @@ describe('Treasury', () => {
   });
 
   test<MyContext>('Merge (3 INDY UTxOs)', async (context: MyContext) => {
-    const [sysParams, __] = await init(
-      context.lucid,
-      [iusdInitialAssetCfg()],
-      context.emulator.slot,
-    );
+    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
@@ -212,11 +204,7 @@ describe('Treasury', () => {
   });
 
   test<MyContext>('Merge (fail, 1 lovelace, 2 INDY UTxOs)', async (context: MyContext) => {
-    const [sysParams, __] = await init(
-      context.lucid,
-      [iusdInitialAssetCfg()],
-      context.emulator.slot,
-    );
+    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
@@ -237,11 +225,7 @@ describe('Treasury', () => {
   });
 
   test<MyContext>('Split (12 assets)', async (context: MyContext) => {
-    const [sysParams, __] = await init(
-      context.lucid,
-      [iusdInitialAssetCfg()],
-      context.emulator.slot,
-    );
+    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
@@ -271,11 +255,7 @@ describe('Treasury', () => {
   });
 
   test<MyContext>('Split (fail, lovelace only)', async (context: MyContext) => {
-    const [sysParams, __] = await init(
-      context.lucid,
-      [iusdInitialAssetCfg()],
-      context.emulator.slot,
-    );
+    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
@@ -286,11 +266,7 @@ describe('Treasury', () => {
   });
 
   test<MyContext>('Collect non-positive amount or negative extra lovelaces fails', async (context: MyContext) => {
-    const [sysParams, __] = await init(
-      context.lucid,
-      [iusdInitialAssetCfg()],
-      context.emulator.slot,
-    );
+    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);