@indigo-labs/indigo-sdk 0.3.9 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/contracts/cdp/helpers.ts

@@ -17,6 +17,18 @@ import {
   rationalSub,
 } from '../../types/rational';
 
+/**
+ * Amount of iasset equal in value to the given number of collateral amount.
+ */
+export function iassetValueOfCollateral(
+  collateralAmt: bigint,
+  oraclePrice: Rational,
+): bigint {
+  return rationalFloor(
+    rationalDiv(rationalFromInt(collateralAmt), oraclePrice),
+  );
+}
+
 /**
  * This is mostly for debugging purposes.
  */

package/src/contracts/gov/transactions.ts

@@ -252,11 +252,7 @@ export async function createProposal(
         ),
       )
       .validFrom(Number(currentTime) - ONE_SECOND)
-      .validTo(
-        Number(currentTime) +
-          Number(sysParams.govParams.gBiasTime) -
-          ONE_SECOND,
-      )
+      .validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND)
       .addSigner(ownAddr),
     newPollId,
   ];
@@ -325,9 +321,7 @@ export async function createShardsChunks(
     .newTx()
     .validFrom(Number(currentTime) - ONE_SECOND)
     .validTo(
-      Number(currentTime) +
-        Number(sysParams.pollManagerParams.pBiasTime) -
-        ONE_SECOND,
+      Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
     )
     .mintAssets(mkAssetsOf(pollNft, shardsCount), Data.void())
     // Ref scripts
@@ -580,9 +574,7 @@ export async function mergeShards(
     .newTx()
     .validFrom(Number(currentTime) - ONE_SECOND)
     .validTo(
-      Number(currentTime) +
-        Number(sysParams.pollManagerParams.pBiasTime) -
-        ONE_SECOND,
+      Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
     )
     .readFrom([
       pollShardRefScriptUtxo,
@@ -1561,9 +1553,7 @@ export async function executeProposal(
 
   tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo])
     .validFrom(Number(currentTime) - ONE_SECOND)
-    .validTo(
-      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND,
-    )
+    .validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND)
     .collectFrom([executeUtxo], Data.void())
     .mintAssets(
       mkAssetsOf(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),

package/src/contracts/iasset/helpers.ts

@@ -95,6 +95,7 @@ export function attachOracle(
     .with(
       { DeferredValidation: { feedValHash: P.select() } },
       async (feedValHash) => {
+        if (priceOracleOref) throw new Error('Cannot pass price oracle oref');
         if (!pythMessage) throw new Error('Missing Pyth message');
         if (!pythStateOref) throw new Error('Missing pyth state out ref');
 

package/src/contracts/price-oracle/types-new.ts

@@ -20,7 +20,7 @@ export const OracleIdxSchema = TSchema.Union(
   TSchema.Literal('OracleVoid', { flatInUnion: true }),
 );
 
-export type OracleIdx = typeof OracleIdxSchema;
+export type OracleIdx = typeof OracleIdxSchema.Type;
 
 const PriceOracleDatumSchema = TSchema.Struct({
   price: RationalSchema,

package/src/contracts/rob/helpers.ts

@@ -13,14 +13,15 @@ import {
   serialiseRobRedeemer,
 } from './types-new';
 import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
-import { zeroNegatives } from '../../utils/bigint-utils';
+import { BigIntOrd, sum, zeroNegatives } from '../../utils/bigint-utils';
 import {
   readonlyArray as RA,
   array as A,
   function as F,
   option as O,
+  ord as Ord,
 } from 'fp-ts';
-import { SystemParams } from '../../types/system-params';
+import { CurrencySymbolSP, SystemParams } from '../../types/system-params';
 import { match, P } from 'ts-pattern';
 import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
 import {
@@ -33,19 +34,22 @@ import {
 } from '@3rd-eye-labs/cardano-offchain-common';
 import {
   Rational,
-  rationalDiv,
   rationalFloor,
   rationalFromInt,
   rationalMul,
+  rationalToFloat,
 } from '../../types/rational';
+import { insertSorted, shuffle } from '../../utils/array-utils';
+import { iassetValueOfCollateral } from '../cdp/helpers';
+import { OracleIdx } from '../price-oracle/types-new';
 
 export const MIN_ROB_COLLATERAL_AMT = 3_000_000n;
 
-export function robAmountToSpend(
-  utxo: UTxO,
-  datum: RobDatum,
-  sysParams: SystemParams,
-): bigint {
+/**
+ * The amount of collateral asset available in the ROB when buy order. In case of ADA, take
+ * into account the min UTXO collateral.
+ */
+export function robCollateralAmtToSpend(utxo: UTxO, datum: RobDatum): bigint {
   return match(datum.orderType)
     .returnType<bigint>()
     .with({ BuyIAssetOrder: P.select() }, (content) => {
@@ -57,55 +61,118 @@ export function robAmountToSpend(
         return assetClassValueOf(utxo.assets, content.collateralAsset);
       }
     })
+    .otherwise(() => {
+      throw new Error('Collateral to spend is relevant only for Buy orders.');
+    });
+}
+
+/**
+ * The amount if iassets available in ROB when sell order.
+ */
+export function robIAssetAmtToSpend(
+  utxo: UTxO,
+  datum: RobDatum,
+  iassetCurrencySymbol: CurrencySymbolSP,
+) {
+  return match(datum.orderType)
+    .returnType<bigint>()
     .with({ SellIAssetOrder: P.any }, (_) => {
       return assetClassValueOf(utxo.assets, {
-        currencySymbol: fromHex(
-          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-        ),
+        currencySymbol: fromHex(iassetCurrencySymbol.unCurrencySymbol),
         tokenName: datum.iasset,
       });
     })
+    .otherwise(() => {
+      throw new Error('IAssets to spend is relevant only for Sell orders.');
+    });
+}
+
+/**
+ * Amount to spend from the ROB universal for Buy and sell orders.
+ */
+export function robAmtToSpend(
+  utxo: UTxO,
+  datum: RobDatum,
+  iassetCurrencySymbol: CurrencySymbolSP,
+): bigint {
+  return match(datum.orderType)
+    .with({ BuyIAssetOrder: P.any }, () => robCollateralAmtToSpend(utxo, datum))
+    .with({ SellIAssetOrder: P.any }, () =>
+      robIAssetAmtToSpend(utxo, datum, iassetCurrencySymbol),
+    )
     .exhaustive();
 }
 
-export function isFullyRedeemed(
+export function robBuyOrderSummary(
   utxo: UTxO,
   datum: RobDatum,
-  sysParams: SystemParams,
+  oraclePrice: Rational,
+): {
+  /**
+   * The amount that can be spent from the ROB.
+   */
+  redeemableCollateral: bigint;
+  /**
+   * The amount paid to the ROB when everything redeemed.
+   */
+  payoutIAsset: bigint;
+} {
+  const redeemable = robCollateralAmtToSpend(utxo, datum);
+
+  const payoutAmt = iassetValueOfCollateral(redeemable, oraclePrice);
+
+  return {
+    redeemableCollateral: redeemable,
+    payoutIAsset: payoutAmt,
+  };
+}
+
+/**
+ * In case it's applied to a sell order instead, it will throw an error.
+ */
+export function isBuyOrderFullyRedeemed(
+  utxo: UTxO,
+  datum: RobDatum,
+  oraclePrice: Rational,
 ): boolean {
-  // TODO: or when the price doesn't allow single token redemption
-  return robAmountToSpend(utxo, datum, sysParams) === 0n;
+  const summary = robBuyOrderSummary(utxo, datum, oraclePrice);
+
+  return summary.redeemableCollateral <= 0n || summary.payoutIAsset <= 0n;
 }
 
-// /**
-//  * Calculate the actually redeemable lovelaces taking into account:
-//  *  - LRP datum
-//  *  - UTXO's value
-//  *  - min redemption
-//  *
-//  * This helps to handle incorrectly initialised LRPs, too.
-//  */
-// export function lrpRedeemableLovelacesInclReimb(
-//   lrp: [UTxO, RobDatum],
-//   lrpParams: RobParamsSP,
-// ): bigint {
-//   const datum = lrp[1];
-//   const utxo = lrp[0];
-
-//   let res = 0n;
-//   // When incorrectly initialised
-//   if (datum.lovelacesToSpend > lovelacesAmt(utxo.assets)) {
-//     res = bigintMax(lovelacesAmt(utxo.assets) - MIN_ROB_COLLATERAL_AMT, 0n);
-//   } else {
-//     res = datum.lovelacesToSpend;
-//   }
-
-//   if (res < lrpParams.minRedemptionLovelacesAmt) {
-//     return 0n;
-//   }
-
-//   return res;
-// }
+/**
+ * Use the limit prices to decide fully redeemed.
+ */
+export function isFullyRedeemed(
+  utxo: UTxO,
+  datum: RobDatum,
+  iassetCurrencySymbol: CurrencySymbolSP,
+): boolean {
+  return match(datum.orderType)
+    .returnType<boolean>()
+    .with({ BuyIAssetOrder: P.select() }, (content) =>
+      isBuyOrderFullyRedeemed(utxo, datum, content.maxPrice),
+    )
+
+    .with({ SellIAssetOrder: P.select() }, (content) => {
+      const iassetToSpend = robIAssetAmtToSpend(
+        utxo,
+        datum,
+        iassetCurrencySymbol,
+      );
+
+      const payoutAmts = content.allowedCollateralAssets.map((c) =>
+        rationalFloor(rationalMul(rationalFromInt(iassetToSpend), c[1])),
+      );
+
+      return (
+        iassetToSpend <= 0n ||
+        // When for every allowed collateral asset the payout would be 0
+        payoutAmts.every((amt) => amt <= 0n)
+      );
+    })
+    .exhaustive();
+}
 
 /**
  * Right now we allow multi redemptions when the collateral asset, iasset pair is the same.
@@ -129,13 +196,13 @@ export function buildRedemptionsTx(
   txOutputsBeforeCount: bigint,
   collateralAssetRefInputIdx: bigint,
   iassetRefInputIdx: bigint,
-  oracleIdx: bigint | null,
+  oracleIdx: OracleIdx,
 ): TxBuilder {
   return F.pipe(
     redemptions,
     A.reduceWithIndex<[UTxO, bigint], TxBuilder>(
       tx,
-      (idx, acc, [robUtxo, spendAmt]) => {
+      (idx, acc, [robUtxo, payoutAmt]) => {
         const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
 
         if (toHex(robDatum.iasset) !== toHex(iasset)) {
@@ -151,7 +218,7 @@ export function buildRedemptionsTx(
               throw new Error('Only same collateral asset');
             }
 
-            const payoutIAssetAmt = spendAmt;
+            const payoutIAssetAmt = payoutAmt;
 
             const reimburstmentIAsset = calculateFeeFromRatio(
               redemptionReimbursementRatio,
@@ -192,18 +259,16 @@ export function buildRedemptionsTx(
               }),
             );
 
-            const payoutCollateralAmt = spendAmt;
+            const payoutCollateralAmt = payoutAmt;
 
             const reimbursementCollateral = calculateFeeFromRatio(
               redemptionReimbursementRatio,
               payoutCollateralAmt,
             );
 
-            const redeemedIAssetAmt = rationalFloor(
-              rationalDiv(
-                rationalFromInt(payoutCollateralAmt - reimbursementCollateral),
-                price,
-              ),
+            const redeemedIAssetAmt = iassetValueOfCollateral(
+              payoutCollateralAmt - reimbursementCollateral,
+              price,
             );
 
             const resultVal = addAssets(
@@ -225,7 +290,9 @@ export function buildRedemptionsTx(
           .exhaustive();
 
         if (lovelacesAmt(robOutputVal) < MIN_ROB_COLLATERAL_AMT) {
-          throw new Error('ROB was incorrectly initialised.');
+          throw new Error(
+            'Redeeming more than available or selected ROB was incorrectly initialised.',
+          );
         }
 
         return acc
@@ -239,10 +306,7 @@ export function buildRedemptionsTx(
                   iassetRefInputIdx: iassetRefInputIdx,
                   continuingOutputIdx: txOutputsBeforeCount + BigInt(idx),
                   sellOrderAllowedAssetsIdx: sellOrderAllowedAssetsIdx,
-                  priceOracleIdx:
-                    oracleIdx != null
-                      ? { OracleRefInputIdx: oracleIdx }
-                      : 'OracleVoid',
+                  priceOracleIdx: oracleIdx,
                 },
               }),
           })
@@ -265,141 +329,155 @@ export function buildRedemptionsTx(
   );
 }
 
-// /**
-//  * Given all available LRP UTXOs, calculate total available ADA that can be redeemed (including reimbursement fee).
-//  * Taking into account ncorrectly initialised LRPs (without base collateral).
-//  */
-// export function calculateTotalAdaForRedemption(
-//   iasset: Uint8Array<ArrayBufferLike>,
-//   iassetPrice: OnChainDecimal,
-//   lrpParams: RobParamsSP,
-//   allLrps: [UTxO, RobDatum][],
-//   /**
-//    * How many LRPs can be redeemed in a single Tx.
-//    */
-//   maxLrpsInTx: number,
-// ): bigint {
-//   return F.pipe(
-//     allLrps,
-//     A.filterMap(([utxo, datum]) => {
-//       if (
-//         toHex(datum.iasset) !== toHex(iasset) ||
-//         datum.maxPrice.getOnChainInt < iassetPrice.getOnChainInt
-//       ) {
-//         return O.none;
-//       }
-
-//       const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
-//         [utxo, datum],
-//         lrpParams,
-//       );
-
-//       if (lovelacesToSpend === 0n) {
-//         return O.none;
-//       }
-
-//       // Subtract the reimbursement fee here on each iteration to simulate real redemptions.
-//       return O.some(lovelacesToSpend);
-//     }),
-//     // From largest to smallest
-//     A.sort(Ord.reverse(BigIntOrd)),
-//     // We can fit only this number of redemptions with CDP open into a single Tx.
-//     A.takeLeft(maxLrpsInTx),
-//     sum,
-//   );
-// }
-
-// export function randomLrpsSubsetSatisfyingTargetLovelaces(
-//   iasset: Uint8Array<ArrayBufferLike>,
-//   // Including the reimbursement percentage
-//   targetLovelacesToSpend: bigint,
-//   iassetPrice: OnChainDecimal,
-//   allLrps: [UTxO, RobDatum][],
-//   lrpParams: RobParamsSP,
-//   /**
-//    * How many LRPs can be redeemed in a single Tx.
-//    */
-//   maxLrpsInTx: number,
-//   randomiseFn: (arr: [UTxO, RobDatum][]) => [UTxO, RobDatum][] = shuffle,
-// ): [UTxO, RobDatum][] {
-//   if (targetLovelacesToSpend < lrpParams.minRedemptionLovelacesAmt) {
-//     throw new Error("Can't redeem less than the minimum.");
-//   }
-
-//   const shuffled = randomiseFn(
-//     F.pipe(
-//       allLrps,
-//       A.filter(
-//         ([_, datum]) =>
-//           toHex(datum.iasset) === toHex(iasset) &&
-//           datum.maxPrice.getOnChainInt >= iassetPrice.getOnChainInt,
-//       ),
-//     ),
-//   );
-
-//   // Sorted from highest to lowest by lovelaces to spend
-//   let result: [UTxO, RobDatum][] = [];
-//   let runningSum = 0n;
-
-//   for (let i = 0; i < shuffled.length; i++) {
-//     const element = shuffled[i];
-
-//     const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
-//       element,
-//       lrpParams,
-//     );
-
-//     // Do not add LRPs with smaller lovelacesToSpend than the minRedemption
-//     // to the random subset.
-//     if (lovelacesToSpend < lrpParams.minRedemptionLovelacesAmt) {
-//       continue;
-//     }
-
-//     // When we can't add a new redemption because otherwise the min redemption
-//     // wouldn't be satisfied.
-//     // Try to replace the smallest collected with a following larger one when available.
-//     if (
-//       result.length > 0 &&
-//       targetLovelacesToSpend - runningSum < lrpParams.minRedemptionLovelacesAmt
-//     ) {
-//       const last = result[result.length - 1];
-
-//       // Pop the smallest collected when the current is larger.
-//       if (lrpRedeemableLovelacesInclReimb(last, lrpParams) < lovelacesToSpend) {
-//         const popped = result.pop()!;
-//         runningSum -= lrpRedeemableLovelacesInclReimb(popped, lrpParams);
-//       } else {
-//         continue;
-//       }
-//     }
-
-//     result = insertSorted(
-//       result,
-//       element,
-//       Ord.contramap<bigint, [UTxO, RobDatum]>(
-//         ([_, dat]) => dat.lovelacesToSpend,
-//         // From highest to lowest
-//       )(Ord.reverse(BigIntOrd)),
-//     );
-//     runningSum += lovelacesToSpend;
-
-//     // When more items than max allowed, pop the one with smallest value
-//     if (result.length > maxLrpsInTx) {
-//       const popped = result.pop()!;
-//       runningSum -= lrpRedeemableLovelacesInclReimb(popped, lrpParams);
-//     }
-
-//     if (runningSum >= targetLovelacesToSpend) {
-//       return result;
-//     }
-//   }
-
-//   if (
-//     targetLovelacesToSpend - runningSum >=
-//     lrpParams.minRedemptionLovelacesAmt
-//   ) {
-//     throw new Error("Couldn't achieve target lovelaces");
-//   }
-
-//   return result;
-// }
+/**
+ * Given all available LRP UTXOs, calculate total available collateral that can be redeemed.
+ * Taking into account incorrectly initialised LRPs (without base collateral) and max number of ROBs.
+ */
+export function calculateTotalCollateralForRedemption(
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+  iassetPrice: Rational,
+  allRobs: [UTxO, RobDatum][],
+  /**
+   * How many LRPs can be redeemed in a single Tx.
+   */
+  maxRobsInTx: number,
+): bigint {
+  return F.pipe(
+    allRobs,
+    A.filterMap(([utxo, datum]) => {
+      const isCorrectOrder = match(datum.orderType)
+        .returnType<boolean>()
+        .with(
+          { BuyIAssetOrder: P.select() },
+          (content) =>
+            isSameAssetClass(content.collateralAsset, collateralAsset) &&
+            rationalToFloat(content.maxPrice) >= rationalToFloat(iassetPrice) &&
+            !isBuyOrderFullyRedeemed(utxo, datum, iassetPrice),
+        )
+        .otherwise(() => false);
+
+      if (toHex(datum.iasset) !== toHex(iasset) || !isCorrectOrder) {
+        return O.none;
+      }
+
+      // We constrained in the logic above that the ROB is a buy order and is not yet fully redeemed.
+      const collateralToSpend = robCollateralAmtToSpend(utxo, datum);
+
+      return O.some(collateralToSpend);
+    }),
+    // From largest to smallest
+    A.sort(Ord.reverse(BigIntOrd)),
+    // We can fit only this number of redemptions with CDP open into a single Tx.
+    A.takeLeft(maxRobsInTx),
+    sum,
+  );
+}
+
+/**
+ * Pick random subset from all the ROBs (it does the necessary filtering) satisfying the target collateral to spend.
+ * It's relevant for BUY orders only.
+ */
+export function randomRobsSubsetSatisfyingTargetCollateral(
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+  targetCollateralToSpend: bigint,
+  iassetPrice: Rational,
+  allLrps: [UTxO, RobDatum][],
+  /**
+   * How many LRPs can be redeemed in a single Tx.
+   */
+  maxLrpsInTx: number,
+  randomiseFn: (arr: [UTxO, RobDatum][]) => [UTxO, RobDatum][] = shuffle,
+): [UTxO, RobDatum][] {
+  if (
+    targetCollateralToSpend <= 0n ||
+    iassetValueOfCollateral(targetCollateralToSpend, iassetPrice) <= 0n
+  ) {
+    throw new Error('Must redeem and payout more than 0.');
+  }
+
+  const shuffled = randomiseFn(
+    F.pipe(
+      allLrps,
+      A.filter(
+        ([utxo, datum]) =>
+          toHex(datum.iasset) === toHex(iasset) &&
+          match(datum.orderType)
+            .with(
+              { BuyIAssetOrder: P.select() },
+              (content) =>
+                isSameAssetClass(collateralAsset, content.collateralAsset) &&
+                rationalToFloat(content.maxPrice) >=
+                  rationalToFloat(iassetPrice),
+            )
+            // Only buy order types
+            .otherwise(() => false) &&
+          !isBuyOrderFullyRedeemed(utxo, datum, iassetPrice),
+      ),
+    ),
+  );
+
+  // Sorted from highest to lowest by lovelaces to spend
+  let result: [UTxO, RobDatum][] = [];
+  let runningSum = 0n;
+
+  for (let i = 0; i < shuffled.length; i++) {
+    const element = shuffled[i];
+
+    const lovelacesToSpend = robCollateralAmtToSpend(element[0], element[1]);
+
+    const remainingToRedeem = targetCollateralToSpend - runningSum;
+    const remainingToPayout = iassetValueOfCollateral(
+      remainingToRedeem,
+      iassetPrice,
+    );
+
+    // When we can't add a new redemption because otherwise there would be no payout.
+    // Try to replace the smallest collected with a following larger one when available.
+    if (result.length > 0 && remainingToPayout <= 0n) {
+      const last = result[result.length - 1];
+
+      const lastSummary = robBuyOrderSummary(last[0], last[1], iassetPrice);
+
+      // Pop the smallest collected when the current is larger.
+      if (lastSummary.redeemableCollateral < lovelacesToSpend) {
+        result.pop()!;
+        runningSum -= lastSummary.redeemableCollateral;
+      } else {
+        continue;
+      }
+    }
+
+    result = insertSorted(
+      result,
+      element,
+      Ord.contramap<bigint, [UTxO, RobDatum]>(
+        ([utxo, dat]) => robCollateralAmtToSpend(utxo, dat),
+        // From highest to lowest
+      )(Ord.reverse(BigIntOrd)),
+    );
+    runningSum += lovelacesToSpend;
+
+    // When more items than max allowed, pop the one with smallest value
+    if (result.length > maxLrpsInTx) {
+      const popped = result.pop()!;
+      runningSum -= robCollateralAmtToSpend(popped[0], popped[1]);
+    }
+
+    if (runningSum >= targetCollateralToSpend) {
+      return result;
+    }
+  }
+
+  const remainingToSpend = targetCollateralToSpend - runningSum;
+
+  if (
+    remainingToSpend > 0n &&
+    iassetValueOfCollateral(remainingToSpend, iassetPrice) > 0n
+  ) {
+    throw new Error("Couldn't achieve target lovelaces");
+  }
+
+  return result;
+}