@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/src/contracts/execute/scripts.ts

@@ -6,7 +6,7 @@ import {
 import { castExecuteParams, ExecuteParams } from './types';
 import {
   ExecuteParamsSP,
-  fromSystemParamsAsset,
+  fromSystemParamsAssetLucid,
 } from '../../types/system-params';
 import { _executeValidator } from '../../validators/execute-validator';
 
@@ -14,7 +14,7 @@ export const mkExecuteValidator = (
   params: ExecuteParams,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applySingleCborEncoding(
       applyParamsToScript(_executeValidator.cborHex, [
         castExecuteParams(params),
@@ -27,21 +27,30 @@ export const mkExecuteValidatorFromSP = (
   params: ExecuteParamsSP,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applySingleCborEncoding(
       applyParamsToScript(_executeValidator.cborHex, [
         castExecuteParams({
-          govNFT: fromSystemParamsAsset(params.govNFT),
-          upgradeToken: fromSystemParamsAsset(params.upgradeToken),
-          iAssetToken: fromSystemParamsAsset(params.iAssetToken),
-          stabilityPoolToken: fromSystemParamsAsset(params.stabilityPoolToken),
-          versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
+          govNFT: fromSystemParamsAssetLucid(params.govNFT),
+          upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
+          iAssetToken: fromSystemParamsAssetLucid(params.iAssetToken),
+          collateralAssetToken: fromSystemParamsAssetLucid(
+            params.collateralAssetToken,
+          ),
+          stabilityPoolToken: fromSystemParamsAssetLucid(
+            params.stabilityPoolToken,
+          ),
+          cdpCreatorToken: fromSystemParamsAssetLucid(params.cdpCreatorToken),
+          cdpToken: fromSystemParamsAssetLucid(params.cdpToken),
+          versionRecordToken: fromSystemParamsAssetLucid(
+            params.versionRecordToken,
+          ),
+          iassetValHash: params.iassetValHash,
           cdpValHash: params.cdpValHash,
           sPoolValHash: params.sPoolValHash,
           versionRegistryValHash: params.versionRegistryValHash,
           treasuryValHash: params.treasuryValHash,
-          indyAsset: fromSystemParamsAsset(params.indyAsset),
-        } as ExecuteParams),
+        }),
       ]),
     ),
   };

package/src/contracts/execute/types-new.ts

@@ -0,0 +1,44 @@
+import { option as O, function as F } from 'fp-ts';
+import { TSchema, Data } from '@evolution-sdk/evolution';
+import {
+  ProposalContentSchema,
+  TreasuryWithdrawalSchema,
+} from '../gov/types-new';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+
+const ExecuteDatumSchema = TSchema.Struct({
+  id: TSchema.Integer,
+  content: ProposalContentSchema,
+  passedTime: TSchema.Integer,
+  votingEndTime: TSchema.Integer,
+  protocolVersion: TSchema.Integer,
+  /// Value proposed to be withdrawn from the treasury as part of the proposal.
+  treasuryWithdrawal: TSchema.NullOr(TreasuryWithdrawalSchema),
+});
+
+export type ExecuteDatum = typeof ExecuteDatumSchema.Type;
+
+export function serialiseExecuteDatum(d: ExecuteDatum): string {
+  return Data.withSchema(ExecuteDatumSchema).toCBORHex(d);
+}
+
+export function parseExecuteDatum(datum: string): O.Option<ExecuteDatum> {
+  try {
+    return O.some(
+      Data.withSchema(ExecuteDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum,
+      ),
+    );
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseExecuteDatumOrThrow(datum: string): ExecuteDatum {
+  return F.pipe(
+    parseExecuteDatum(datum),
+    O.match(() => {
+      throw new Error('Expected an Execute datum.');
+    }, F.identity),
+  );
+}

package/src/contracts/execute/types.ts

@@ -1,57 +1,24 @@
-import { Data, Datum } from '@lucid-evolution/lucid';
+import { Data } from '@lucid-evolution/lucid';
 import { AssetClassSchema } from '../../types/generic';
-import { TreasuryWithdrawalSchema } from '../gov/types';
-import { option as O, function as F } from 'fp-ts';
-import { ProposalContentSchema } from '../gov/types-new';
 
 const ExecuteParamsSchema = Data.Object({
   govNFT: AssetClassSchema,
   upgradeToken: AssetClassSchema,
   iAssetToken: AssetClassSchema,
+  collateralAssetToken: AssetClassSchema,
   stabilityPoolToken: AssetClassSchema,
+  cdpCreatorToken: AssetClassSchema,
+  cdpToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
+  iassetValHash: Data.Bytes(),
   cdpValHash: Data.Bytes(),
   sPoolValHash: Data.Bytes(),
   versionRegistryValHash: Data.Bytes(),
   treasuryValHash: Data.Bytes(),
-  indyAsset: AssetClassSchema,
 });
 export type ExecuteParams = Data.Static<typeof ExecuteParamsSchema>;
 export const ExecuteParams = ExecuteParamsSchema as unknown as ExecuteParams;
 
-const ExecuteDatumSchema = Data.Object({
-  id: Data.Integer(),
-  content: ProposalContentSchema,
-  passedTime: Data.Integer(),
-  votingEndTime: Data.Integer(),
-  protocolVersion: Data.Integer(),
-  /// Value proposed to be withdrawn from the treasury as part of the proposal.
-  treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
-});
-export type ExecuteDatum = Data.Static<typeof ExecuteDatumSchema>;
-export const ExecuteDatum = ExecuteDatumSchema as unknown as ExecuteDatum;
-
-export function serialiseExecuteDatum(d: ExecuteDatum): Datum {
-  return Data.to<ExecuteDatum>(d, ExecuteDatum);
-}
-
-export function parseExecuteDatum(d: Datum): O.Option<ExecuteDatum> {
-  try {
-    return O.some(Data.from<ExecuteDatum>(d, ExecuteDatum));
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseExecuteDatumOrThrow(d: Datum): ExecuteDatum {
-  return F.pipe(
-    parseExecuteDatum(d),
-    O.match(() => {
-      throw new Error('Expected an Execute datum.');
-    }, F.identity),
-  );
-}
-
 export function castExecuteParams(params: ExecuteParams): Data {
   return Data.castTo(params, ExecuteParams);
 }

package/src/contracts/gov/helpers.ts

@@ -6,23 +6,33 @@ import {
   ord as Ord,
   function as F,
 } from 'fp-ts';
-import { TreasuryWithdrawal, TreasuryWithdrawalItem } from './types';
 import {
   addAssets,
   Assets,
   LucidEvolution,
   OutRef,
+  toHex,
   toText,
+  UTxO,
 } from '@lucid-evolution/lucid';
-import { mkAssetsOf } from '../../utils/value-helpers';
+import { matchSingle } from '../../utils/utils';
+import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
 import {
+  AddCollateralAsssetContent,
+  ProposeAssetContent,
+  TreasuryWithdrawal,
+  TreasuryWithdrawalItem,
+} from './types-new';
+import { AssetClass, mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  CollateralAssetContent,
+  CollateralAssetOutput,
   IAssetContent,
   IAssetOutput,
+  parseCollateralAssetDatumOrThrow,
   parseIAssetDatumOrThrow,
-} from '../cdp/types';
-import { ProposeAssetContent } from './types-new';
-import { matchSingle } from '../../utils/utils';
-import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
+} from '../iasset/types';
+import { getAssetClassComparisonStr, ParsedOutput } from '../../types/generic';
 
 export function proposalDeposit(
   baseDeposit: bigint,
@@ -32,100 +42,159 @@ export function proposalDeposit(
 }
 
 export function createValueFromWithdrawal(w: TreasuryWithdrawal): Assets {
-  return A.reduce<TreasuryWithdrawalItem, Assets>({}, (acc, [cs, tk, amt]) =>
-    addAssets(acc, mkAssetsOf({ currencySymbol: cs, tokenName: tk }, amt)),
-  )(w.value);
+  return A.reduce<TreasuryWithdrawalItem, Assets>({}, (acc, item) =>
+    addAssets(
+      acc,
+      mkAssetsOf(
+        {
+          currencySymbol: item.currencySymbol,
+          tokenName: item.tokenName,
+        },
+        item.amount,
+      ),
+    ),
+  )([...w.value]);
 }
 
 /**
- * Find the IAsset that should be a preceding one for the new IAsset token name.
- * In case there are no iassets, none should be returned.
+ * A generic solution for iassets and collateral assets chain.
  */
-export async function findRelativeIAssetForInsertion(
-  /**
-   * UFT encoded
-   */
-  newIAssetTokenName: string,
+async function findRelativeAssetForInsertion<
+  T extends Uint8Array<ArrayBufferLike> | AssetClass,
+  K,
+>(
+  newAsset: T,
   allIAssetOrefs: OutRef[],
   lucid: LucidEvolution,
-): Promise<O.Option<IAssetOutput>> {
-  const iassetUtxos = await Promise.all(
+  assetOrd: Ord.Ord<T>,
+  getComparisonAsset: (datum: K) => T,
+  parseDatum: (utxo: UTxO) => K,
+): Promise<O.Option<ParsedOutput<K>>> {
+  const parsedUtxos = await Promise.all(
     allIAssetOrefs.map(async (oref) => {
-      const iassetUtxo = matchSingle(
+      const utxo = matchSingle(
         await lucid.utxosByOutRef([oref]),
-        (_) => new Error('Expected a single IAsset UTXO'),
+        (_) => new Error('Expected a single UTXO'),
       );
 
-      const datum = parseIAssetDatumOrThrow(getInlineDatumOrThrow(iassetUtxo));
+      const datum = parseDatum(utxo);
 
-      return { datum: datum, utxo: iassetUtxo };
+      return { datum: datum, utxo: utxo };
     }),
   );
 
   // The iasset just before the new token name based on assets ordering
   return pipe(
-    // Sort the asset names
-    iassetUtxos,
+    parsedUtxos,
+    // Sort by the asset names
     A.sort(
-      Ord.contramap<string, IAssetOutput>((x) => toText(x.datum.assetName))(
-        S.Ord,
+      Ord.contramap<T, ParsedOutput<K>>((a) => getComparisonAsset(a.datum))(
+        assetOrd,
       ),
     ),
     // split head and tail
     A.foldLeft(
       () => O.none,
-      (head, rest) => O.some<[IAssetOutput, IAssetOutput[]]>([head, rest]),
+      (head, rest) =>
+        O.some<[ParsedOutput<K>, ParsedOutput<K>[]]>([head, rest]),
     ),
     // find the preceding iasset for the new token name
     O.flatMap(([firstIAsset, rest]) =>
       O.some(
-        A.reduce<IAssetOutput, IAssetOutput>(firstIAsset, (acc, iasset) =>
-          toText(iasset.datum.assetName) < newIAssetTokenName ? iasset : acc,
+        A.reduce<ParsedOutput<K>, ParsedOutput<K>>(
+          firstIAsset,
+          (acc, iasset) => {
+            const isGreater =
+              assetOrd.compare(getComparisonAsset(iasset.datum), newAsset) ===
+              -1;
+
+            // When the new asset is greater, stop searching for the reference.
+            return isGreater ? iasset : acc;
+          },
         )(rest),
       ),
     ),
   );
 }
 
+/**
+ * Find the IAsset that should be a preceding one for the new IAsset token name.
+ * In case there are no iassets, none should be returned.
+ */
+export async function findRelativeIAssetForInsertion(
+  newIAssetTokenName: Uint8Array<ArrayBufferLike>,
+  allIAssetOrefs: OutRef[],
+  lucid: LucidEvolution,
+): Promise<O.Option<IAssetOutput>> {
+  return findRelativeAssetForInsertion(
+    newIAssetTokenName,
+    allIAssetOrefs,
+    lucid,
+    Ord.contramap<string, Uint8Array<ArrayBufferLike>>((x) => toText(toHex(x)))(
+      S.Ord,
+    ),
+    (d) => d.assetName,
+    (utxo) => parseIAssetDatumOrThrow(getInlineDatumOrThrow(utxo)),
+  );
+}
+
+/**
+ * Find collateral asset that should be a preceding one for the new Collateral asset.
+ * In case there are no collateral assets, none should be returned.
+ */
+export async function findRelativeCollateralAssetForInsertion(
+  newCollateralAsset: AssetClass,
+  allCollateralAssetOrefs: OutRef[],
+  lucid: LucidEvolution,
+): Promise<O.Option<CollateralAssetOutput>> {
+  return findRelativeAssetForInsertion(
+    newCollateralAsset,
+    allCollateralAssetOrefs,
+    lucid,
+    Ord.contramap<string, AssetClass>((x) => getAssetClassComparisonStr(x))(
+      S.Ord,
+    ),
+    (d) => d.collateralAsset,
+    (utxo) => parseCollateralAssetDatumOrThrow(getInlineDatumOrThrow(utxo)),
+  );
+}
+
+type IAssetCreationDatumHelperReturnType = {
+  newIAsset: IAssetContent;
+  newReferencedIAsset: O.Option<IAssetContent>;
+};
+
 export function iassetCreationDatumHelper(
   proposeAssetContent: ProposeAssetContent,
   referencedIAsset: O.Option<IAssetContent>,
-): { newIAsset: IAssetContent; newReferencedIAsset: O.Option<IAssetContent> } {
+): IAssetCreationDatumHelperReturnType {
   const newContent: IAssetContent = {
     assetName: proposeAssetContent.asset,
-    price: { Oracle: { content: proposeAssetContent.priceOracleNft } },
-    interestOracleNft: proposeAssetContent.interestOracleNft,
-    redemptionRatio: proposeAssetContent.redemptionRatioPercentage,
-    maintenanceRatio: proposeAssetContent.maintenanceRatioPercentage,
-    liquidationRatio: proposeAssetContent.liquidationRatioPercentage,
-    debtMintingFeePercentage: proposeAssetContent.debtMintingFeePercentage,
-    liquidationProcessingFeePercentage:
-      proposeAssetContent.liquidationProcessingFeePercentage,
-    stabilityPoolWithdrawalFeePercentage:
-      proposeAssetContent.stabilityPoolWithdrawalFeePercentage,
-    redemptionReimbursementPercentage:
-      proposeAssetContent.redemptionReimbursementPercentage,
-    redemptionProcessingFeePercentage:
-      proposeAssetContent.redemptionProcessingFeePercentage,
-    interestCollectorPortionPercentage:
-      proposeAssetContent.interestCollectorPortionPercentage,
+    collateralAssetsCount: 0n,
+    debtMintingFeeRatio: proposeAssetContent.debtMintingFeeRatio,
+    liquidationProcessingFeeRatio:
+      proposeAssetContent.liquidationProcessingFeeRatio,
+    stabilityPoolWithdrawalFeeRatio:
+      proposeAssetContent.stabilityPoolWithdrawalFeeRatio,
+    redemptionReimbursementRatio:
+      proposeAssetContent.redemptionReimbursementRatio,
+    redemptionProcessingFeeRatio:
+      proposeAssetContent.redemptionProcessingFeeRatio,
     firstIAsset: true,
     nextIAsset: null,
   };
 
   return F.pipe(
     referencedIAsset,
-    O.match<
-      IAssetContent,
-      { newIAsset: IAssetContent; newReferencedIAsset: O.Option<IAssetContent> }
-    >(
+    O.match<IAssetContent, IAssetCreationDatumHelperReturnType>(
       () => ({
         newIAsset: newContent,
         newReferencedIAsset: O.none,
       }),
       (referencedIA) => {
         if (
-          toText(proposeAssetContent.asset) < toText(referencedIA.assetName)
+          toText(toHex(proposeAssetContent.asset)) <
+          toText(toHex(referencedIA.assetName))
         ) {
           return {
             newIAsset: {
@@ -155,3 +224,70 @@ export function iassetCreationDatumHelper(
     ),
   );
 }
+
+type CollateralAssetCreationDatumHelperReturnType = {
+  newCollateralAsset: CollateralAssetContent;
+  newReferencedCollateralAsset: O.Option<CollateralAssetContent>;
+};
+
+export function collateralAssetCreationDatumHelper(
+  addAssetContent: AddCollateralAsssetContent,
+  referencedCollateralAsset: O.Option<CollateralAssetContent>,
+): CollateralAssetCreationDatumHelperReturnType {
+  const newContent: CollateralAssetContent = {
+    iasset: addAssetContent.correspondingIAsset,
+    collateralAsset: addAssetContent.collateralAsset,
+    extraDecimals: addAssetContent.assetExtraDecimals,
+    priceInfo: addAssetContent.assetPriceInfo,
+    interestOracleNft: addAssetContent.interestOracleNft,
+    redemptionRatio: addAssetContent.redemptionRatio,
+    maintenanceRatio: addAssetContent.maintenanceRatio,
+    liquidationRatio: addAssetContent.liquidationRatio,
+    minCollateralAmt: addAssetContent.minCollateralAmt,
+    firstCollateralAsset: true,
+    nextCollateralAsset: null,
+  };
+
+  return F.pipe(
+    referencedCollateralAsset,
+    O.match<
+      CollateralAssetContent,
+      CollateralAssetCreationDatumHelperReturnType
+    >(
+      () => ({
+        newCollateralAsset: newContent,
+        newReferencedCollateralAsset: O.none,
+      }),
+      (referencedCA) => {
+        if (
+          getAssetClassComparisonStr(addAssetContent.collateralAsset) <
+          getAssetClassComparisonStr(referencedCA.collateralAsset)
+        ) {
+          return {
+            newCollateralAsset: {
+              ...newContent,
+              firstCollateralAsset: true,
+              nextCollateralAsset: referencedCA.collateralAsset,
+            },
+            newReferencedCollateralAsset: O.some({
+              ...referencedCA,
+              firstCollateralAsset: false,
+            }),
+          };
+        } else {
+          return {
+            newCollateralAsset: {
+              ...newContent,
+              firstCollateralAsset: false,
+              nextCollateralAsset: referencedCA.nextCollateralAsset,
+            },
+            newReferencedCollateralAsset: O.some({
+              ...referencedCA,
+              nextCollateralAsset: addAssetContent.collateralAsset,
+            }),
+          };
+        }
+      },
+    ),
+  );
+}

package/src/contracts/gov/scripts.ts

@@ -1,11 +1,14 @@
 import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
 import { castGovParams, GovParams } from './types';
-import { GovParamsSP, fromSystemParamsAsset } from '../../types/system-params';
+import {
+  GovParamsSP,
+  fromSystemParamsAssetLucid,
+} from '../../types/system-params';
 import { _governanceValidator } from '../../validators/governance-validator';
 
 export const mkGovValidator = (params: GovParams): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_governanceValidator.cborHex, [
       castGovParams(params),
     ]),
@@ -16,18 +19,22 @@ export const mkGovValidatorFromSP = (
   params: GovParamsSP,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_governanceValidator.cborHex, [
       castGovParams({
         gBiasTime: BigInt(params.gBiasTime),
-        govNFT: fromSystemParamsAsset(params.govNFT),
-        pollToken: fromSystemParamsAsset(params.pollToken),
-        upgradeToken: fromSystemParamsAsset(params.upgradeToken),
-        indyAsset: fromSystemParamsAsset(params.indyAsset),
-        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
+        govNFT: fromSystemParamsAssetLucid(params.govNFT),
+        pollToken: fromSystemParamsAssetLucid(params.pollToken),
+        upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
+        indyAsset: fromSystemParamsAssetLucid(params.indyAsset),
+        versionRecordToken: fromSystemParamsAssetLucid(
+          params.versionRecordToken,
+        ),
+        iassetSymbol: params.iassetSymbol.unCurrencySymbol,
+        iassetValHash: params.iassetValHash,
         pollManagerValHash: params.pollManagerValHash,
-        daoIdentityToken: fromSystemParamsAsset(params.daoIdentityToken),
-        iAssetAuthToken: fromSystemParamsAsset(params.iAssetAuthToken),
+        daoIdentityToken: fromSystemParamsAssetLucid(params.daoIdentityToken),
+        iAssetAuthToken: fromSystemParamsAssetLucid(params.iAssetAuthToken),
       }),
     ]),
   };