@indigo-labs/indigo-sdk 0.1.27 → 0.2.0

package/src/contracts/cdp/types.ts

@@ -0,0 +1,161 @@
+import { Data, Datum, Redeemer, UTxO } from '@lucid-evolution/lucid';
+import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
+import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
+import { OracleAssetNftSchema } from '../price-oracle/types';
+import { match, P } from 'ts-pattern';
+import { option as O, function as F } from 'fp-ts';
+
+const CdpParamsSchema = Data.Object({
+  cdp_auth_token: AssetClassSchema,
+  cdp_asset_symbol: Data.Bytes(),
+  iasset_auth_token: AssetClassSchema,
+  stability_pool_auth_token: AssetClassSchema,
+  version_record_token: AssetClassSchema,
+  upgrade_token: AssetClassSchema,
+  collector_val_hash: Data.Bytes(),
+  sp_val_hash: Data.Bytes(),
+  gov_nft: AssetClassSchema,
+  min_collateral_in_lovelace: Data.Integer(),
+  partial_redemption_extra_fee_lovelace: Data.Integer(),
+  bias_time: Data.Integer(),
+  treasury_val_hash: Data.Bytes(),
+});
+export type CdpParams = Data.Static<typeof CdpParamsSchema>;
+const CdpParams = CdpParamsSchema as unknown as CdpParams;
+
+export const CDPFeesSchema = Data.Enum([
+  Data.Object({
+    ActiveCDPInterestTracking: Data.Object({
+      lastSettled: Data.Integer(),
+      unitaryInterestSnapshot: Data.Integer(),
+    }),
+  }),
+  Data.Object({
+    FrozenCDPAccumulatedFees: Data.Object({
+      lovelacesTreasury: Data.Integer(),
+      lovelacesIndyStakers: Data.Integer(),
+    }),
+  }),
+]);
+
+export const CDPContentSchema = Data.Object({
+  cdpOwner: Data.Nullable(Data.Bytes()),
+  iasset: Data.Bytes(),
+  mintedAmt: Data.Integer(),
+  cdpFees: CDPFeesSchema,
+});
+
+export const IAssetPriceInfoSchema = Data.Enum([
+  Data.Object({
+    Delisted: Data.Object({ content: OnChainDecimalSchema }),
+  }),
+  Data.Object({
+    Oracle: Data.Object({ content: OracleAssetNftSchema }),
+  }),
+]);
+
+export const IAssetContentSchema = Data.Object({
+  /** Use the HEX encoding */
+  assetName: Data.Bytes(),
+  price: IAssetPriceInfoSchema,
+  interestOracleNft: AssetClassSchema,
+  redemptionRatio: OnChainDecimalSchema,
+  maintenanceRatio: OnChainDecimalSchema,
+  liquidationRatio: OnChainDecimalSchema,
+  debtMintingFeePercentage: OnChainDecimalSchema,
+  liquidationProcessingFeePercentage: OnChainDecimalSchema,
+  stabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
+  redemptionReimbursementPercentage: OnChainDecimalSchema,
+  redemptionProcessingFeePercentage: OnChainDecimalSchema,
+  interestCollectorPortionPercentage: OnChainDecimalSchema,
+  firstIAsset: Data.Boolean(),
+  nextIAsset: Data.Nullable(Data.Bytes()),
+});
+
+export const CDPDatumSchema = Data.Enum([
+  Data.Object({ CDP: Data.Object({ content: CDPContentSchema }) }),
+  Data.Object({ IAsset: Data.Object({ content: IAssetContentSchema }) }),
+]);
+
+export type CDPFees = Data.Static<typeof CDPFeesSchema>;
+export type CDPDatum = Data.Static<typeof CDPDatumSchema>;
+const CDPDatum = CDPDatumSchema as unknown as CDPDatum;
+
+export type CDPContent = Data.Static<typeof CDPContentSchema>;
+const CDPContent = CDPContentSchema as unknown as CDPContent;
+export type IAssetContent = Data.Static<typeof IAssetContentSchema>;
+const IAssetContent = IAssetContentSchema as unknown as IAssetContent;
+
+const CDPRedeemerSchema = Data.Enum([
+  Data.Object({
+    AdjustCdp: Data.Object({
+      currentTime: Data.Integer(),
+      mintedAmtChange: Data.Integer(),
+      collateralAmtChange: Data.Integer(),
+    }),
+  }),
+  Data.Object({ CloseCdp: Data.Object({ currentTime: Data.Integer() }) }),
+  Data.Object({ RedeemCdp: Data.Object({ currentTime: Data.Integer() }) }),
+  Data.Object({ FreezeCdp: Data.Object({ currentTime: Data.Integer() }) }),
+  Data.Literal('MergeCdps'),
+  Data.Object({
+    MergeAuxiliary: Data.Object({ mainMergeUtxo: OutputReferenceSchema }),
+  }),
+  Data.Literal('Liquidate'),
+  Data.Literal('UpdateOrInsertAsset'),
+  Data.Literal('UpgradeVersion'),
+]);
+export type CDPRedeemer = Data.Static<typeof CDPRedeemerSchema>;
+const CDPRedeemer = CDPRedeemerSchema as unknown as CDPRedeemer;
+
+export function serialiseCdpRedeemer(r: CDPRedeemer): Redeemer {
+  return Data.to<CDPRedeemer>(r, CDPRedeemer);
+}
+
+export function parseCdpDatum(datum: Datum): O.Option<CDPContent> {
+  return match(Data.from<CDPDatum>(datum, CDPDatum))
+    .with({ CDP: { content: P.select() } }, (res) => O.some(res))
+    .otherwise(() => O.none);
+}
+
+export function parseCdpDatumOrThrow(datum: Datum): CDPContent {
+  return F.pipe(
+    parseCdpDatum(datum),
+    O.match(() => {
+      throw new Error('Expected a CDP datum.');
+    }, F.identity),
+  );
+}
+
+export function serialiseCdpDatum(cdpDatum: CDPContent): Datum {
+  return Data.to<CDPDatum>({ CDP: { content: cdpDatum } }, CDPDatum);
+}
+
+export function parseIAssetDatum(datum: Datum): O.Option<IAssetContent> {
+  try {
+    return match(Data.from<CDPDatum>(datum, CDPDatum))
+      .with({ IAsset: { content: P.select() } }, (res) => O.some(res))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseIAssetDatumOrThrow(datum: Datum): IAssetContent {
+  return F.pipe(
+    parseIAssetDatum(datum),
+    O.match(() => {
+      throw new Error('Expected an IAsset datum.');
+    }, F.identity),
+  );
+}
+
+export function serialiseIAssetDatum(iassetDatum: IAssetContent): Datum {
+  return Data.to<CDPDatum>({ IAsset: { content: iassetDatum } }, CDPDatum);
+}
+
+export function castCdpParams(params: CdpParams): Data {
+  return Data.castTo(params, CdpParams);
+}
+
+export type IAssetOutput = { datum: IAssetContent; utxo: UTxO };

package/src/contracts/cdp-creator/scripts.ts

@@ -0,0 +1,39 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import { castCDPCreatorParams, CDPCreatorParams } from './types';
+import {
+  CDPCreatorParamsSP,
+  fromSystemParamsAsset,
+} from '../../types/system-params';
+import { _cdpCreatorValidator } from '../../validators/cdp-creator-validator';
+
+export const mkCDPCreatorValidator = (
+  params: CDPCreatorParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
+      castCDPCreatorParams(params),
+    ]),
+  };
+};
+
+export const mkCDPCreatorValidatorFromSP = (
+  params: CDPCreatorParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
+      castCDPCreatorParams({
+        cdpCreatorNft: fromSystemParamsAsset(params.cdpCreatorNft),
+        cdpAssetCs: params.cdpAssetCs.unCurrencySymbol,
+        cdpAuthTk: fromSystemParamsAsset(params.cdpAuthTk),
+        iAssetAuthTk: fromSystemParamsAsset(params.iAssetAuthTk),
+        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
+        cdpScriptHash: params.cdpScriptHash,
+        collectorValHash: params.collectorValHash,
+        minCollateralInLovelace: BigInt(params.minCollateralInLovelace),
+        biasTime: BigInt(params.biasTime),
+      }),
+    ]),
+  };
+};

package/src/{types/indigo/cdp-creator.ts → contracts/cdp-creator/types.ts}

@@ -1,5 +1,5 @@
-import { Data, Datum } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../generic';
+import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
 
 const CDPCreatorParamsSchema = Data.Object({
   cdpCreatorNft: AssetClassSchema,
@@ -37,8 +37,10 @@ export type CDPCreatorRedeemer = Data.Static<typeof CDPCreatorRedeemerSchema>;
 export const CDPCreatorRedeemer =
   CDPCreatorRedeemerSchema as unknown as CDPCreatorRedeemer;
 
-export function castCDPCreatorRedeemer(params: CDPCreatorRedeemer): Data {
-  return Data.castTo(params, CDPCreatorRedeemer);
+export function serialiseCDPCreatorRedeemer(
+  params: CDPCreatorRedeemer,
+): Redeemer {
+  return Data.to<CDPCreatorRedeemer>(params, CDPCreatorRedeemer);
 }
 
 export function serialiseCDPCreatorDatum(): Datum {

package/src/contracts/collector/scripts.ts

@@ -0,0 +1,32 @@
+import {
+  applyParamsToScript,
+  Constr,
+  fromText,
+  SpendingValidator,
+} from '@lucid-evolution/lucid';
+import { CollectorParamsSP } from '../../types/system-params';
+import { _collectorValidator } from '../../validators/collector-validator';
+
+export const mkCollectorValidatorFromSP = (
+  params: CollectorParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_collectorValidator.cborHex, [
+      new Constr(0, [
+        new Constr(0, [
+          params.stakingManagerNFT[0].unCurrencySymbol,
+          fromText(params.stakingManagerNFT[1].unTokenName),
+        ]),
+        new Constr(0, [
+          params.stakingToken[0].unCurrencySymbol,
+          fromText(params.stakingToken[1].unTokenName),
+        ]),
+        new Constr(0, [
+          params.versionRecordToken[0].unCurrencySymbol,
+          fromText(params.versionRecordToken[1].unTokenName),
+        ]),
+      ]),
+    ]),
+  };
+};

package/src/contracts/collector/transactions.ts

@@ -0,0 +1,44 @@
+import {
+  Constr,
+  Data,
+  LucidEvolution,
+  OutRef,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  fromSystemParamsScriptRef,
+  SystemParams,
+} from '../../types/system-params';
+import { matchSingle } from '../../utils/utils';
+
+export async function collectorFeeTx(
+  fee: bigint,
+  lucid: LucidEvolution,
+  params: SystemParams,
+  tx: TxBuilder,
+  collectorOref: OutRef,
+): Promise<void> {
+  const collectorUtxo: UTxO = matchSingle(
+    await lucid.utxosByOutRef([collectorOref]),
+    (_) => new Error('Expected a single collector UTXO'),
+  );
+
+  const collectorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.collectorValidatorRef),
+    ]),
+    (_) => new Error('Expected a single collector Ref Script UTXO'),
+  );
+
+  tx.collectFrom([collectorUtxo], Data.to(new Constr(0, [])))
+    .pay.ToContract(
+      collectorUtxo.address,
+      { kind: 'inline', value: Data.to(new Constr(0, [])) },
+      {
+        ...collectorUtxo.assets,
+        lovelace: collectorUtxo.assets.lovelace + fee,
+      },
+    )
+    .readFrom([collectorRefScriptUtxo]);
+}

package/src/contracts/execute/scripts.ts

@@ -0,0 +1,48 @@
+import {
+  applyParamsToScript,
+  applySingleCborEncoding,
+  SpendingValidator,
+} from '@lucid-evolution/lucid';
+import { castExecuteParams, ExecuteParams } from './types';
+import {
+  ExecuteParamsSP,
+  fromSystemParamsAsset,
+} from '../../types/system-params';
+import { _executeValidator } from '../../validators/execute-validator';
+
+export const mkExecuteValidator = (
+  params: ExecuteParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applySingleCborEncoding(
+      applyParamsToScript(_executeValidator.cborHex, [
+        castExecuteParams(params),
+      ]),
+    ),
+  };
+};
+
+export const mkExecuteValidatorFromSP = (
+  params: ExecuteParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    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),
+          cdpValHash: params.cdpValHash,
+          sPoolValHash: params.sPoolValHash,
+          versionRegistryValHash: params.versionRegistryValHash,
+          treasuryValHash: params.treasuryValHash,
+          indyAsset: fromSystemParamsAsset(params.indyAsset),
+        } as ExecuteParams),
+      ]),
+    ),
+  };
+};

package/src/contracts/execute/types.ts

@@ -0,0 +1,57 @@
+import { Data, Datum } 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,
+  stabilityPoolToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  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

@@ -0,0 +1,157 @@
+import { pipe } from 'fp-ts/lib/function';
+import {
+  array as A,
+  option as O,
+  string as S,
+  ord as Ord,
+  function as F,
+} from 'fp-ts';
+import { TreasuryWithdrawal, TreasuryWithdrawalItem } from './types';
+import {
+  addAssets,
+  Assets,
+  LucidEvolution,
+  OutRef,
+  toText,
+} from '@lucid-evolution/lucid';
+import { mkAssetsOf } from '../../utils/value-helpers';
+import {
+  IAssetContent,
+  IAssetOutput,
+  parseIAssetDatumOrThrow,
+} from '../cdp/types';
+import { ProposeAssetContent } from './types-new';
+import { matchSingle } from '../../utils/utils';
+import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
+
+export function proposalDeposit(
+  baseDeposit: bigint,
+  activeProposals: bigint,
+): bigint {
+  return baseDeposit * 2n ** activeProposals;
+}
+
+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);
+}
+
+/**
+ * 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(
+  /**
+   * UFT encoded
+   */
+  newIAssetTokenName: string,
+  allIAssetOrefs: OutRef[],
+  lucid: LucidEvolution,
+): Promise<O.Option<IAssetOutput>> {
+  const iassetUtxos = await Promise.all(
+    allIAssetOrefs.map(async (oref) => {
+      const iassetUtxo = matchSingle(
+        await lucid.utxosByOutRef([oref]),
+        (_) => new Error('Expected a single IAsset UTXO'),
+      );
+
+      const datum = parseIAssetDatumOrThrow(getInlineDatumOrThrow(iassetUtxo));
+
+      return { datum: datum, utxo: iassetUtxo };
+    }),
+  );
+
+  // The iasset just before the new token name based on assets ordering
+  return pipe(
+    // Sort the asset names
+    iassetUtxos,
+    A.sort(
+      Ord.contramap<string, IAssetOutput>((x) => toText(x.datum.assetName))(
+        S.Ord,
+      ),
+    ),
+    // split head and tail
+    A.foldLeft(
+      () => O.none,
+      (head, rest) => O.some<[IAssetOutput, IAssetOutput[]]>([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,
+        )(rest),
+      ),
+    ),
+  );
+}
+
+export function iassetCreationDatumHelper(
+  proposeAssetContent: ProposeAssetContent,
+  referencedIAsset: O.Option<IAssetContent>,
+): { newIAsset: IAssetContent; newReferencedIAsset: O.Option<IAssetContent> } {
+  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,
+    firstIAsset: true,
+    nextIAsset: null,
+  };
+
+  return F.pipe(
+    referencedIAsset,
+    O.match<
+      IAssetContent,
+      { newIAsset: IAssetContent; newReferencedIAsset: O.Option<IAssetContent> }
+    >(
+      () => ({
+        newIAsset: newContent,
+        newReferencedIAsset: O.none,
+      }),
+      (referencedIA) => {
+        if (
+          toText(proposeAssetContent.asset) < toText(referencedIA.assetName)
+        ) {
+          return {
+            newIAsset: {
+              ...newContent,
+              firstIAsset: true,
+              nextIAsset: referencedIA.assetName,
+            },
+            newReferencedIAsset: O.some({
+              ...referencedIA,
+              firstIAsset: false,
+            }),
+          };
+        } else {
+          return {
+            newIAsset: {
+              ...newContent,
+              firstIAsset: false,
+              nextIAsset: referencedIA.nextIAsset,
+            },
+            newReferencedIAsset: O.some({
+              ...referencedIA,
+              nextIAsset: proposeAssetContent.asset,
+            }),
+          };
+        }
+      },
+    ),
+  );
+}

package/src/contracts/gov/scripts.ts

@@ -0,0 +1,34 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import { castGovParams, GovParams } from './types';
+import { GovParamsSP, fromSystemParamsAsset } from '../../types/system-params';
+import { _governanceValidator } from '../../validators/governance-validator';
+
+export const mkGovValidator = (params: GovParams): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_governanceValidator.cborHex, [
+      castGovParams(params),
+    ]),
+  };
+};
+
+export const mkGovValidatorFromSP = (
+  params: GovParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    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),
+        pollManagerValHash: params.pollManagerValHash,
+        daoIdentityToken: fromSystemParamsAsset(params.daoIdentityToken),
+        iAssetAuthToken: fromSystemParamsAsset(params.iAssetAuthToken),
+      }),
+    ]),
+  };
+};