@indigo-labs/indigo-sdk 0.3.9 → 0.3.10

package/src/contracts/rob-leverage/transactions.ts

@@ -1,4 +1,4 @@
-/*import {
+import {
   LucidEvolution,
   TxBuilder,
   OutRef,
@@ -7,26 +7,25 @@
   slotToUnixTime,
   Data,
   fromHex,
+  getInputIndices,
 } from '@lucid-evolution/lucid';
 import {
   addrDetails,
   createScriptAddress,
   getInlineDatumOrThrow,
 } from '../../utils/lucid-utils';
-import { parsePriceOracleDatum } from '../price-oracle/types-new';
-import { ocdMul } from '../../types/on-chain-decimal';
 import { serialiseCdpDatum } from '../cdp/types-new';
-import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
 import { matchSingle } from '../../utils/utils';
 import {
   fromSystemParamsAsset,
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
-import { oracleExpirationAwareValidity } from '../price-oracle/helpers';
 import { parseInterestOracleDatum } from '../interest-oracle/types-new';
-import { serialiseCDPCreatorRedeemer } from '../cdp-creator/types-new';
-import { collectorFeeTx } from '../collector/transactions';
+import {
+  serialiseCDPCreatorDatum,
+  serialiseCDPCreatorRedeemer,
+} from '../cdp-creator/types-new';
 import { calculateUnitaryInterestSinceOracleLastUpdated } from '../interest-oracle/helpers';
 import {
   approximateLeverageRedemptions,
@@ -34,33 +33,41 @@ import {
   calculateLeverageFromCollateralRatio,
   MAX_REDEMPTIONS_WITH_CDP_OPEN,
 } from './helpers';
-import {
-  buildRedemptionsTx,
-  randomLrpsSubsetSatisfyingTargetLovelaces,
-} from '../lrp/helpers';
+
 import {
   parseCollateralAssetDatumOrThrow,
   parseIAssetDatumOrThrow,
 } from '../iasset/types';
+import { mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
+import { RobDatum } from '../rob/types-new';
+import { rationalToFloat } from '../../types/rational';
 import {
-  mkAssetsOf,
-  mkLovelacesOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { RobDatum } from '../lrp/types-new';
+  buildRedemptionsTx,
+  randomRobsSubsetSatisfyingTargetCollateral,
+} from '../rob/helpers';
+import { treasuryFeeTx } from '../treasury/transactions';
+import Decimal from 'decimal.js';
+import { fromDecimal } from '../../utils/bigint-utils';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import { retrieveAdjustedPrice } from '../../utils/oracle-helpers';
+import { attachOracle } from '../iasset/helpers';
+import { OracleIdx } from '../price-oracle/types-new';
 
-export async function leverageCdpWithLrp(
+export async function leverageCdpWithRob(
   leverage: number,
   baseCollateral: bigint,
-  priceOracleOutRef: OutRef,
+  priceOracleOutRef: OutRef | undefined,
   iassetOutRef: OutRef,
   collateralAssetOutRef: OutRef,
   cdpCreatorOref: OutRef,
   interestOracleOref: OutRef,
-  collectorOref: OutRef,
+  treasuryOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   allRobs: [UTxO, RobDatum][],
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
@@ -112,14 +119,6 @@ export async function leverageCdpWithLrp(
     getInlineDatumOrThrow(interestOracleUtxo),
   );
 
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOutRef]),
-    (_) => new Error('Expected a single price oracle UTXO'),
-  );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
-  );
-
   const iassetUtxo = matchSingle(
     await lucid.utxosByOutRef([iassetOutRef]),
     (_) => new Error('Expected a single IAsset UTXO'),
@@ -136,14 +135,25 @@ export async function leverageCdpWithLrp(
     getInlineDatumOrThrow(collateralAssetUtxo),
   );
 
+  const [price, _] = await retrieveAdjustedPrice(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    collateralAssetDatum.extraDecimals,
+    priceOracleOutRef,
+    pythMessage,
+    sysParams.pythConfig,
+    lucid,
+  );
+
   const maxLeverage = calculateLeverageFromCollateralRatio(
     collateralAssetDatum.iasset,
+    collateralAssetDatum.collateralAsset,
     collateralAssetDatum.maintenanceRatio,
     baseCollateral,
-    priceOracleDatum.price,
-    iassetDatum.debtMintingFeePercentage,
-    iassetDatum.redemptionReimbursementPercentage,
-    sysParams.robParams,
+    price,
+    iassetDatum.debtMintingFeeRatio,
+    iassetDatum.redemptionReimbursementRatio,
     allRobs,
   );
 
@@ -154,8 +164,8 @@ export async function leverageCdpWithLrp(
   const leverageSummary = approximateLeverageRedemptions(
     baseCollateral,
     leverage,
-    iassetDatum.redemptionReimbursementPercentage,
-    iassetDatum.debtMintingFeePercentage,
+    iassetDatum.redemptionProcessingFeeRatio,
+    iassetDatum.debtMintingFeeRatio,
   );
 
   if (maxLeverage < leverageSummary.leverage) {
@@ -163,8 +173,8 @@ export async function leverageCdpWithLrp(
   }
 
   if (
-    leverageSummary.collateralRatio.getOnChainInt <
-    collateralAssetDatum.maintenanceRatio.getOnChainInt
+    rationalToFloat(leverageSummary.collateralRatio) <
+    rationalToFloat(collateralAssetDatum.maintenanceRatio)
   ) {
     throw new Error(
       "Can't have collateral ratio smaller than maintenance ratio",
@@ -172,83 +182,67 @@ export async function leverageCdpWithLrp(
   }
 
   const redemptionDetails = summarizeActualLeverageRedemptions(
-    leverageSummary.lovelacesForRedemptionWithReimbursement,
-    iassetDatum.redemptionReimbursementPercentage,
-    priceOracleDatum.price,
-    sysParams.robParams,
-    randomLrpsSubsetSatisfyingTargetLovelaces(
+    leverageSummary.redeemedCollateral,
+    iassetDatum.redemptionReimbursementRatio,
+    price,
+    randomRobsSubsetSatisfyingTargetCollateral(
       iassetDatum.assetName,
-      leverageSummary.lovelacesForRedemptionWithReimbursement,
-      priceOracleDatum.price,
+      collateralAssetDatum.collateralAsset,
+      leverageSummary.redeemedCollateral,
+      price,
       allRobs,
-      sysParams.robParams,
       MAX_REDEMPTIONS_WITH_CDP_OPEN,
     ),
   );
 
-  const mintedAmt = redemptionDetails.totalRedemptionIAssets;
+  // payout / (1 - debtMintingFee) = total minted amount
+  const mintedAmt = fromDecimal(
+    Decimal(redemptionDetails.totalIAssetPayout)
+      .div(
+        Decimal(1).minus(
+          Decimal(iassetDatum.debtMintingFeeRatio.numerator).div(
+            iassetDatum.debtMintingFeeRatio.denominator,
+          ),
+        ),
+      )
+      .floor(),
+  );
 
-  const debtMintingFee = calculateFeeFromPercentage(
-    iassetDatum.debtMintingFeePercentage,
-    ocdMul({ getOnChainInt: mintedAmt }, priceOracleDatum.price).getOnChainInt,
+  const debtMintingFee = calculateFeeFromRatio(
+    iassetDatum.debtMintingFeeRatio,
+    mintedAmt,
   );
 
   const collateralAmt =
-    redemptionDetails.totalRedeemedLovelaces + baseCollateral - debtMintingFee;
+    redemptionDetails.totalRedeemedCollateral + baseCollateral;
 
   const cdpNftVal = mkAssetsOf(
     fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
     1n,
   );
 
-  const iassetTokensVal = mkAssetsOf(
-    {
-      currencySymbol: fromHex(
-        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-      ),
-      tokenName: iassetDatum.assetName,
-    },
-    mintedAmt,
-  );
+  const iassetClass = {
+    currencySymbol: fromHex(
+      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+    ),
+    tokenName: iassetDatum.assetName,
+  };
 
-  const txValidity = oracleExpirationAwareValidity(
-    currentSlot,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expiration),
-    network,
-  );
+  const iassetTokensVal = mkAssetsOf(iassetClass, mintedAmt);
+
+  const refScripts = [
+    cdpCreatorRefScriptUtxo,
+    cdpAuthTokenPolicyRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+    robScriptRefUtxo,
+  ];
 
   const tx = lucid
     .newTx()
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    // Ref inputs
-    .readFrom([
-      priceOracleUtxo,
-      interestOracleUtxo,
-      iassetUtxo,
-      collateralAssetUtxo,
-    ])
     // Ref scripts
-    .readFrom([
-      cdpCreatorRefScriptUtxo,
-      cdpAuthTokenPolicyRefScriptUtxo,
-      iAssetTokenPolicyRefScriptUtxo,
-      robScriptRefUtxo,
-    ])
+    .readFrom(refScripts)
     .mintAssets(cdpNftVal, Data.void())
     .mintAssets(iassetTokensVal, Data.void())
-    .collectFrom(
-      [cdpCreatorUtxo],
-      serialiseCDPCreatorRedeemer({
-        CreateCDP: {
-          cdpOwner: fromHex(pkh.hash),
-          minted: mintedAmt,
-          collateral: collateralAmt,
-          currentTime: currentTime,
-        },
-      }),
-    )
     .pay.ToContract(
       createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
       {
@@ -256,6 +250,7 @@ export async function leverageCdpWithLrp(
         value: serialiseCdpDatum({
           cdpOwner: fromHex(pkh.hash),
           iasset: iassetDatum.assetName,
+          collateralAsset: collateralAssetDatum.collateralAsset,
           mintedAmt: mintedAmt,
           cdpFees: {
             ActiveCDPInterestTracking: {
@@ -269,31 +264,108 @@ export async function leverageCdpWithLrp(
           },
         }),
       },
-      addAssets(cdpNftVal, mkLovelacesOf(collateralAmt)),
+      addAssets(
+        cdpNftVal,
+        mkAssetsOf(collateralAssetDatum.collateralAsset, collateralAmt),
+      ),
     )
     .pay.ToContract(
       cdpCreatorUtxo.address,
-      { kind: 'inline', value: Data.void() },
+      {
+        kind: 'inline',
+        value: serialiseCDPCreatorDatum({
+          creatorInputOref: {
+            outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
+            txHash: fromHex(cdpCreatorUtxo.txHash),
+          },
+        }),
+      },
       cdpCreatorUtxo.assets,
-    )
-    .addSignerKey(pkh.hash);
+    );
+
+  const treasuryRefScriptUtxo =
+    debtMintingFee > 0n
+      ? await treasuryFeeTx(
+          iassetClass,
+          debtMintingFee,
+          0n,
+          lucid,
+          sysParams,
+          tx,
+          cdpCreatorUtxo,
+          treasuryOref,
+        )
+      : undefined;
+
+  const { interval, referenceInputs: refInputs } = await attachOracle(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    priceOracleOutRef,
+    pythStateOref,
+    pythMessage,
+    sysParams.pythConfig,
+    sysParams.cdpCreatorParams.biasTime,
+    currentSlot,
+    lucid,
+    tx,
+  );
+
+  const referenceInputs = [
+    interestOracleUtxo,
+    iassetUtxo,
+    collateralAssetUtxo,
+    ...refInputs,
+  ];
+
+  const refInputsIndices = getInputIndices(referenceInputs, [
+    ...referenceInputs,
+    ...refScripts,
+    ...(treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []),
+  ]);
+
+  const oracleIdx: OracleIdx =
+    priceOracleOutRef !== undefined
+      ? { OracleRefInputIdx: refInputsIndices[3] }
+      : 'OracleVoid';
+
+  tx.validFrom(interval.validFrom)
+    .validTo(interval.validTo)
+    .readFrom(referenceInputs)
+    .collectFrom([cdpCreatorUtxo], {
+      kind: 'self',
+      makeRedeemer: (inputIdx) => {
+        return serialiseCDPCreatorRedeemer({
+          CreateCDP: {
+            cdpOwner: fromHex(pkh.hash),
+            minted: mintedAmt,
+            collateralAmt: collateralAmt,
+            currentTime: currentTime,
+            creatorInputIdx: inputIdx,
+            creatorOutputIdx: 1n,
+            cdpOutputIdx: 0n,
+            iassetRefInputIdx: refInputsIndices[1],
+            collateralAssetRefInputIdx: refInputsIndices[2],
+            interestOracleRefInputIdx: refInputsIndices[0],
+            priceOracleIdx: oracleIdx,
+          },
+        });
+      },
+    });
 
   buildRedemptionsTx(
-    redemptionDetails.redemptions.map((r) => [
-      r.utxo,
-      r.iassetsForRedemptionAmt,
-    ]),
-    priceOracleDatum.price,
-    iassetDatum.redemptionReimbursementPercentage,
+    redemptionDetails.redemptions.map((r) => [r.utxo, r.iassetsPayoutAmt]),
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    price,
+    iassetDatum.redemptionReimbursementRatio,
     sysParams,
     tx,
-    2n,
+    2n + (debtMintingFee > 0n ? 1n : 0n),
+    refInputsIndices[2],
+    refInputsIndices[1],
+    oracleIdx,
   );
 
-  if (debtMintingFee > 0) {
-    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collectorOref);
-  }
-
   return tx;
 }
-*/

package/src/index.ts

@@ -6,8 +6,6 @@ export * from './contracts/cdp/scripts';
 export * from './contracts/cdp-creator/types';
 export * from './contracts/cdp-creator/scripts';
 export * from './contracts/poll/scripts';
-export * from './contracts/poll/types-poll-new';
-export * from './contracts/poll/helpers';
 export * from './contracts/collector/transactions';
 export * from './contracts/collector/types-new';
 export * from './contracts/gov/transactions';

package/src/utils/utils.ts

@@ -23,6 +23,3 @@ export function loadSystemParamsFromUrl(url: string): Promise<SystemParams> {
     .then((res: Response) => res.json())
     .then((data: unknown) => data as SystemParams);
 }
-
-export const getRandomElement = <T>(arr: T[]) =>
-  arr.length ? arr[Math.floor(Math.random() * arr.length)] : undefined;

package/tests/cdp/cdp-queries.ts

@@ -13,7 +13,6 @@ import {
   cdpCollateralRatioPercentage,
   createScriptAddress,
   fromSystemParamsAsset,
-  getRandomElement,
   matchSingle,
   SystemParams,
 } from '../../src';
@@ -29,6 +28,7 @@ import {
   AssetClass,
   assetClassToUnit,
   getInlineDatumOrThrow,
+  getRandomElement,
 } from '@3rd-eye-labs/cardano-offchain-common';
 import {
   InterestOracleDatum,

package/tests/endpoints/initialize.ts

@@ -47,8 +47,20 @@ export async function init(
   ) => InitialAssetParam[] = () => [],
   overrideProtocolParams: Partial<ProtocolParams> = {},
   initOptions: InitializeOptions = DEFAULT_INIT_OPTIONS,
-  spStakingCred?: ScriptCredential,
-  treasuryStakingCred?: ScriptCredential,
+  spStakingCred: ScriptCredential = {
+    tag: 'StakingHash',
+    contents: {
+      tag: 'ScriptCredential',
+      contents: 'b8358aadd30c60eba168608ad5e875592e9b7cb8c700827cde87f9a3',
+    },
+  },
+  treasuryStakingCred: ScriptCredential = {
+    tag: 'StakingHash',
+    contents: {
+      tag: 'ScriptCredential',
+      contents: 'b8358aadd30c60eba168608ad5e875592e9b7cb8c700827cde87f9a3',
+    },
+  },
 ): Promise<ReturnType<typeof initContract>> {
   const protocolParams: ProtocolParams = {
     ...protocolParamsMock,

package/tests/interest-collection/interest-collector-queries.ts

@@ -1,10 +1,11 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress, getRandomElement } from '../../src';
+import { createScriptAddress } from '../../src';
 import { option as O, function as F } from 'fp-ts';
 import {
   AssetClass,
   assetClassToUnit,
   assetClassValueOf,
+  getRandomElement,
   matchSingle,
 } from '@3rd-eye-labs/cardano-offchain-common';
 

package/tests/queries/collector-queries.ts

@@ -1,6 +1,7 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress, getRandomElement } from '../../src';
+import { createScriptAddress } from '../../src';
 import { option as O, function as F } from 'fp-ts';
+import { getRandomElement } from '@3rd-eye-labs/cardano-offchain-common';
 
 export async function findAllCollectors(
   lucid: LucidEvolution,

package/tests/queries/poll-queries.ts

@@ -1,10 +1,11 @@
 import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
 
-import { matchSingle, createScriptAddress, getRandomElement } from '../../src';
+import { matchSingle, createScriptAddress } from '../../src';
 import { option as O, array as A, function as F } from 'fp-ts';
 import {
   AssetClass,
   assetClassToUnit,
+  getRandomElement,
 } from '@3rd-eye-labs/cardano-offchain-common';
 import {
   parsePollManager,

package/tests/queries/treasury-queries.ts

@@ -1,9 +1,10 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { getRandomElement, SystemParams } from '../../src';
+import { SystemParams } from '../../src';
 import { option as O, function as F } from 'fp-ts';
 import {
   AssetClass,
   assetClassToUnit,
+  getRandomElement,
 } from '@3rd-eye-labs/cardano-offchain-common';
 
 export async function findRandomTreasuryUtxo(