@indigo-labs/indigo-sdk 0.4.4 → 0.5.1

package/src/contracts/stableswap/transactions.ts

@@ -11,13 +11,11 @@ import {
   sortUTxOs,
   toHex,
   TxBuilder,
-  UTxO,
 } from '@lucid-evolution/lucid';
 import {
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
-import { estimateUtxoMinLovelace } from '../../utils/lucid-utils';
 import {
   parseStableswapOrderDatumOrThrow,
   serialiseStableswapOrderDatum,
@@ -42,34 +40,20 @@ import {
   serialiseStableswapPoolDatum,
   StableswapPoolContent,
 } from '../cdp/types-new';
-import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
 import { array as A, function as F } from 'fp-ts';
 import { isEmpty } from 'fp-ts/lib/Array';
-import { BASE_MAX_EXECUTION_FEE, createDestinationDatum } from './helpers';
+import {
+  BASE_MAX_EXECUTION_FEE,
+  createDestinationDatum,
+  estimateMinOrderOutputLovelaces,
+  PSMProcessingConfig,
+  StableswapInfo,
+  StableswapOrderInfo,
+  summariseOrder,
+} from './helpers';
 import * as Core from '@evolution-sdk/evolution';
 import { treasuryFeeTx } from '../treasury/transactions';
-import {
-  Rational,
-  rationalDiv,
-  rationalFloor,
-  rationalFromInt,
-  rationalMul,
-} from '../../types/rational';
-
-type StableswapInfo = {
-  suppliedCollateralAsset: bigint;
-  suppliedIasset: bigint;
-  owedCollateralAsset: bigint;
-  owedIasset: bigint;
-  mintingFee: bigint;
-  redemptionFee: bigint;
-};
-
-type StableswapOrderInfo = {
-  utxo: UTxO;
-  datum: StableswapOrderDatum;
-  swapInfo: StableswapInfo;
-};
+import { Rational } from '../../types/rational';
 
 export async function createStableswapOrder(
   iasset: string,
@@ -113,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!, {
@@ -140,12 +118,7 @@ export async function createStableswapOrder(
       kind: 'inline',
       value: serialiseStableswapOrderDatum(datum),
     },
-    addAssets(
-      assetsToSwap,
-      mkLovelacesOf(
-        roundedExpectedOutputLovelaces + maxExecutionFee + additionalLovelaces,
-      ),
-    ),
+    addAssets(orderAssetsPlusFees, mkLovelacesOf(expectedMinOutputLovelaces)),
   );
 }
 
@@ -188,6 +161,7 @@ export async function batchProcessStableswapOrders(
   treasuryOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
+  psmProcessingConfig?: PSMProcessingConfig,
 ): Promise<TxBuilder> {
   const stableswapScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -259,169 +233,19 @@ 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 suppliedIasset = assetClassValueOf(orderUtxo.assets, iassetAc);
-      const suppliedCollateralAsset = assetClassValueOf(
-        orderUtxo.assets,
-        collateralAc,
+      const res = summariseOrder(
+        lucid,
+        { utxo: orderUtxo, datum: orderDatum },
+        { utxo: stableswapPoolUtxo, datum: stableswapPoolDatum },
+        sysParams,
+        psmProcessingConfig,
       );
 
-      if (
-        (suppliedIasset != 0n && suppliedCollateralAsset != 0n) ||
-        (suppliedIasset == 0n && suppliedCollateralAsset == 0n)
-      ) {
-        throw new Error(
-          'An order must supply either iAsset or collateral asset',
-        );
+      if (res._tag === 'ERROR') {
+        throw new Error(res.description);
       }
 
-      const isMinting = suppliedCollateralAsset > 0n;
-
-      const isOneToOne =
-        stableswapPoolDatum.collateralToIassetRatio.numerator ===
-        stableswapPoolDatum.collateralToIassetRatio.denominator;
-
-      if (isMinting) {
-        // Mint order with one to one ratio case.
-        if (isOneToOne) {
-          const fee = calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            suppliedCollateralAsset,
-          );
-
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: suppliedCollateralAsset,
-              suppliedIasset: 0n,
-              owedCollateralAsset: 0n,
-              owedIasset: suppliedCollateralAsset - fee,
-              mintingFee: fee,
-              redemptionFee: 0n,
-            },
-          };
-          // Mint order with any ratio case.
-        } else {
-          const iAssetConversion = rationalFloor(
-            rationalDiv(
-              rationalFromInt(suppliedCollateralAsset),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const attemptedNormalizedCollateral = rationalFloor(
-            rationalMul(
-              rationalFromInt(iAssetConversion),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const normalizedCollateralSupplied =
-            rationalFloor(
-              rationalDiv(
-                rationalFromInt(attemptedNormalizedCollateral),
-                stableswapPoolDatum.collateralToIassetRatio,
-              ),
-            ) != iAssetConversion
-              ? suppliedCollateralAsset
-              : attemptedNormalizedCollateral;
-
-          const fee = calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            iAssetConversion,
-          );
-
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: normalizedCollateralSupplied,
-              suppliedIasset: 0n,
-              owedCollateralAsset: 0n,
-              owedIasset: iAssetConversion - fee,
-              mintingFee: fee,
-              redemptionFee: 0n,
-            },
-          };
-        }
-        // Redeem order case
-      } else {
-        const fee = calculateFeeFromRatio(
-          stableswapPoolDatum.redemptionFeeRatio,
-          suppliedIasset,
-        );
-
-        const effectiveSuppliedIasset = suppliedIasset - fee;
-
-        // Redeem order with one to one ratio case
-        if (isOneToOne) {
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: 0n,
-              suppliedIasset: effectiveSuppliedIasset,
-              owedCollateralAsset: effectiveSuppliedIasset,
-              owedIasset: 0n,
-              mintingFee: 0n,
-              redemptionFee: fee,
-            },
-          };
-          // Redeem order with any ratio case
-        } else {
-          const collateralConversion = rationalFloor(
-            rationalMul(
-              rationalFromInt(effectiveSuppliedIasset),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const attemptedNormalizedEffectiveIasset = rationalFloor(
-            rationalDiv(
-              rationalFromInt(collateralConversion),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const normalizedEffectiveIasset =
-            rationalFloor(
-              rationalMul(
-                rationalFromInt(attemptedNormalizedEffectiveIasset),
-                stableswapPoolDatum.collateralToIassetRatio,
-              ),
-            ) != collateralConversion
-              ? effectiveSuppliedIasset
-              : attemptedNormalizedEffectiveIasset;
-
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: 0n,
-              suppliedIasset: normalizedEffectiveIasset,
-              owedCollateralAsset: rationalFloor(
-                rationalMul(
-                  rationalFromInt(effectiveSuppliedIasset),
-                  stableswapPoolDatum.collateralToIassetRatio,
-                ),
-              ),
-              owedIasset: 0n,
-              mintingFee: 0n,
-              redemptionFee: fee,
-            },
-          };
-        }
-      }
+      return res.result;
     },
   );
 
@@ -448,7 +272,7 @@ export async function batchProcessStableswapOrders(
           owedIasset: acc.owedIasset + orderInfo.swapInfo.owedIasset,
           mintingFee: acc.mintingFee + orderInfo.swapInfo.mintingFee,
           redemptionFee: acc.redemptionFee + orderInfo.swapInfo.redemptionFee,
-        };
+        } satisfies StableswapInfo;
       },
     ),
   );
@@ -456,6 +280,15 @@ export async function batchProcessStableswapOrders(
   const collateralAmtChangePool =
     totalSwapInfo.suppliedCollateralAsset - totalSwapInfo.owedCollateralAsset;
 
+  const newPsmPoolValue = addAssets(
+    stableswapPoolUtxo.assets,
+    mkAssetsOf(collateralAc, collateralAmtChangePool),
+  );
+
+  if (assetClassValueOf(newPsmPoolValue, collateralAc) < 0n) {
+    throw new Error('Cannot batch more than liquidity allows');
+  }
+
   const amountToMint =
     totalSwapInfo.owedIasset -
     totalSwapInfo.suppliedIasset +
@@ -486,12 +319,7 @@ export async function batchProcessStableswapOrders(
         kind: 'inline',
         value: serialiseStableswapPoolDatum(stableswapPoolDatum),
       },
-      collateralAmtChangePool != 0n
-        ? addAssets(
-            stableswapPoolUtxo.assets,
-            mkAssetsOf(collateralAc, collateralAmtChangePool),
-          )
-        : stableswapPoolUtxo.assets,
+      newPsmPoolValue,
     )
     // This has to be added as otherwise there is the following error:
     // TxBuilderError: { Complete: RedeemerBuilder: Coin selection had to be updated
@@ -509,8 +337,8 @@ export async function batchProcessStableswapOrders(
     A.reduce<StableswapOrderInfo, TxBuilder>(tx, (acc, orderInfo) => {
       return acc
         .collectFrom(
-          [orderInfo.utxo],
-          isSameOutRef(orderInfo.utxo, mainOrderUtxo)
+          [orderInfo.order.utxo],
+          isSameOutRef(orderInfo.order.utxo, mainOrderUtxo)
             ? serialiseStableswapOrderRedeemer('BatchProcessStableswapOrders')
             : {
                 kind: 'selected',
@@ -522,26 +350,29 @@ export async function batchProcessStableswapOrders(
                     },
                   });
                 },
-                inputs: [orderInfo.utxo, mainOrderUtxo],
+                inputs: [orderInfo.order.utxo, mainOrderUtxo],
               },
         )
         .pay.ToAddressWithData(
-          addressToBech32(orderInfo.datum.destination, lucid.config().network!),
+          addressToBech32(
+            orderInfo.order.datum.destination,
+            lucid.config().network!,
+          ),
           {
             kind: 'inline',
             value: createDestinationDatum(
-              orderInfo.datum.destinationInlineDatum ?? null,
-              orderInfo.utxo,
+              orderInfo.order.datum.destinationInlineDatum ?? null,
+              orderInfo.order.utxo,
             ),
           },
           addAssets(
-            // Currently, we always take the max execution fee from the order utxo.
+            // NOTICE: Currently, we always take the max execution fee from the order utxo.
             // This can be improved so that we take the actual execution fee.
             mkLovelacesOf(
-              lovelacesAmt(orderInfo.utxo.assets) -
-                orderInfo.datum.maxExecutionFee,
+              lovelacesAmt(orderInfo.order.utxo.assets) -
+                orderInfo.order.datum.maxExecutionFee,
             ),
-            orderInfo.swapInfo.owedIasset > 0
+            orderInfo.orderType === 'MINTING'
               ? mkAssetsOf(iassetAc, orderInfo.swapInfo.owedIasset)
               : mkAssetsOf(
                   collateralAc,

package/src/contracts/staking/transactions.ts

@@ -5,7 +5,6 @@ import {
   fromText,
   LucidEvolution,
   OutRef,
-  slotToUnixTime,
   toHex,
   TxBuilder,
 } from '@lucid-evolution/lucid';
@@ -130,11 +129,9 @@ export async function adjustStakingPosition(
   amount: bigint,
   params: SystemParams,
   lucid: LucidEvolution,
-  currentSlot: number,
   stakingManagerRef?: OutRef,
 ): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const now = BigInt(slotToUnixTime(network, currentSlot));
+  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
 
   const stakingPositionOut = await findStakingPositionByOutRef(
     stakingPositionRef,
@@ -210,11 +207,9 @@ export async function closeStakingPosition(
   stakingPositionRef: OutRef,
   params: SystemParams,
   lucid: LucidEvolution,
-  currentSlot: number,
   stakingManagerRef?: OutRef,
 ): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const now = BigInt(slotToUnixTime(network, currentSlot));
+  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
 
   const stakingPositionOut = await findStakingPositionByOutRef(
     stakingPositionRef,

package/tests/cdp/actions.ts

@@ -103,7 +103,6 @@ export async function runOpenCdp(
     orefs.interestOracleUtxo,
     directTreasuryPayment ? undefined : orefs.treasuryUtxo,
     context.lucid,
-    context.emulator.slot,
     pythMessage,
     pythStateOref,
   );
@@ -142,7 +141,6 @@ export async function runDepositCdp(
     orefs.interestCollectorUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
   );
 }
 
@@ -194,7 +192,6 @@ export async function runWithdrawCdp(
     orefs.interestCollectorUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
     pythMessage,
     pythStateOref,
   );
@@ -249,7 +246,6 @@ export async function runMintCdp(
     orefs.interestCollectorUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
     pythMessage,
     pythStateOref,
   );
@@ -288,7 +284,6 @@ export async function runBurnCdp(
     orefs.interestCollectorUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
   );
 }
 
@@ -321,7 +316,6 @@ export async function runCloseCdp(
     orefs.interestCollectorUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
   );
 }
 
@@ -367,7 +361,6 @@ export async function runRedeemCdp(
     orefs.govUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
   );
 }
 
@@ -415,7 +408,6 @@ export async function runFreezeCdp(
     orefs.interestOracleUtxo,
     sysParams,
     context.lucid,
-    context.emulator.slot,
     pythMessage,
     pythStateOref,
   );
@@ -463,7 +455,6 @@ export async function runCreateAndFreezeCdps(
         orefs.interestOracleUtxo,
         orefs.treasuryUtxo,
         context.lucid,
-        context.emulator.slot,
       ),
     );
   });
@@ -475,7 +466,6 @@ export async function runCreateAndFreezeCdps(
       priceOracleUtxo!,
       { numerator: 18n, denominator: 10n }, // 1.8
       assetInfo.collateralAssets[0].oracleParams!,
-      context.emulator.slot,
     ),
   );
 
@@ -515,7 +505,6 @@ export async function runCreateAndFreezeCdps(
           orefs.interestOracleUtxo,
           sysParams,
           context.lucid,
-          context.emulator.slot,
         ),
       );
     }

package/tests/cdp/cdp-helpers.ts

@@ -2,7 +2,7 @@ import { match, P } from 'ts-pattern';
 import { CDPContent } from '../../src/contracts/cdp/types-new';
 import { calculateAccruedInterest } from '../../src/contracts/interest-oracle/helpers';
 import { LucidContext } from '../test-helpers';
-import { slotToUnixTime, toHex, toText } from '@lucid-evolution/lucid';
+import { toHex, toText } from '@lucid-evolution/lucid';
 import { findCollateralAsset } from '../queries/iasset-queries';
 import {
   fromSystemParamsAsset,
@@ -18,7 +18,7 @@ export async function calculateCdpInterest(
   sysParams: SystemParams,
 ): Promise<bigint> {
   const currentTime = BigInt(
-    slotToUnixTime(context.lucid.config().network!, context.emulator.slot),
+    context.lucid.slotToUnixTime(context.lucid.currentSlot()),
   );
 
   const collateralAsset = await findCollateralAsset(

package/tests/cdp/cdp-queries.ts

@@ -385,7 +385,6 @@ export async function findCdpCR(
   lucid: LucidEvolution,
   sysParams: SystemParams,
   cdp: { utxo: UTxO; datum: CDPContent },
-  slot: number,
 ): Promise<number> {
   const iassetAscii = toText(toHex(cdp.datum.iasset));
 
@@ -410,7 +409,7 @@ export async function findCdpCR(
   );
 
   return cdpCollateralRatioPercentage(
-    slot,
+    BigInt(lucid.slotToUnixTime(lucid.currentSlot())),
     adjustedPrice,
     cdp.utxo.assets,
     cdp.datum,
@@ -420,6 +419,5 @@ export async function findCdpCR(
       iassetAscii,
       cdp.datum.collateralAsset,
     ),
-    lucid.config().network!,
   );
 }