@indigo-labs/indigo-sdk 0.5.0 → 0.5.2

package/src/contracts/stableswap/transactions.ts

@@ -16,7 +16,6 @@ import {
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
-import { estimateUtxoMinLovelace } from '../../utils/lucid-utils';
 import {
   parseStableswapOrderDatumOrThrow,
   serialiseStableswapOrderDatum,
@@ -46,8 +45,8 @@ import { isEmpty } from 'fp-ts/lib/Array';
 import {
   BASE_MAX_EXECUTION_FEE,
   createDestinationDatum,
-  defaultOrderProcessingConfig,
-  OrderProcessConfig,
+  estimateMinOrderOutputLovelaces,
+  PSMProcessingConfig,
   StableswapInfo,
   StableswapOrderInfo,
   summariseOrder,
@@ -98,23 +97,17 @@ export async function createStableswapOrder(
         amount,
       );
 
-  // This is an approximation of the amount of lovelace that will be needed to pay for the output.
-  const expectedOutputLovelaces = estimateUtxoMinLovelace(
-    lucid.config().protocolParameters!,
-    myAddress,
+  const orderAssetsPlusFees = addAssets(
     assetsToSwap,
-    {
-      kind: 'inline',
-      value: createDestinationDatum(destinationInlineDatum ?? null, {
-        txHash:
-          '0000000000000000000000000000000000000000000000000000000000000000',
-        outputIndex: 0,
-      }),
-    },
+    mkLovelacesOf(maxExecutionFee),
+    mkLovelacesOf(additionalLovelaces),
   );
 
-  const roundedExpectedOutputLovelaces =
-    (expectedOutputLovelaces / 1_000_000n + 1n) * 1_000_000n;
+  const expectedMinOutputLovelaces = estimateMinOrderOutputLovelaces(
+    lucid,
+    datum,
+    orderAssetsPlusFees,
+  );
 
   return lucid.newTx().pay.ToContract(
     credentialToAddress(lucid.config().network!, {
@@ -125,12 +118,7 @@ export async function createStableswapOrder(
       kind: 'inline',
       value: serialiseStableswapOrderDatum(datum),
     },
-    addAssets(
-      assetsToSwap,
-      mkLovelacesOf(
-        roundedExpectedOutputLovelaces + maxExecutionFee + additionalLovelaces,
-      ),
-    ),
+    addAssets(orderAssetsPlusFees, mkLovelacesOf(expectedMinOutputLovelaces)),
   );
 }
 
@@ -173,7 +161,7 @@ export async function batchProcessStableswapOrders(
   treasuryOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
-  orderProcessingConfig: OrderProcessConfig = defaultOrderProcessingConfig,
+  psmProcessingConfig?: PSMProcessingConfig,
 ): Promise<TxBuilder> {
   const stableswapScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -245,25 +233,16 @@ export async function batchProcessStableswapOrders(
         getInlineDatumOrThrow(orderUtxo),
       );
 
-      if (
-        toHex(orderDatum.iasset) != toHex(mainOrderDatum.iasset) ||
-        toHex(orderDatum.collateralAsset.currencySymbol) !=
-          toHex(mainOrderDatum.collateralAsset.currencySymbol) ||
-        toHex(orderDatum.collateralAsset.tokenName) !=
-          toHex(mainOrderDatum.collateralAsset.tokenName)
-      ) {
-        throw new Error('Wrong batch of orders');
-      }
-
       const res = summariseOrder(
+        lucid,
         { utxo: orderUtxo, datum: orderDatum },
         { utxo: stableswapPoolUtxo, datum: stableswapPoolDatum },
         sysParams,
-        orderProcessingConfig,
+        psmProcessingConfig,
       );
 
       if (res._tag === 'ERROR') {
-        throw new Error(res.reason);
+        throw new Error(res.description);
       }
 
       return res.result;

package/tests/cdp/cdp.test.ts

@@ -148,8 +148,7 @@ describe('CDP', () => {
     context.lucid = await Lucid(context.emulator, 'Custom');
   });
 
-  // eslint-disable-next-line vitest/no-focused-tests
-  test.only<MyContext>('Open CDP; ADA collateral', async (context: MyContext) => {
+  test<MyContext>('Open CDP; ADA collateral', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
     const [sysParams, [iusdAssetInfo]] = await init(context.lucid, [

package/tests/indigo-test-helpers.ts

@@ -17,7 +17,7 @@ import {
 } from '@3rd-eye-labs/cardano-offchain-common';
 import { IndigoTestContext } from './test-helpers';
 import { init } from './endpoints/initialize';
-import { iusdInitialAssetCfg } from './mock/assets-mock';
+import { ieurInitialAssetCfg, iusdInitialAssetCfg } from './mock/assets-mock';
 
 export const MAINNET_PROTOCOL_PARAMETERS: ProtocolParameters = {
   ...PROTOCOL_PARAMETERS_DEFAULT,
@@ -81,7 +81,7 @@ export async function createIndigoTestContext(
 
   const [systemParams, assetConfigs] = await init(
     context.lucid,
-    [iusdInitialAssetCfg()],
+    [iusdInitialAssetCfg(), ieurInitialAssetCfg()],
     () => [],
     {
       foundationMultisig: {

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

@@ -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,6 +37,7 @@ import {
   findStableswapPool,
 } from '../cdp/cdp-queries';
 import {
+  findAllStableswapOrders,
   findSingleStableswapOrder,
   findStableswapOrders,
 } from './stableswap-queries';
@@ -422,10 +424,16 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
     context.assetConfigs[0],
     adaAssetClass,
   );
+  await refreshPriceOracle(
+    context,
+    context.systemParams,
+    context.assetConfigs[1],
+    adaAssetClass,
+  );
 
   context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
-  // Add some iAssets to wallet
+  // Add some IUSD to wallet
   await runAndAwaitTx(
     context.lucid,
     runOpenCdp(
@@ -438,6 +446,19 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
     ),
   );
 
+  // 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,
@@ -452,6 +473,50 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
     ),
   );
 
+  // 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,
@@ -516,6 +581,33 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
     ),
   );
 
+  // 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,
@@ -552,11 +644,27 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
     ),
   );
 
-  const stableswapOrders = await findStableswapOrders(
+  // 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,
-    fromText(context.assetConfigs[0].iassetTokenNameAscii),
-    EXAMPLE_TOKEN_1,
   );
 
   await createUtxoAtTreasury(
@@ -571,10 +679,10 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
   );
 
   const satisfiableOrders = pickValidSatisfiableOrders(
+    context.lucid,
     stableswapOrders,
     stableswapPool,
     context.systemParams,
-    { ignoreMaxExecutionFeeConstraint: false },
   );
 
   expect(satisfiableOrders.length, 'Only 2 orders are satisfiable').toEqual(2);
@@ -594,11 +702,9 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
   // Checks after last transaction //
   ///////////////////////////////////
 
-  const remainingOrders = await findStableswapOrders(
+  const remainingOrders = await findAllStableswapOrders(
     context.lucid,
     context.systemParams.validatorHashes.stableswapHash,
-    fromText(context.assetConfigs[0].iassetTokenNameAscii),
-    EXAMPLE_TOKEN_1,
   );
 
   expect(
@@ -606,11 +712,17 @@ test<IndigoTestContext>('Stableswap - pickValidSatisfiableOrders', async (contex
     'Expected different orders to not be processed',
   ).toEqual(
     expect.arrayContaining([
+      mintOtherIassetTx,
+      mintOtherCollateralTx,
+      redeemOtherIassetTx,
+      redeemOtherCollateralTx,
       redeemOrderMaxFeeTx,
       redeemOrderTx0,
       mintOrderMaxFeeTx,
       mintOrderMaxExecFeeTx,
       redemptionOrderMaxExecFeeTx,
+      redemptionOrderMinLovelacesTx,
+      mintOrderMinLovelacesTx,
     ]),
   );
 });