@indigo-labs/indigo-sdk 0.3.25 → 0.3.26

package/tests/stableswap/stableswap.test.ts

@@ -208,6 +208,8 @@ test<IndigoTestContext>('Stableswap - Batch a single order to mint', async (cont
     context.systemParams,
   );
 
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
   const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
     context.lucid,
     mkTreasuryAddr(context.lucid, context.systemParams),
@@ -389,6 +391,192 @@ test<IndigoTestContext>('Stableswap - Batch a single order to mint with no minti
   );
 });
 
+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);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      benchmarkAndAwaitTx(
+        'Stableswap - Batch a single order to mint with collateral in the pool',
+        await batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  assert(
+    lovelacesAmt(adminValueDiff) >= 0n &&
+      lovelacesAmt(adminValueDiff) < 100_000n,
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      20_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000n - 50_000n,
+    'Unexpected value received by order owner',
+  );
+});
+
 test<IndigoTestContext>('Stableswap - Batch a single order to redeem', async (context: IndigoTestContext) => {
   context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
@@ -498,6 +686,12 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem', async (co
     iassetAc,
   );
 
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
   const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
     context.lucid,
     mkTreasuryAddr(context.lucid, context.systemParams),
@@ -537,6 +731,20 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem', async (co
     negateAssets(initialUserValue),
   );
 
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  assert(
+    lovelacesAmt(adminValueDiff) >= 0n &&
+      lovelacesAmt(adminValueDiff) < 100_000n,
+  );
+
   assert(
     assetClassValueOf(treasuryValChange, iassetAc) == 25_000n &&
       0n <= lovelacesAmt(treasuryValChange) &&
@@ -672,6 +880,12 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem with no red
     context.systemParams,
   );
 
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
   const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
     context.lucid,
     mkTreasuryAddr(context.lucid, context.systemParams),
@@ -709,6 +923,18 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem with no red
     negateAssets(initialUserValue),
   );
 
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  // This one will result in a bigger gain for the admin as the tx fee is lower
+  assert(lovelacesAmt(adminValueDiff) >= 0n);
+
   assert(
     assetClassValueOf(treasuryValChange, iassetAc) == 0n,
     'Unexpected value received by the treasury',
@@ -873,6 +1099,12 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem emptying th
     iassetAc,
   );
 
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
   const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
     context.lucid,
     mkTreasuryAddr(context.lucid, context.systemParams),
@@ -910,6 +1142,20 @@ test<IndigoTestContext>('Stableswap - Batch a single order to redeem emptying th
     negateAssets(initialUserValue),
   );
 
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  assert(
+    lovelacesAmt(adminValueDiff) >= 0n &&
+      lovelacesAmt(adminValueDiff) < 100_000n,
+  );
+
   assert(
     assetClassValueOf(treasuryValChange, iassetAc) == 50_251n &&
       0n <= lovelacesAmt(treasuryValChange) &&

package/tests/utils/benchmark-utils.ts

@@ -79,3 +79,52 @@ export async function benchmarkAndAwaitTx(
 
   await lucid.awaitTx(await (await signedTx.complete()).submit());
 }
+
+// This function is used to benchmark a transaction and await it's successful execution,
+// as well as to query the transaction fee.
+export async function benchmarkAndAwaitTxWithTxFee(
+  name: string,
+  tx: TxBuilder,
+  lucid: LucidEvolution,
+  provider: Provider,
+  extraSigners: string[] = [],
+): Promise<bigint> {
+  // Complete the transaction
+  const bTx = await tx.complete();
+  const signatures = [await bTx.partialSign.withWallet()];
+  for (const signer of extraSigners) {
+    lucid.selectWallet.fromSeed(signer);
+    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
+  }
+
+  const signedTx = bTx.assemble(signatures);
+
+  // Calculate execution units
+  const exUnits = await calculateTxExUnits(provider, signedTx);
+
+  // Get protocol parameters for percentages
+  const protocolParams = await provider.getProtocolParameters();
+
+  if (protocolParams.maxTxExMem !== MAINNET_PROTOCOL_PARAMETERS.maxTxExMem) {
+    throw new Error('Protocol parameters do not match Mainnet');
+  }
+
+  // Calculate percentages
+  const result = {
+    ...exUnits,
+    memPercentage: (exUnits.mem / Number(protocolParams.maxTxExMem)) * 100,
+    stepsPercentage:
+      (exUnits.steps / Number(protocolParams.maxTxExSteps)) * 100,
+    sizePercentage: (exUnits.txSize / Number(protocolParams.maxTxSize)) * 100,
+  };
+
+  BENCHMARK_RESULTS[name] = result;
+
+  const completedTx = await signedTx.complete();
+
+  const txFee = completedTx.toTransaction().body().fee();
+
+  await lucid.awaitTx(await completedTx.submit());
+
+  return txFee;
+}