@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.2.41",
+  "version": "0.3.0",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -40,13 +40,18 @@
   "author": "3rd Eye Labs",
   "license": "MIT",
   "dependencies": {
-    "@3rd-eye-labs/cardano-offchain-common": "^1.1.8",
-    "@evolution-sdk/evolution": "^0.2.5",
+    "@3rd-eye-labs/cardano-offchain-common": "1.2.0",
+    "@evolution-sdk/evolution": "^0.3.22",
     "@harmoniclabs/crypto": "^0.3.0",
     "@lucid-evolution/lucid": "^0.4.29",
+    "@noble/ed25519": "^3.0.0",
+    "@pythnetwork/pyth-lazer-sdk": "^6.0.0",
     "decimal.js": "^10.6.0",
     "dotenv": "^16.5.0",
+    "effect": "^3.19.18",
     "fp-ts": "^2.16.10",
+    "json-with-bigint": "3.5.3",
+    "libsodium-wrappers-sumo": "^0.8.2",
     "ts-pattern": "^5.8.0"
   },
   "devDependencies": {
@@ -64,5 +69,11 @@
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.39.0",
     "vitest": "^4.0.14"
+  },
+  "pnpm": {
+    "overrides": {
+      "libsodium-wrappers-sumo": "0.8.2",
+      "libsodium-sumo": "0.8.2"
+    }
   }
 }

package/src/contracts/cdp/helpers.ts

@@ -1,28 +1,28 @@
-import Decimal from 'decimal.js';
-import {
-  OCD_DECIMAL_UNIT,
-  ocdAdd,
-  ocdCeil,
-  ocdDiv,
-  ocdMul,
-  ocdNegate,
-  ocdSub,
-  OnChainDecimal,
-} from '../../types/on-chain-decimal';
 import { Network, slotToUnixTime, UTxO } from '@lucid-evolution/lucid';
-import { CDPContent } from './types';
 import { calculateAccruedInterest } from '../interest-oracle/helpers';
 import { match, P } from 'ts-pattern';
-import { InterestOracleDatum } from '../interest-oracle/types';
-import { lovelacesAmt } from '../../utils/value-helpers';
-import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import { assetClassValueOf } from '@3rd-eye-labs/cardano-offchain-common';
+import { InterestOracleDatum } from '../interest-oracle/types-new';
+import { CDPContent } from './types-new';
+import {
+  Rational,
+  rationalAdd,
+  rationalCeil,
+  rationalDiv,
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+  rationalNegate,
+  rationalSub,
+} from '../../types/rational';
 
 /**
  * This is mostly for debugging purposes.
  */
 export function cdpCollateralRatioPercentage(
   currentSlot: number,
-  iassetPrice: OnChainDecimal,
+  iassetPrice: Rational,
   cdpUtxo: UTxO,
   cdpContent: CDPContent,
   interestOracleDatum: InterestOracleDatum,
@@ -32,29 +32,28 @@ export function cdpCollateralRatioPercentage(
 
   return match(cdpContent.cdpFees)
     .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      const interestAdaAmt = ocdMul(
-        {
-          getOnChainInt: calculateAccruedInterest(
-            currentTime,
-            interest.unitaryInterestSnapshot,
-            cdpContent.mintedAmt,
-            interest.lastSettled,
-            interestOracleDatum,
-          ),
-        },
-        iassetPrice,
-      ).getOnChainInt;
+      const interestAmt = calculateAccruedInterest(
+        currentTime,
+        interest.unitaryInterestSnapshot,
+        cdpContent.mintedAmt,
+        interest.lastSettled,
+        interestOracleDatum,
+      );
 
-      const collateral = lovelacesAmt(cdpUtxo.assets) - interestAdaAmt;
+      const collateral = assetClassValueOf(
+        cdpUtxo.assets,
+        cdpContent.collateralAsset,
+      );
 
-      return (
-        Number(
-          ocdDiv(
-            { getOnChainInt: collateral * 100n },
-            ocdMul({ getOnChainInt: cdpContent.mintedAmt }, iassetPrice),
-          ).getOnChainInt,
-        ) / Number(OCD_DECIMAL_UNIT)
+      const ratio = rationalDiv(
+        rationalFromInt(collateral),
+        rationalMul(
+          rationalFromInt(cdpContent.mintedAmt + interestAmt),
+          iassetPrice,
+        ),
       );
+
+      return Number((ratio.numerator * 100n) / ratio.denominator);
     })
     .with({ FrozenCDPAccumulatedFees: P.any }, () => 0)
     .exhaustive();
@@ -66,29 +65,16 @@ export function cdpCollateralRatioPercentage(
 export function calculateIAssetRedemptionAmt(
   collateralAmt: bigint,
   mintedAmt: bigint,
-  price: OnChainDecimal,
-  rmr: OnChainDecimal,
+  price: Rational,
+  rmr: Rational,
 ): bigint {
-  const hundred: OnChainDecimal = {
-    getOnChainInt: 100n * OCD_DECIMAL_UNIT,
-  };
-
-  const res = ocdAdd(
-    ocdNegate(
-      ocdDiv({ getOnChainInt: collateralAmt * OCD_DECIMAL_UNIT }, price),
-    ),
-    ocdDiv(
-      ocdMul(rmr, { getOnChainInt: mintedAmt * OCD_DECIMAL_UNIT }),
-      hundred,
-    ),
-  );
-
-  return ocdCeil(
-    ocdDiv(
-      res,
-      ocdSub(ocdDiv(rmr, hundred), {
-        getOnChainInt: OCD_DECIMAL_UNIT,
-      }),
+  return rationalCeil(
+    rationalDiv(
+      rationalAdd(
+        rationalNegate(rationalDiv(rationalFromInt(collateralAmt), price)),
+        rationalMul(rmr, rationalFromInt(mintedAmt)),
+      ),
+      rationalSub(rmr, rationalFromInt(1n)),
     ),
   );
 }
@@ -113,9 +99,9 @@ export function calculateIAssetRedemptionAmt(
 export function calculateMinCollateralCappedIAssetRedemptionAmt(
   collateralAmt: bigint,
   mintedAmt: bigint,
-  price: OnChainDecimal,
-  rmr: OnChainDecimal,
-  reimburstmentPercentage: OnChainDecimal,
+  price: Rational,
+  rmr: Rational,
+  reimbursementRatio: Rational,
   minCollateral: bigint,
 ): {
   uncappedIAssetRedemptionAmt: bigint;
@@ -127,12 +113,12 @@ export function calculateMinCollateralCappedIAssetRedemptionAmt(
     price,
     rmr,
   );
-  const uncappedMaxRedemptionLovelacesAmt = ocdMul(price, {
-    getOnChainInt: uncappedMaxIAssetRedemptionAmt,
-  }).getOnChainInt;
+  const uncappedMaxRedemptionLovelacesAmt = rationalFloor(
+    rationalMul(price, rationalFromInt(uncappedMaxIAssetRedemptionAmt)),
+  );
 
-  const maxReimburstment = calculateFeeFromPercentage(
-    reimburstmentPercentage,
+  const maxReimburstment = calculateFeeFromRatio(
+    reimbursementRatio,
     uncappedMaxRedemptionLovelacesAmt,
   );
 
@@ -152,16 +138,26 @@ export function calculateMinCollateralCappedIAssetRedemptionAmt(
       cappedIAssetRedemptionAmt: 0n,
     };
   } else {
-    const resLovelaces = Decimal(
-      (minCollateral - collateralAmt) * 100_000_000n,
-    ).div(reimburstmentPercentage.getOnChainInt - 100_000_000n);
-    const resIAsset = resLovelaces.div(
-      Decimal(price.getOnChainInt).div(OCD_DECIMAL_UNIT),
+    const resLovelaces = rationalDiv(
+      rationalFromInt(minCollateral - collateralAmt),
+      rationalSub(reimbursementRatio, rationalFromInt(1n)),
     );
+    const resIAsset = rationalDiv(resLovelaces, price);
 
     return {
       uncappedIAssetRedemptionAmt: uncappedMaxIAssetRedemptionAmt,
-      cappedIAssetRedemptionAmt: BigInt(resIAsset.floor().toNumber()),
+      cappedIAssetRedemptionAmt: rationalFloor(resIAsset),
     };
   }
 }
+
+export function adjustPriceToDecimals(
+  extraDecimals: bigint,
+  price: Rational,
+): Rational {
+  return extraDecimals === 0n
+    ? price
+    : extraDecimals > 0n
+      ? rationalMul(price, rationalFromInt(10n ** extraDecimals))
+      : rationalDiv(price, rationalFromInt(10n ** -extraDecimals));
+}

package/src/contracts/cdp/scripts.ts

@@ -1,32 +1,69 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import { CdpParamsSP, fromSystemParamsAsset } from '../../types/system-params';
-import { castCdpParams } from './types';
+import {
+  applyParamsToScript,
+  SpendingValidator,
+  WithdrawalValidator,
+} from '@lucid-evolution/lucid';
+import {
+  CdpParamsSP,
+  CdpRedeemParamsSP,
+  fromSystemParamsAssetLucid,
+} from '../../types/system-params';
+import { castCdpParams, castCdpRedeemParams } from './types';
 import { _cdpValidator } from '../../validators/cdp-validator';
+import { _cdpRedeemValidator } from '../../validators/cdp-redeem-validator';
 
 export const mkCdpValidatorFromSP = (
   params: CdpParamsSP,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_cdpValidator.cborHex, [
       castCdpParams({
-        cdp_auth_token: fromSystemParamsAsset(params.cdpAuthToken),
+        cdp_auth_token: fromSystemParamsAssetLucid(params.cdpAuthToken),
         cdp_asset_symbol: params.cdpAssetSymbol.unCurrencySymbol,
-        iasset_auth_token: fromSystemParamsAsset(params.iAssetAuthToken),
-        stability_pool_auth_token: fromSystemParamsAsset(
+        iasset_auth_token: fromSystemParamsAssetLucid(params.iAssetAuthToken),
+        collateral_asset_auth_token: fromSystemParamsAssetLucid(
+          params.collateralAssetAuthToken,
+        ),
+        stability_pool_auth_token: fromSystemParamsAssetLucid(
           params.stabilityPoolAuthToken,
         ),
-        version_record_token: fromSystemParamsAsset(params.versionRecordToken),
-        upgrade_token: fromSystemParamsAsset(params.upgradeToken),
-        collector_val_hash: params.collectorValHash,
+        upgrade_token: fromSystemParamsAssetLucid(params.upgradeToken),
+        version_record_token: fromSystemParamsAssetLucid(
+          params.versionRecordToken,
+        ),
+        interest_collector_val_hash: params.interestCollectorValHash,
         sp_val_hash: params.spValHash,
-        gov_nft: fromSystemParamsAsset(params.govNFT),
-        min_collateral_in_lovelace: BigInt(params.minCollateralInLovelace),
+        iasset_val_hash: params.iassetValHash,
+        treasury_val_hash: params.treasuryValHash,
+        cdp_redeem_val_hash: params.cdpRedeemValHash,
+        bias_time: BigInt(params.biasTime),
+      }),
+    ]),
+  };
+};
+
+export const mkCdpRedeemValidatorFromSP = (
+  params: CdpRedeemParamsSP,
+): WithdrawalValidator => {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_cdpRedeemValidator.cborHex, [
+      castCdpRedeemParams({
+        cdp_auth_token: fromSystemParamsAssetLucid(params.cdpAuthToken),
+        cdp_asset_symbol: params.cdpAssetSymbol.unCurrencySymbol,
+        iasset_auth_token: fromSystemParamsAssetLucid(params.iAssetAuthToken),
+        collateral_asset_auth_token: fromSystemParamsAssetLucid(
+          params.collateralAssetAuthToken,
+        ),
+        interest_collector_val_hash: params.interestCollectorValHash,
+        iasset_val_hash: params.iassetValHash,
+        treasury_val_hash: params.treasuryValHash,
+        gov_nft: fromSystemParamsAssetLucid(params.govNFT),
         partial_redemption_extra_fee_lovelace: BigInt(
           params.partialRedemptionExtraFeeLovelace,
         ),
         bias_time: BigInt(params.biasTime),
-        treasury_val_hash: params.treasuryValHash,
       }),
     ]),
   };