@indigo-labs/indigo-sdk 0.1.27 → 0.2.0

package/eslint.config.mjs

@@ -1,13 +1,17 @@
 import eslint from '@eslint/js';
 import tseslint from 'typescript-eslint';
+import vitestEslint from '@vitest/eslint-plugin';
+import { defineConfig } from 'eslint/config';
 
-export default tseslint.config(
+export default defineConfig(
   {
     ignores: ['**/dist/*', '**/node_modules/*'],
   },
   {
     files: ['**/*.ts'],
     extends: [
+      // The vitest eslint recommended is important at least because it's easy to forget `expect`'s matcher calls.
+      vitestEslint.configs.recommended,
       eslint.configs.recommended,
       tseslint.configs.recommendedTypeChecked,
       {
@@ -20,8 +24,10 @@ export default tseslint.config(
       },
     ],
     rules: {
+      'vitest/expect-expect': 'off',
       'no-unreachable': 'warn',
       'no-use-before-define': 'error',
+      'no-unused-expressions': 'warn',
       '@typescript-eslint/no-unused-vars': [
         'error',
         {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.1.27",
+  "version": "0.2.0",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean --tsconfig tsconfig.build.json",
-    "lint": "npx eslint .",
+    "type-check": "tsc --noEmit",
+    "lint": "pnpm eslint .",
     "lint:fix": "npx eslint --fix .",
     "repack": "pnpm run build  && pnpm pack",
     "format": "npx prettier --write src/ tests/",
@@ -39,8 +40,11 @@
   "author": "3rd Eye Labs",
   "license": "MIT",
   "dependencies": {
-    "@lucid-evolution/experimental": "^0.0.9",
+    "@3rd-eye-labs/cardano-offchain-common": "^1.1.6",
+    "@evolution-sdk/evolution": "^0.2.5",
+    "@harmoniclabs/crypto": "^0.3.0",
     "@lucid-evolution/lucid": "^0.4.29",
+    "decimal.js": "^10.6.0",
     "dotenv": "^16.5.0",
     "fp-ts": "^2.16.10",
     "ts-pattern": "^5.8.0"
@@ -51,6 +55,7 @@
     "@babel/preset-typescript": "^7.21.4",
     "@eslint/js": "^9.32.0",
     "@types/node": "^24.3.0",
+    "@vitest/eslint-plugin": "^1.5.0",
     "eslint": "^9.32.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.5",
@@ -58,6 +63,6 @@
     "tsup": "^8.3.6",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.39.0",
-    "vitest": "3.2.4"
+    "vitest": "^4.0.14"
   }
 }

package/src/contracts/cdp/helpers.ts

@@ -0,0 +1,167 @@
+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';
+
+/**
+ * This is mostly for debugging purposes.
+ */
+export function cdpCollateralRatioPercentage(
+  currentSlot: number,
+  iassetPrice: OnChainDecimal,
+  cdpUtxo: UTxO,
+  cdpContent: CDPContent,
+  interestOracleDatum: InterestOracleDatum,
+  network: Network,
+): number {
+  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+
+  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 collateral = lovelacesAmt(cdpUtxo.assets) - interestAdaAmt;
+
+      return (
+        Number(
+          ocdDiv(
+            { getOnChainInt: collateral * 100n },
+            ocdMul({ getOnChainInt: cdpContent.mintedAmt }, iassetPrice),
+          ).getOnChainInt,
+        ) / Number(OCD_DECIMAL_UNIT)
+      );
+    })
+    .with({ FrozenCDPAccumulatedFees: P.any }, () => 0)
+    .exhaustive();
+}
+
+/**
+ * The amount of iassets to redeem to reach the RMR.
+ */
+export function calculateIAssetRedemptionAmt(
+  collateralAmt: bigint,
+  mintedAmt: bigint,
+  price: OnChainDecimal,
+  rmr: OnChainDecimal,
+): 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,
+      }),
+    ),
+  );
+}
+
+/**
+ * Calculates the allowable redemption amount so the min collateral constraint still holds.
+ * It caps the redemption amount to still satisfy the min collateral.
+ *
+ * Returns uncapped max iassets /\ capped max iassets
+ *
+ * The derived calculation comes from the following equation where:
+ * c - collateral
+ * m - min collateral
+ * r - reimburstment ratio
+ * x - redemption amount
+ *
+ * `c - x + r * x = m`
+ * `-x + r * x = m - c`
+ * `x * (r - 1) = m - c`
+ * `x = (m - c) / r - 1`
+ */
+export function calculateMinCollateralCappedIAssetRedemptionAmt(
+  collateralAmt: bigint,
+  mintedAmt: bigint,
+  price: OnChainDecimal,
+  rmr: OnChainDecimal,
+  reimburstmentPercentage: OnChainDecimal,
+  minCollateral: bigint,
+): {
+  uncappedIAssetRedemptionAmt: bigint;
+  cappedIAssetRedemptionAmt: bigint;
+} {
+  const uncappedMaxIAssetRedemptionAmt = calculateIAssetRedemptionAmt(
+    collateralAmt,
+    mintedAmt,
+    price,
+    rmr,
+  );
+  const uncappedMaxRedemptionLovelacesAmt = ocdMul(price, {
+    getOnChainInt: uncappedMaxIAssetRedemptionAmt,
+  }).getOnChainInt;
+
+  const maxReimburstment = calculateFeeFromPercentage(
+    reimburstmentPercentage,
+    uncappedMaxRedemptionLovelacesAmt,
+  );
+
+  const doesMaxBreakMinCollateral =
+    collateralAmt - uncappedMaxRedemptionLovelacesAmt + maxReimburstment <
+    minCollateral;
+
+  if (!doesMaxBreakMinCollateral) {
+    return {
+      uncappedIAssetRedemptionAmt: uncappedMaxIAssetRedemptionAmt,
+      cappedIAssetRedemptionAmt: uncappedMaxIAssetRedemptionAmt,
+    };
+    // already below min collateral
+  } else if (collateralAmt <= minCollateral) {
+    return {
+      uncappedIAssetRedemptionAmt: uncappedMaxIAssetRedemptionAmt,
+      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),
+    );
+
+    return {
+      uncappedIAssetRedemptionAmt: uncappedMaxIAssetRedemptionAmt,
+      cappedIAssetRedemptionAmt: BigInt(resIAsset.floor().toNumber()),
+    };
+  }
+}

package/src/contracts/cdp/scripts.ts

@@ -0,0 +1,33 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import { CdpParamsSP, fromSystemParamsAsset } from '../../types/system-params';
+import { castCdpParams } from './types';
+import { _cdpValidator } from '../../validators/cdp-validator';
+
+export const mkCdpValidatorFromSP = (
+  params: CdpParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_cdpValidator.cborHex, [
+      castCdpParams({
+        cdp_auth_token: fromSystemParamsAsset(params.cdpAuthToken),
+        cdp_asset_symbol: params.cdpAssetSymbol.unCurrencySymbol,
+        iasset_auth_token: fromSystemParamsAsset(params.iAssetAuthToken),
+        stability_pool_auth_token: fromSystemParamsAsset(
+          params.stabilityPoolAuthToken,
+        ),
+        version_record_token: fromSystemParamsAsset(params.versionRecordToken),
+        upgrade_token: fromSystemParamsAsset(params.upgradeToken),
+        collector_val_hash: params.collectorValHash,
+        sp_val_hash: params.spValHash,
+        gov_nft: fromSystemParamsAsset(params.govNFT),
+        min_collateral_in_lovelace: BigInt(params.minCollateralInLovelace),
+        partial_redemption_extra_fee_lovelace: BigInt(
+          params.partialRedemptionExtraFeeLovelace,
+        ),
+        bias_time: BigInt(params.biasTime),
+        treasury_val_hash: params.treasuryValHash,
+      }),
+    ]),
+  };
+};