@indigo-labs/indigo-sdk 0.3.10 → 0.3.12

package/tests/cdp/cdp.test.ts

@@ -205,6 +205,65 @@ describe('CDP', () => {
       { min: 199, max: 200 },
     );
   });
+  test<MyContext>('Open CDP; ADA collateral - direct treasury payment', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [_, addedValueInTreasury] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      mkTreasuryAddr(context.lucid, sysParams),
+      async () =>
+        benchmarkAndAwaitTx(
+          'CDP - Open CDP; ADA collateral - direct treasury payment',
+          await runOpenCdp(
+            context,
+            sysParams,
+            'iUSD',
+            adaAssetClass,
+            10_000_000n,
+            5_000_000n,
+            undefined,
+            // Direct treasury payment.
+            true,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    const cdp = await findOwnCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    );
+
+    const iAssetAc = {
+      currencySymbol: fromHex(
+        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+      ),
+      tokenName: fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    };
+
+    assert(
+      // A 0.5% of 5,000,000 minted iAsset go to treasury.
+      assetClassValueOf(addedValueInTreasury, iAssetAc) == 25_000n &&
+        // Extra ADA had to be paid to cover the minimum.
+        lovelacesAmt(addedValueInTreasury) > 1_000_000n,
+      'Unexpected value received by the treasury',
+    );
+
+    assertValueInRange(
+      await findCdpCR(context.lucid, sysParams, cdp, context.emulator.slot),
+      { min: 199, max: 200 },
+    );
+  });
   test<MyContext>('Open CDP; non-ADA collateral asset', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
@@ -266,6 +325,69 @@ describe('CDP', () => {
     );
   });
 
+  test<MyContext>('Open CDP; non-ADA collateral asset - direct treasury payment', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    const [_, addedValueInTreasury] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      mkTreasuryAddr(context.lucid, sysParams),
+      async () =>
+        benchmarkAndAwaitTx(
+          'CDP - Open CDP; non-ADA collateral - direct treasury payment',
+          await runOpenCdp(
+            context,
+            sysParams,
+            'iUSD',
+            collateralAssetA,
+            10_000_000n,
+            5_000_000n,
+            undefined,
+            // Direct treasury payment.
+            true,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    const cdp = await findOwnCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    );
+
+    const iAssetAc = {
+      currencySymbol: fromHex(
+        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+      ),
+      tokenName: fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    };
+
+    assert(
+      // A 0.5% of 5,000,000 minted iAsset go to treasury.
+      assetClassValueOf(addedValueInTreasury, iAssetAc) == 25_000n &&
+        // Extra ADA had to be paid to cover the minimum.
+        lovelacesAmt(addedValueInTreasury) > 1_000_000n,
+      'Unexpected value received by the treasury',
+    );
+
+    assertValueInRange(
+      await findCdpCR(context.lucid, sysParams, cdp, context.emulator.slot),
+      { min: 199, max: 200 },
+    );
+  });
+
   // This tests opening a CDP with a collateral asset with 8 decimals, such as xBTC.
   test<MyContext>('Open CDP; non-ADA collateral asset with more decimals', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
@@ -1046,7 +1168,7 @@ describe('CDP', () => {
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
 
     await expectScriptFailure(
-      'I',
+      'H',
       runTestAdjustCdpDelisted(
         context,
         sysParams,
@@ -1603,7 +1725,7 @@ describe('CDP', () => {
             iusdInitialAssetCfg().debtMintingFeeRatio,
             rationalFromInt(debtAdjustment),
           ),
-        ),
+        ) && lovelacesAmt(treasuryValChange) < 700_000n,
       'Unexpected value received by the treasury',
     );
 
@@ -1619,16 +1741,12 @@ describe('CDP', () => {
     expect(lovelacesAmt(cdpAfterAction.utxo.assets)).toBe(initialCollateral);
   });
 
-  test<MyContext>('Mint CDP w/ interest; non-ADA collateral', async (context: MyContext) => {
+  test<IndigoTestContext>('Mint CDP w/ interest; ADA collateral - direct treasury payment', async (context: IndigoTestContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
     const [sysParams, [iusdAssetInfo]] = await init(
       context.lucid,
-      [
-        {
-          ...iusdInitialAssetCfg(),
-          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
-        },
-      ],
+      [iusdInitialAssetCfg()],
       context.emulator.slot,
     );
 
@@ -1643,7 +1761,7 @@ describe('CDP', () => {
         context,
         sysParams,
         iasset,
-        collateralAssetA,
+        adaAssetClass,
         initialCollateral,
         initialMint,
       ),
@@ -1655,7 +1773,7 @@ describe('CDP', () => {
       context,
       sysParams,
       iusdAssetInfo,
-      collateralAssetA,
+      adaAssetClass,
       rationalFromInt(1n),
     );
 
@@ -1691,13 +1809,15 @@ describe('CDP', () => {
         ],
         async () =>
           benchmarkAndAwaitTx(
-            'CDP - Mint CDP w/ interest; non-ADA collateral',
+            'CDP - Mint CDP w/ interest; ADA collateral - direct treasury payment',
             await runMintCdp(
               context,
               sysParams,
               'iUSD',
-              collateralAssetA,
+              adaAssetClass,
               debtAdjustment,
+              undefined,
+              true,
             ),
             context.lucid,
             context.emulator,
@@ -1728,7 +1848,7 @@ describe('CDP', () => {
             iusdInitialAssetCfg().debtMintingFeeRatio,
             rationalFromInt(debtAdjustment),
           ),
-        ),
+        ) && lovelacesAmt(treasuryValChange) > 1_000_000n,
       'Unexpected value received by the treasury',
     );
 
@@ -1741,47 +1861,301 @@ describe('CDP', () => {
     expect(cdpAfterAction.datum.mintedAmt).toBe(
       initialMint + 100_000n + interestPaid,
     );
-    expect(
-      assetClassValueOf(cdpAfterAction.utxo.assets, collateralAssetA),
-    ).toBe(initialCollateral);
+    expect(lovelacesAmt(cdpAfterAction.utxo.assets)).toBe(initialCollateral);
   });
 
-  test<IndigoTestContext>('Mint CDP with expired oracle fails', async (context: IndigoTestContext) => {
+  test<MyContext>('Mint CDP w/ interest; non-ADA collateral', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
     const [sysParams, [iusdAssetInfo]] = await init(
       context.lucid,
-      [iusdInitialAssetCfg()],
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
+        },
+      ],
       context.emulator.slot,
     );
 
     context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+    const iasset = 'iUSD';
+    const initialCollateral = 12_000_000n;
+    const initialMint = 500_000n;
+
     await runAndAwaitTx(
       context.lucid,
       runOpenCdp(
         context,
         sysParams,
-        'iUSD',
-        adaAssetClass,
-        12_000_000n,
-        500_000n,
+        iasset,
+        collateralAssetA,
+        initialCollateral,
+        initialMint,
       ),
     );
 
-    //Await until oracle is expired
-    context.emulator.awaitSlot(
-      Number(iusdAssetInfo.collateralAssets[0].oracleParams!.expirationPeriod) /
-        1000,
+    context.emulator.awaitSlot(60500);
+
+    await runFeedPriceToOracle(
+      context,
+      sysParams,
+      iusdAssetInfo,
+      collateralAssetA,
+      rationalFromInt(1n),
     );
 
-    await expectScriptFailure(
-      'X',
-      runMintCdp(context, sysParams, 'iUSD', adaAssetClass),
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const debtAdjustment = 100_000n;
+
+    const [pkh, skh] = await addrDetails(context.lucid);
+
+    const cdpBeforeAction = await findCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+      pkh.hash,
+      skh,
+    );
+
+    const cdpOwedInterest = await calculateCdpInterest(
+      cdpBeforeAction.datum,
+      context,
+      sysParams,
+    );
+
+    const [__, [interestCollectorValChange, treasuryValChange]] =
+      await getValueChangeAtAddressesAfterAction(
+        context.lucid,
+        [
+          createScriptAddress(
+            context.lucid.config().network!,
+            sysParams.validatorHashes.interestCollectionHash,
+          ),
+          mkTreasuryAddr(context.lucid, sysParams),
+        ],
+        async () =>
+          benchmarkAndAwaitTx(
+            'CDP - Mint CDP w/ interest; non-ADA collateral',
+            await runMintCdp(
+              context,
+              sysParams,
+              'iUSD',
+              collateralAssetA,
+              debtAdjustment,
+            ),
+            context.lucid,
+            context.emulator,
+          ),
+      );
+
+    const iAssetAc = {
+      currencySymbol: fromHex(
+        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+      ),
+      tokenName: fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    };
+
+    const interestPaid = assetClassValueOf(
+      interestCollectorValChange,
+      iAssetAc,
+    );
+
+    assert(
+      interestPaid > 0 && interestPaid == cdpOwedInterest,
+      'Expected interest paid to collector',
+    );
+
+    assert(
+      assetClassValueOf(treasuryValChange, iAssetAc) ==
+        rationalFloor(
+          rationalMul(
+            iusdInitialAssetCfg().debtMintingFeeRatio,
+            rationalFromInt(debtAdjustment),
+          ),
+        ) && lovelacesAmt(treasuryValChange) < 700_000n,
+      'Unexpected value received by the treasury',
+    );
+
+    const cdpAfterAction = await findOwnCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    );
+
+    expect(cdpAfterAction.datum.mintedAmt).toBe(
+      initialMint + 100_000n + interestPaid,
     );
+    expect(
+      assetClassValueOf(cdpAfterAction.utxo.assets, collateralAssetA),
+    ).toBe(initialCollateral);
   });
 
-  test<IndigoTestContext>('Mint CDP with delisted iAsset fails', async (context: IndigoTestContext) => {
+  test<MyContext>('Mint CDP w/ interest; non-ADA collateral - direct treasury payment', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
-    const [sysParams, [iUsdInfo]] = await init(
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+    const iasset = 'iUSD';
+    const initialCollateral = 12_000_000n;
+    const initialMint = 500_000n;
+
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        iasset,
+        collateralAssetA,
+        initialCollateral,
+        initialMint,
+      ),
+    );
+
+    context.emulator.awaitSlot(60500);
+
+    await runFeedPriceToOracle(
+      context,
+      sysParams,
+      iusdAssetInfo,
+      collateralAssetA,
+      rationalFromInt(1n),
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const debtAdjustment = 100_000n;
+
+    const [pkh, skh] = await addrDetails(context.lucid);
+
+    const cdpBeforeAction = await findCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+      pkh.hash,
+      skh,
+    );
+
+    const cdpOwedInterest = await calculateCdpInterest(
+      cdpBeforeAction.datum,
+      context,
+      sysParams,
+    );
+
+    const [__, [interestCollectorValChange, treasuryValChange]] =
+      await getValueChangeAtAddressesAfterAction(
+        context.lucid,
+        [
+          createScriptAddress(
+            context.lucid.config().network!,
+            sysParams.validatorHashes.interestCollectionHash,
+          ),
+          mkTreasuryAddr(context.lucid, sysParams),
+        ],
+        async () =>
+          benchmarkAndAwaitTx(
+            'CDP - Mint CDP w/ interest; non-ADA collateral - direct treasury payment',
+            await runMintCdp(
+              context,
+              sysParams,
+              'iUSD',
+              collateralAssetA,
+              debtAdjustment,
+              undefined,
+              true,
+            ),
+            context.lucid,
+            context.emulator,
+          ),
+      );
+
+    const iAssetAc = {
+      currencySymbol: fromHex(
+        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+      ),
+      tokenName: fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    };
+
+    const interestPaid = assetClassValueOf(
+      interestCollectorValChange,
+      iAssetAc,
+    );
+
+    assert(
+      interestPaid > 0 && interestPaid == cdpOwedInterest,
+      'Expected interest paid to collector',
+    );
+
+    assert(
+      assetClassValueOf(treasuryValChange, iAssetAc) ==
+        rationalFloor(
+          rationalMul(
+            iusdInitialAssetCfg().debtMintingFeeRatio,
+            rationalFromInt(debtAdjustment),
+          ),
+        ) && lovelacesAmt(treasuryValChange) > 1_000_000n,
+      'Unexpected value received by the treasury',
+    );
+
+    const cdpAfterAction = await findOwnCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    );
+
+    expect(cdpAfterAction.datum.mintedAmt).toBe(
+      initialMint + 100_000n + interestPaid,
+    );
+    expect(
+      assetClassValueOf(cdpAfterAction.utxo.assets, collateralAssetA),
+    ).toBe(initialCollateral);
+  });
+
+  test<IndigoTestContext>('Mint CDP with expired oracle fails', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        adaAssetClass,
+        12_000_000n,
+        500_000n,
+      ),
+    );
+
+    //Await until oracle is expired
+    context.emulator.awaitSlot(
+      Number(iusdAssetInfo.collateralAssets[0].oracleParams!.expirationPeriod) /
+        1000,
+    );
+
+    await expectScriptFailure(
+      'X',
+      runMintCdp(context, sysParams, 'iUSD', adaAssetClass),
+    );
+  });
+
+  test<IndigoTestContext>('Mint CDP with delisted iAsset fails', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+    const [sysParams, [iUsdInfo]] = await init(
       context.lucid,
       [
         {
@@ -2939,17 +3313,12 @@ describe('CDP', () => {
     );
   });
 
-  test<IndigoTestContext>('Redeem CDP; non-ADA collateral', async (context: IndigoTestContext) => {
+  test<IndigoTestContext>('Redeem CDP; ADA collateral - direct treasury payment', async (context: IndigoTestContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
     const [sysParams, [iusdAssetInfo]] = await init(
       context.lucid,
-      [
-        {
-          ...iusdInitialAssetCfg(),
-          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
-        },
-      ],
+      [iusdInitialAssetCfg()],
       context.emulator.slot,
       () => [],
       {
@@ -2977,7 +3346,7 @@ describe('CDP', () => {
         context,
         sysParams,
         'iUSD',
-        collateralAssetA,
+        adaAssetClass,
         50_000_000n,
         10_000_000n,
       ),
@@ -2992,7 +3361,7 @@ describe('CDP', () => {
         context,
         sysParams,
         'iUSD',
-        collateralAssetA,
+        adaAssetClass,
         20_000_000n,
         10_000_000n,
       ),
@@ -3003,7 +3372,7 @@ describe('CDP', () => {
       context,
       sysParams,
       iusdAssetInfo,
-      collateralAssetA,
+      adaAssetClass,
       { numerator: 125n, denominator: 100n },
     );
 
@@ -3011,34 +3380,23 @@ describe('CDP', () => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
     await benchmarkAndAwaitTx(
-      'CDP - Redeem CDP; non-ADA collateral',
+      'CDP - Redeem CDP; ADA collateral - direct treasury payment',
       await runRedeemCdp(
         context,
         sysParams,
         iusdAssetInfo,
-        collateralAssetA,
+        adaAssetClass,
         pkh.hash,
         skh,
+        // Direct treasury payment
+        true,
       ),
       context.lucid,
       context.emulator,
     );
-
-    const cdp = await findCdp(
-      context.lucid,
-      sysParams.validatorHashes.cdpHash,
-      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-      pkh.hash,
-      skh,
-    );
-
-    expect(cdp.datum.mintedAmt).toBe(6_000_000n);
-    expect(assetClassValueOf(cdp.utxo.assets, collateralAssetA)).toBe(
-      15_050_000n,
-    );
   });
 
-  test<IndigoTestContext>('Redeem CDP; non-ADA collateral with more decimals', async (context: IndigoTestContext) => {
+  test<IndigoTestContext>('Redeem CDP; non-ADA collateral', async (context: IndigoTestContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
     const [sysParams, [iusdAssetInfo]] = await init(
@@ -3046,14 +3404,7 @@ describe('CDP', () => {
       [
         {
           ...iusdInitialAssetCfg(),
-          collateralAssets: [
-            mkBaseCollateralAsset(
-              collateralAssetA,
-              0n,
-              rationalFromInt(1n),
-              2n,
-            ),
-          ],
+          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
         },
       ],
       context.emulator.slot,
@@ -3084,7 +3435,7 @@ describe('CDP', () => {
         sysParams,
         'iUSD',
         collateralAssetA,
-        5_000_000_000n,
+        50_000_000n,
         10_000_000n,
       ),
     );
@@ -3099,7 +3450,7 @@ describe('CDP', () => {
         sysParams,
         'iUSD',
         collateralAssetA,
-        2_000_000_000n,
+        20_000_000n,
         10_000_000n,
       ),
     );
@@ -3116,9 +3467,9 @@ describe('CDP', () => {
     // Let admin do the redemption (i.e. not the CDP's owner)
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
-    await runAndAwaitTx(
-      context.lucid,
-      runRedeemCdp(
+    await benchmarkAndAwaitTx(
+      'CDP - Redeem CDP; non-ADA collateral',
+      await runRedeemCdp(
         context,
         sysParams,
         iusdAssetInfo,
@@ -3126,6 +3477,8 @@ describe('CDP', () => {
         pkh.hash,
         skh,
       ),
+      context.lucid,
+      context.emulator,
     );
 
     const cdp = await findCdp(
@@ -3138,11 +3491,11 @@ describe('CDP', () => {
 
     expect(cdp.datum.mintedAmt).toBe(6_000_000n);
     expect(assetClassValueOf(cdp.utxo.assets, collateralAssetA)).toBe(
-      1_505_000_000n,
+      15_050_000n,
     );
   });
 
-  test<IndigoTestContext>('Redeem CDP; non-ADA collateral with less decimals', async (context: IndigoTestContext) => {
+  test<IndigoTestContext>('Redeem CDP; non-ADA collateral - direct treasury payment', async (context: IndigoTestContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
     const [sysParams, [iusdAssetInfo]] = await init(
@@ -3150,14 +3503,7 @@ describe('CDP', () => {
       [
         {
           ...iusdInitialAssetCfg(),
-          collateralAssets: [
-            mkBaseCollateralAsset(
-              collateralAssetA,
-              0n,
-              rationalFromInt(1n),
-              -2n,
-            ),
-          ],
+          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
         },
       ],
       context.emulator.slot,
@@ -3189,7 +3535,7 @@ describe('CDP', () => {
         'iUSD',
         collateralAssetA,
         50_000_000n,
-        1_000_000_000n,
+        10_000_000n,
       ),
     );
 
@@ -3204,7 +3550,7 @@ describe('CDP', () => {
         'iUSD',
         collateralAssetA,
         20_000_000n,
-        1_000_000_000n,
+        10_000_000n,
       ),
     );
 
@@ -3220,16 +3566,20 @@ describe('CDP', () => {
     // Let admin do the redemption (i.e. not the CDP's owner)
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
-    await runAndAwaitTx(
-      context.lucid,
-      runRedeemCdp(
+    await benchmarkAndAwaitTx(
+      'CDP - Redeem CDP; non-ADA collateral - direct treasury payment',
+      await runRedeemCdp(
         context,
         sysParams,
         iusdAssetInfo,
         collateralAssetA,
         pkh.hash,
         skh,
+        // Direct treasury payment
+        true,
       ),
+      context.lucid,
+      context.emulator,
     );
 
     const cdp = await findCdp(
@@ -3240,18 +3590,30 @@ describe('CDP', () => {
       skh,
     );
 
-    expect(cdp.datum.mintedAmt).toBe(600_000_000n);
+    expect(cdp.datum.mintedAmt).toBe(6_000_000n);
     expect(assetClassValueOf(cdp.utxo.assets, collateralAssetA)).toBe(
       15_050_000n,
     );
   });
 
-  test<IndigoTestContext>('Redeem CDP by unauthorized user fails', async (context: IndigoTestContext) => {
+  test<IndigoTestContext>('Redeem CDP; non-ADA collateral with more decimals', async (context: IndigoTestContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
     const [sysParams, [iusdAssetInfo]] = await init(
       context.lucid,
-      [iusdInitialAssetCfg()],
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: [
+            mkBaseCollateralAsset(
+              collateralAssetA,
+              0n,
+              rationalFromInt(1n),
+              2n,
+            ),
+          ],
+        },
+      ],
       context.emulator.slot,
       () => [],
       {
@@ -3272,17 +3634,213 @@ describe('CDP', () => {
       ),
     );
 
-    const [pkh, skh] = await addrDetails(context.lucid);
-
-    // Create redeemed CDP from Admin wallet
+    // Add iAssets to admin's wallet
     await runAndAwaitTx(
       context.lucid,
       runOpenCdp(
         context,
         sysParams,
         'iUSD',
-        adaAssetClass,
-        20_000_000n,
+        collateralAssetA,
+        5_000_000_000n,
+        10_000_000n,
+      ),
+    );
+
+    // Create redeemed CDP from user wallet
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+    const [pkh, skh] = await addrDetails(context.lucid);
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        collateralAssetA,
+        2_000_000_000n,
+        10_000_000n,
+      ),
+    );
+
+    // Feed price oracle
+    await runFeedPriceToOracle(
+      context,
+      sysParams,
+      iusdAssetInfo,
+      collateralAssetA,
+      { numerator: 125n, denominator: 100n },
+    );
+
+    // Let admin do the redemption (i.e. not the CDP's owner)
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    await runAndAwaitTx(
+      context.lucid,
+      runRedeemCdp(
+        context,
+        sysParams,
+        iusdAssetInfo,
+        collateralAssetA,
+        pkh.hash,
+        skh,
+      ),
+    );
+
+    const cdp = await findCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+      pkh.hash,
+      skh,
+    );
+
+    expect(cdp.datum.mintedAmt).toBe(6_000_000n);
+    expect(assetClassValueOf(cdp.utxo.assets, collateralAssetA)).toBe(
+      1_505_000_000n,
+    );
+  });
+
+  test<IndigoTestContext>('Redeem CDP; non-ADA collateral with less decimals', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: [
+            mkBaseCollateralAsset(
+              collateralAssetA,
+              0n,
+              rationalFromInt(1n),
+              -2n,
+            ),
+          ],
+        },
+      ],
+      context.emulator.slot,
+      () => [],
+      {
+        cdpRedemptionRequiredSignature: fromHex(
+          paymentCredentialOf(context.users.admin.address).hash,
+        ),
+      },
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      feedInterestOracle(
+        iusdAssetInfo.collateralAssets[0].interestOracleParams,
+        0n,
+        context.lucid,
+        context.emulator.slot,
+        iusdAssetInfo.collateralAssets[0].interestOracleNft,
+      ),
+    );
+
+    // Add iAssets to admin's wallet
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        collateralAssetA,
+        50_000_000n,
+        1_000_000_000n,
+      ),
+    );
+
+    // Create redeemed CDP from user wallet
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+    const [pkh, skh] = await addrDetails(context.lucid);
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        collateralAssetA,
+        20_000_000n,
+        1_000_000_000n,
+      ),
+    );
+
+    // Feed price oracle
+    await runFeedPriceToOracle(
+      context,
+      sysParams,
+      iusdAssetInfo,
+      collateralAssetA,
+      { numerator: 125n, denominator: 100n },
+    );
+
+    // Let admin do the redemption (i.e. not the CDP's owner)
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    await runAndAwaitTx(
+      context.lucid,
+      runRedeemCdp(
+        context,
+        sysParams,
+        iusdAssetInfo,
+        collateralAssetA,
+        pkh.hash,
+        skh,
+      ),
+    );
+
+    const cdp = await findCdp(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+      pkh.hash,
+      skh,
+    );
+
+    expect(cdp.datum.mintedAmt).toBe(600_000_000n);
+    expect(assetClassValueOf(cdp.utxo.assets, collateralAssetA)).toBe(
+      15_050_000n,
+    );
+  });
+
+  test<IndigoTestContext>('Redeem CDP by unauthorized user fails', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+      () => [],
+      {
+        cdpRedemptionRequiredSignature: fromHex(
+          paymentCredentialOf(context.users.admin.address).hash,
+        ),
+      },
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      feedInterestOracle(
+        iusdAssetInfo.collateralAssets[0].interestOracleParams,
+        0n,
+        context.lucid,
+        context.emulator.slot,
+        iusdAssetInfo.collateralAssets[0].interestOracleNft,
+      ),
+    );
+
+    const [pkh, skh] = await addrDetails(context.lucid);
+
+    // Create redeemed CDP from Admin wallet
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        adaAssetClass,
+        20_000_000n,
         10_000_000n,
       ),
     );
@@ -5252,6 +5810,152 @@ describe('CDP', () => {
     }
   });
 
+  test<MyContext>('Liquidate CDP; ADA collateral - direct treasury payment', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    // Open CDP
+    // This is the position that will get liquidated.
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        adaAssetClass,
+        10_000_000n,
+        5_000_000n,
+      ),
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    // Create Stability Pool account
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdpAndCreateSPAccount(
+        context,
+        sysParams,
+        'iUSD',
+        adaAssetClass,
+        10_000_000n,
+      ),
+    );
+
+    // Process the create account request
+    await runAndAwaitTx(
+      context.lucid,
+      runProcessSpRequest(
+        context,
+        sysParams,
+        'iUSD',
+        paymentCredentialOf(context.users.user.address).hash,
+      ),
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    await runFeedPriceToOracle(
+      context,
+      sysParams,
+      iusdAssetInfo,
+      adaAssetClass,
+      { numerator: 18n, denominator: 10n },
+    );
+
+    // Validate that CDP CR is in Liquidation Range
+    {
+      const [pkh, skh] = await addrDetails(context.lucid);
+      const cdp = await findCdp(
+        context.lucid,
+        sysParams.validatorHashes.cdpHash,
+        fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+        pkh.hash,
+        skh,
+      );
+
+      assertValueInRange(
+        await findCdpCR(context.lucid, sysParams, cdp, context.emulator.slot),
+        { min: 111, max: 112 },
+      );
+    }
+
+    // We want user to do the freeze of admin's CDP
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await runAndAwaitTx(
+      context.lucid,
+      runFreezeCdp(
+        context,
+        sysParams,
+        'iUSD',
+        adaAssetClass,
+        paymentCredentialOf(context.users.admin.address).hash,
+        stakeCredentialOf(context.users.admin.address),
+      ),
+    );
+
+    {
+      const frozenCdp = matchSingle(
+        await findFrozenCDPs(
+          context.lucid,
+          sysParams.validatorHashes.cdpHash,
+          fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+          iusdAssetInfo.iassetTokenNameAscii,
+        ),
+        (_) => new Error('Expected only single frozen CDP'),
+      );
+
+      const orefs = await findAllNecessaryOrefs(
+        context.lucid,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        adaAssetClass,
+      );
+
+      await benchmarkAndAwaitTx(
+        'CDP - Liquidate CDP; ADA collateral - direct treasury payment',
+        await liquidateCdp(
+          frozenCdp.utxo,
+          orefs.stabilityPoolUtxo,
+          orefs.interestCollectorUtxo,
+          // Direct treasury payment
+          undefined,
+          sysParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+    }
+
+    // Validate that stability pool iassets amount is 4,999,985
+    // (5,000,000 used to burn principal and 15 used to pay interest).
+    {
+      const orefs = await findAllNecessaryOrefs(
+        context.lucid,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        adaAssetClass,
+      );
+
+      expect(
+        assetClassValueOf(orefs.stabilityPoolUtxo.assets, {
+          currencySymbol: fromHex(
+            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          ),
+          tokenName: fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+        }) === 4_999_985n,
+        'Expected different stability pool iassets amount',
+      ).toBeTruthy();
+    }
+  });
+
   test<MyContext>('Liquidate CDP; non-ADA collateral', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
@@ -5402,6 +6106,157 @@ describe('CDP', () => {
     }
   });
 
+  test<MyContext>('Liquidate CDP; non-ADA collateral - direct treasury payment', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: [mkBaseCollateralAsset(collateralAssetA)],
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    // Open CDP
+    // This is the position that will get liquidated.
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdp(
+        context,
+        sysParams,
+        'iUSD',
+        collateralAssetA,
+        10_000_000n,
+        5_000_000n,
+      ),
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    // Create Stability Pool account
+    await runAndAwaitTx(
+      context.lucid,
+      runOpenCdpAndCreateSPAccount(
+        context,
+        sysParams,
+        'iUSD',
+        collateralAssetA,
+        10_000_000n,
+      ),
+    );
+
+    // Process the create account request
+    await runAndAwaitTx(
+      context.lucid,
+      runProcessSpRequest(
+        context,
+        sysParams,
+        'iUSD',
+        paymentCredentialOf(context.users.user.address).hash,
+      ),
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    await runFeedPriceToOracle(
+      context,
+      sysParams,
+      iusdAssetInfo,
+      collateralAssetA,
+      { numerator: 18n, denominator: 10n },
+    );
+
+    // Validate that CDP CR is in Liquidation Range
+    {
+      const [pkh, skh] = await addrDetails(context.lucid);
+      const cdp = await findCdp(
+        context.lucid,
+        sysParams.validatorHashes.cdpHash,
+        fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+        pkh.hash,
+        skh,
+      );
+
+      assertValueInRange(
+        await findCdpCR(context.lucid, sysParams, cdp, context.emulator.slot),
+        { min: 111, max: 112 },
+      );
+    }
+
+    // We want user to do the freeze of admin's CDP
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await runAndAwaitTx(
+      context.lucid,
+      runFreezeCdp(
+        context,
+        sysParams,
+        'iUSD',
+        collateralAssetA,
+        paymentCredentialOf(context.users.admin.address).hash,
+        stakeCredentialOf(context.users.admin.address),
+      ),
+    );
+
+    {
+      const frozenCdp = matchSingle(
+        await findFrozenCDPs(
+          context.lucid,
+          sysParams.validatorHashes.cdpHash,
+          fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+          iusdAssetInfo.iassetTokenNameAscii,
+        ),
+        (_) => new Error('Expected only single frozen CDP'),
+      );
+
+      const orefs = await findAllNecessaryOrefs(
+        context.lucid,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAssetA,
+      );
+
+      await benchmarkAndAwaitTx(
+        'CDP - Liquidate CDP; non ADA collateral - direct treasury payment',
+        await liquidateCdp(
+          frozenCdp.utxo,
+          orefs.stabilityPoolUtxo,
+          orefs.interestCollectorUtxo,
+          // Direct treasury payment
+          undefined,
+          sysParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+    }
+
+    // Validate that stability pool iassets amount is 4,999,985
+    // (5,000,000 used to burn principal and 15 used to pay interest).
+    {
+      const orefs = await findAllNecessaryOrefs(
+        context.lucid,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAssetA,
+      );
+
+      expect(
+        assetClassValueOf(orefs.stabilityPoolUtxo.assets, {
+          currencySymbol: fromHex(
+            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          ),
+          tokenName: fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+        }) === 4_999_985n,
+        'Expected different stability pool iassets amount',
+      ).toBeTruthy();
+    }
+  });
+
   test<IndigoTestContext>('Partially liquidate CDP; ADA collateral', async (context: IndigoTestContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);