@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/stableswap/transactions-mutated.ts

@@ -0,0 +1,348 @@
+import {
+  addAssets,
+  Data,
+  fromHex,
+  LucidEvolution,
+  OutRef,
+  sortUTxOs,
+  toHex,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  parseStableswapOrderDatumOrThrow,
+  serialiseStableswapOrderRedeemer,
+  StableswapOrderDatum,
+} from '../../src/contracts/stableswap/types-new';
+import {
+  fromSystemParamsScriptRef,
+  SystemParams,
+  treasuryFeeTx,
+} from '../../src';
+import {
+  addressToBech32,
+  assetClassToUnit,
+  getInlineDatumOrThrow,
+  lovelacesAmt,
+  matchSingle,
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { isEmpty } from 'fp-ts/lib/Array';
+import { array as A, function as F } from 'fp-ts';
+import { calculateFeeFromRatio } from '../../src/utils/indigo-helpers';
+import {
+  parseStableswapPoolDatumOrThrow,
+  serialiseCdpRedeemer,
+  serialiseStableswapPoolDatum,
+} from '../../src/contracts/cdp/types-new';
+import { createDestinationDatum } from '../../src/contracts/stableswap/helpers';
+import {
+  rationalDiv,
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+} from '../../src/types/rational';
+
+type StableswapOrderInfo = {
+  utxo: UTxO;
+  datum: StableswapOrderDatum;
+  suppliedIasset: bigint;
+  suppliedCollateralAsset: bigint;
+};
+export type MutatedBatchProcessStableswapOrdersType = {
+  type: 'exceed-max-execution-fee';
+  maxExecutionFee: bigint;
+};
+export async function mutatedBatchProcessStableswapOrders(
+  stableswapOrderOrefs: OutRef[],
+  stableswapPoolOref: OutRef,
+  treasuryOref: OutRef,
+  sysParams: SystemParams,
+  lucid: LucidEvolution,
+  type: MutatedBatchProcessStableswapOrdersType,
+): Promise<TxBuilder> {
+  const stableswapScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stableswapValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single Stableswap Ref Script UTXO'),
+  );
+
+  const cdpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
+    ]),
+    (_) => new Error('Expected a single CDP Ref Script UTXO'),
+  );
+
+  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.iAssetTokenPolicyRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
+  );
+
+  if (isEmpty(stableswapOrderOrefs)) {
+    throw new Error('At least one order must be provided.');
+  }
+
+  const stableswapOrderUtxos = await lucid.utxosByOutRef(stableswapOrderOrefs);
+
+  const sortedStableswapOrderUtxos = sortUTxOs(
+    stableswapOrderUtxos,
+    'Canonical',
+  );
+
+  if (sortedStableswapOrderUtxos.length !== stableswapOrderOrefs.length) {
+    throw new Error('Expected certain number of orders');
+  }
+
+  const mainOrderUtxo = sortedStableswapOrderUtxos[0];
+
+  const mainOrderDatum = parseStableswapOrderDatumOrThrow(
+    getInlineDatumOrThrow(mainOrderUtxo),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      sysParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: mainOrderDatum.iasset,
+  };
+
+  const collateralAc = mainOrderDatum.collateralAsset;
+
+  const ordersInfo: StableswapOrderInfo[] = sortedStableswapOrderUtxos.map(
+    (orderUtxo) => {
+      const orderDatum = parseStableswapOrderDatumOrThrow(
+        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 = orderUtxo.assets[assetClassToUnit(iassetAc)] ?? 0n;
+      const suppliedCollateralAsset =
+        orderUtxo.assets[assetClassToUnit(collateralAc)] ?? 0n;
+
+      if (
+        (suppliedIasset != 0n && suppliedCollateralAsset != 0n) ||
+        (suppliedIasset == 0n && suppliedCollateralAsset == 0n)
+      ) {
+        throw new Error(
+          'An order must supply either iAsset or collateral asset',
+        );
+      }
+
+      return {
+        utxo: orderUtxo,
+        datum: orderDatum,
+        suppliedIasset: suppliedIasset,
+        suppliedCollateralAsset: suppliedCollateralAsset,
+      };
+    },
+  );
+
+  const totalSuppliedAssets = F.pipe(
+    ordersInfo,
+    A.reduce<StableswapOrderInfo, [bigint, bigint]>(
+      [0n, 0n],
+      (acc, orderInfo) => [
+        acc[0] + orderInfo.suppliedIasset,
+        acc[1] + orderInfo.suppliedCollateralAsset,
+      ],
+    ),
+  );
+
+  const totalSuppliedIasset = totalSuppliedAssets[0];
+
+  const totalSuppliedCollateralAsset = totalSuppliedAssets[1];
+
+  const stableswapPoolUtxo = matchSingle(
+    await lucid.utxosByOutRef([stableswapPoolOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
+  );
+
+  const stableswapPoolDatum = parseStableswapPoolDatumOrThrow(
+    getInlineDatumOrThrow(stableswapPoolUtxo),
+  );
+
+  const redemptionFee = calculateFeeFromRatio(
+    stableswapPoolDatum.redemptionFeeRatio,
+    totalSuppliedIasset,
+  );
+
+  const totalEffectiveSuppliedIasset = totalSuppliedIasset - redemptionFee;
+
+  const collateralAmtChangePool =
+    totalSuppliedCollateralAsset -
+    rationalFloor(
+      rationalMul(
+        rationalFromInt(totalEffectiveSuppliedIasset),
+        stableswapPoolDatum.collateralToIassetRatio,
+      ),
+    );
+
+  const amountToMint =
+    rationalFloor(
+      rationalDiv(
+        rationalFromInt(totalSuppliedCollateralAsset),
+        stableswapPoolDatum.collateralToIassetRatio,
+      ),
+    ) - totalEffectiveSuppliedIasset;
+
+  const mintingFee = calculateFeeFromRatio(
+    stableswapPoolDatum.mintingFeeRatio,
+    amountToMint,
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([
+      stableswapScriptRefUtxo,
+      cdpScriptRefUtxo,
+      iAssetTokenPolicyRefScriptUtxo,
+    ])
+    .collectFrom([stableswapPoolUtxo], {
+      kind: 'selected',
+      makeRedeemer: (inputIndices) =>
+        serialiseCdpRedeemer({
+          Stableswap: {
+            forwardingInputIndex: inputIndices[0],
+          },
+        }),
+      inputs: [mainOrderUtxo],
+    })
+    .pay.ToContract(
+      stableswapPoolUtxo.address,
+      {
+        kind: 'inline',
+        value: serialiseStableswapPoolDatum(stableswapPoolDatum),
+      },
+      collateralAmtChangePool != 0n
+        ? addAssets(
+            stableswapPoolUtxo.assets,
+            mkAssetsOf(collateralAc, collateralAmtChangePool),
+          )
+        : stableswapPoolUtxo.assets,
+    );
+
+  const fee = mintingFee + redemptionFee;
+
+  if (fee > 0) {
+    await treasuryFeeTx(
+      iassetAc,
+      fee,
+      0n,
+      lucid,
+      sysParams,
+      tx,
+      stableswapPoolOref,
+      treasuryOref,
+    );
+  }
+
+  if (amountToMint != 0n) {
+    tx.mintAssets(mkAssetsOf(iassetAc, amountToMint), Data.void());
+  }
+
+  F.pipe(
+    ordersInfo,
+    A.reduce<StableswapOrderInfo, TxBuilder>(tx, (acc, orderInfo) => {
+      const iassetSupplied =
+        orderInfo.utxo.assets[assetClassToUnit(iassetAc)] ?? 0n;
+
+      const collateralAssetSupplied =
+        orderInfo.utxo.assets[assetClassToUnit(collateralAc)] ?? 0n;
+
+      const isMinting = iassetSupplied > 0n ? false : true;
+
+      const iAssetEquivalentSupplied = isMinting
+        ? rationalFloor(
+            rationalDiv(
+              rationalFromInt(collateralAssetSupplied),
+              stableswapPoolDatum.collateralToIassetRatio,
+            ),
+          )
+        : iassetSupplied;
+
+      const effectiveiAssetEquivalentSupplied = isMinting
+        ? iAssetEquivalentSupplied -
+          calculateFeeFromRatio(
+            stableswapPoolDatum.mintingFeeRatio,
+            iAssetEquivalentSupplied,
+          )
+        : iAssetEquivalentSupplied -
+          calculateFeeFromRatio(
+            stableswapPoolDatum.redemptionFeeRatio,
+            iAssetEquivalentSupplied,
+          );
+
+      const amountToReceive = isMinting
+        ? effectiveiAssetEquivalentSupplied
+        : rationalFloor(
+            rationalMul(
+              rationalFromInt(effectiveiAssetEquivalentSupplied),
+              stableswapPoolDatum.collateralToIassetRatio,
+            ),
+          );
+
+      const maxExecutionFee =
+        type.type === 'exceed-max-execution-fee'
+          ? type.maxExecutionFee
+          : orderInfo.datum.maxExecutionFee;
+
+      return acc
+        .collectFrom(
+          [orderInfo.utxo],
+          orderInfo.utxo == mainOrderUtxo
+            ? serialiseStableswapOrderRedeemer('BatchProcessStableswapOrders')
+            : {
+                kind: 'selected',
+                makeRedeemer: (inputIndices: bigint[]) => {
+                  return serialiseStableswapOrderRedeemer({
+                    BatchAuxiliary: {
+                      ownInputIndex: inputIndices[0],
+                      mainOrderInputIndex: inputIndices[1],
+                    },
+                  });
+                },
+                inputs: [orderInfo.utxo, mainOrderUtxo],
+              },
+        )
+        .pay.ToAddressWithData(
+          addressToBech32(orderInfo.datum.destination, lucid.config().network!),
+          {
+            kind: 'inline',
+            value: createDestinationDatum(
+              orderInfo.datum.destinationInlineDatum ?? null,
+              orderInfo.utxo,
+            ),
+          },
+          addAssets(
+            // 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) - maxExecutionFee,
+            ),
+            isMinting
+              ? mkAssetsOf(iassetAc, amountToReceive)
+              : mkAssetsOf(collateralAc, amountToReceive),
+          ),
+        );
+    }),
+  );
+  return tx;
+}

package/tests/staking.test.ts

@@ -1,73 +1,55 @@
 import { beforeEach, expect, test } from 'vitest';
-import { LucidContext, runAndAwaitTx } from './test-helpers';
-import { EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
-import { Emulator } from '@lucid-evolution/lucid';
-import { generateEmulatorAccount } from '@lucid-evolution/lucid';
-import { init } from '../src/contracts/initialize/transactions';
+import { IndigoTestContext, runAndAwaitTx } from './test-helpers';
 import { addrDetails } from '../src/utils/lucid-utils';
 import { findStakingPosition } from './queries/staking-queries';
-import { iusdInitialAssetCfg } from './mock/assets-mock';
 import {
   adjustStakingPosition,
   closeStakingPosition,
   distributeAda,
   openStakingPosition,
 } from '../src/contracts/staking/transactions';
-import { collectorFeeTx, fromSystemParamsAsset } from '../src';
+import {
+  collectorFeeTx,
+  findStakingManager,
+  fromSystemParamsAsset,
+} from '../src';
+import { createIndigoTestContext } from './indigo-test-helpers';
+import { benchmarkAndAwaitTx } from './utils/benchmark-utils';
 import {
   findAllCollectors,
   findRandomCollector,
 } from './queries/collector-queries';
-import { findStakingManager } from '../src/contracts/staking/helpers';
-import { getValueChangeAtAddressAfterAction } from './utils';
-import { lovelacesAmt } from '@3rd-eye-labs/cardano-offchain-common';
-
-type MyContext = LucidContext<{
-  admin: EmulatorAccount;
-}>;
-
-beforeEach<MyContext>(async (context: MyContext) => {
-  context.users = {
-    admin: generateEmulatorAccount({
-      lovelace: BigInt(100_000_000_000_000),
-    }),
-  };
-
-  context.emulator = new Emulator([context.users.admin]);
+import { getValueChangeAtAddressAfterAction, sendValueTo } from './utils';
+import {
+  lovelacesAmt,
+  mkAssetsOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
 
-  context.lucid = await Lucid(context.emulator, 'Custom');
+beforeEach<IndigoTestContext>(async (context: IndigoTestContext) => {
+  await createIndigoTestContext(context);
 });
 
-test<MyContext>('Staking - Create Position', async ({
+test<IndigoTestContext>('Staking - Create Position', async ({
   lucid,
-  users,
-}: MyContext) => {
-  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
-  const stakingManager = await findStakingManager(systemParams, lucid);
-
-  await runAndAwaitTx(
+  emulator,
+  systemParams,
+}: IndigoTestContext) => {
+  await benchmarkAndAwaitTx(
+    'Staking - Create Position',
+    await openStakingPosition(1_000_000n, systemParams, lucid),
     lucid,
-    openStakingPosition(1_000_000n, systemParams, lucid, stakingManager.utxo),
+    emulator,
   );
 });
 
-test<MyContext>('Staking - Adjust Position', async ({
+test<IndigoTestContext>('Staking - Adjust Position', async ({
   lucid,
-  users,
   emulator,
-}: MyContext) => {
-  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
-
+  systemParams,
+}: IndigoTestContext) => {
   await runAndAwaitTx(
     lucid,
-    openStakingPosition(
-      1_000_000n,
-      systemParams,
-      lucid,
-      (await findStakingManager(systemParams, lucid)).utxo,
-    ),
+    openStakingPosition(1_000_000n, systemParams, lucid),
   );
 
   const [pkh, __] = await addrDetails(lucid);
@@ -78,73 +60,73 @@ test<MyContext>('Staking - Adjust Position', async ({
     pkh.hash,
   );
 
-  await runAndAwaitTx(
-    lucid,
-    adjustStakingPosition(
+  await benchmarkAndAwaitTx(
+    'Staking - Adjust Position',
+    await adjustStakingPosition(
       myStakingPosition.utxo,
       1_000_000n,
       systemParams,
       lucid,
       emulator.slot,
-      (await findStakingManager(systemParams, lucid)).utxo,
     ),
+    lucid,
+    emulator,
   );
 });
 
-test<MyContext>('Staking - Close Position', async ({
-  lucid,
-  users,
-  emulator,
-}: MyContext) => {
-  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
-
-  await runAndAwaitTx(
-    lucid,
-    openStakingPosition(
-      1_000_000n,
-      systemParams,
+// TODO: fails with the Lucid Evolution error: `Error: Not enough ADA leftover to include non-ADA assets in a change address`
+test.todo<IndigoTestContext>(
+  'Staking - Close Position',
+  async ({ lucid, emulator, systemParams, users }: IndigoTestContext) => {
+    lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+    await sendValueTo(
+      users.user2.address,
+      mkAssetsOf(
+        fromSystemParamsAsset(systemParams.govParams.indyAsset),
+        1_000_000n,
+      ),
       lucid,
-      (await findStakingManager(systemParams, lucid)).utxo,
-    ),
-  );
+    );
 
-  const [pkh, __] = await addrDetails(lucid);
-  const myStakingPosition = await findStakingPosition(
-    lucid,
-    systemParams.validatorHashes.stakingHash,
-    fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
-    pkh.hash,
-  );
+    lucid.selectWallet.fromSeed(users.user2.seedPhrase);
 
-  await runAndAwaitTx(
-    lucid,
-    closeStakingPosition(
-      myStakingPosition.utxo,
-      systemParams,
+    await runAndAwaitTx(
       lucid,
-      emulator.slot,
-      (await findStakingManager(systemParams, lucid)).utxo,
-    ),
-  );
-});
+      openStakingPosition(1_000_000n, systemParams, lucid),
+    );
+
+    const [pkh, __] = await addrDetails(lucid);
+    const myStakingPosition = await findStakingPosition(
+      lucid,
+      systemParams.validatorHashes.stakingHash,
+      fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
+      pkh.hash,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Staking - Close Position',
+      await closeStakingPosition(
+        myStakingPosition.utxo,
+        systemParams,
+        lucid,
+        emulator.slot,
+      ),
+      lucid,
+      emulator,
+    );
+  },
+);
 
-test<MyContext>('Staking - Distribute ADA to Stakers', async ({
+test<IndigoTestContext>('Staking - Distribute ADA to Stakers', async ({
   lucid,
   users,
   emulator,
-}: MyContext) => {
-  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
-
+  systemParams,
+}: IndigoTestContext) => {
   await runAndAwaitTx(
     lucid,
-    openStakingPosition(
-      1_000_000n,
-      systemParams,
-      lucid,
-      (await findStakingManager(systemParams, lucid)).utxo,
-    ),
+    openStakingPosition(1_000_000n, systemParams, lucid),
   );
 
   const collectorOref = await findRandomCollector(
@@ -157,19 +139,21 @@ test<MyContext>('Staking - Distribute ADA to Stakers', async ({
 
   const collectorUtxo = (
     await findAllCollectors(lucid, systemParams.validatorHashes.collectorHash)
-  ).find((utxo) => utxo.assets.lovelace > 100_000_000n);
+  ).find((utxo) => utxo.assets['lovelace'] > 100_000_000n);
   if (!collectorUtxo) {
     throw new Error('Expected a collector UTXO');
   }
 
-  await runAndAwaitTx(
-    lucid,
-    distributeAda(
+  await benchmarkAndAwaitTx(
+    'Staking - Distribute ADA to Stakers',
+    await distributeAda(
       (await findStakingManager(systemParams, lucid)).utxo,
       [collectorUtxo],
       systemParams,
       lucid,
     ),
+    lucid,
+    emulator,
   );
 
   const [pkh, __] = await addrDetails(lucid);
@@ -183,7 +167,7 @@ test<MyContext>('Staking - Distribute ADA to Stakers', async ({
   const [____, userValChange] = await getValueChangeAtAddressAfterAction(
     lucid,
     users.admin.address,
-    async () =>
+    () =>
       runAndAwaitTx(
         lucid,
         closeStakingPosition(
@@ -191,7 +175,6 @@ test<MyContext>('Staking - Distribute ADA to Stakers', async ({
           systemParams,
           lucid,
           emulator.slot,
-          (await findStakingManager(systemParams, lucid)).utxo,
         ),
       ),
   );