@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

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

@@ -1,115 +1,268 @@
-import { Core as EvoCore } from '@evolution-sdk/evolution';
-import { Data } from '@lucid-evolution/lucid';
-import { OracleAssetNftSchema } from '../price-oracle/types';
-import { AssetClassSchema } from '../../types/generic';
-import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
-import { IAssetPriceInfoSchema } from '../cdp/types';
+import { TSchema, Data } from '@evolution-sdk/evolution';
 import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+import {
+  AddressSchema,
+  AssetClassSchema,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { option as O, function as F } from 'fp-ts';
+import { IAssetPriceInfoSchema } from '../iasset/types';
+import { MultisigSchema } from '../../types/multisig';
+import { RationalSchema } from '../../types/rational';
 
-export const ProtocolParamsSchema = Data.Object({
-  proposalDeposit: Data.Integer(),
-  votingPeriod: Data.Integer(),
-  effectiveDelay: Data.Integer(),
-  expirationPeriod: Data.Integer(),
-  collateralFeePercentage: OnChainDecimalSchema,
-  proposingPeriod: Data.Integer(),
-  /// Total numer of shards used for voting.
-  totalShards: Data.Integer(),
-  /// The minimum number of votes (yes + no votes) for a proposal to be possible to pass.
-  minimumQuorum: Data.Integer(),
-  /// Maximum amount of lovelaces that can be spent at once from the treasury.
-  maxTreasuryLovelaceSpend: Data.Integer(),
-  /// Maximum amount of INDY that can be spent at once from the treasury.
-  maxTreasuryIndySpend: Data.Integer(),
+export const ProtocolParamsSchema = TSchema.Struct({
+  proposalDeposit: TSchema.Integer,
+  votingPeriod: TSchema.Integer,
+  effectiveDelay: TSchema.Integer,
+  expirationPeriod: TSchema.Integer,
+  proposingPeriod: TSchema.Integer,
+  totalShards: TSchema.Integer,
+  minimumQuorum: TSchema.Integer,
+  maxTreasuryLovelaceSpend: TSchema.Integer,
+  maxTreasuryIndySpend: TSchema.Integer,
+  cdpRedemptionRequiredSignature: TSchema.NullOr(TSchema.ByteArray),
+  electorate: TSchema.Integer,
+  foundationMultisig: MultisigSchema,
 });
 
-export type ProtocolParams = Data.Static<typeof ProtocolParamsSchema>;
-export const ProtocolParams = ProtocolParamsSchema as unknown as ProtocolParams;
+export type ProtocolParams = typeof ProtocolParamsSchema.Type;
 
-const ProposeAssetContentSchema = Data.Object({
-  asset: Data.Bytes(),
-  priceOracleNft: OracleAssetNftSchema,
-  interestOracleNft: AssetClassSchema,
-  redemptionRatioPercentage: OnChainDecimalSchema,
-  maintenanceRatioPercentage: OnChainDecimalSchema,
-  liquidationRatioPercentage: OnChainDecimalSchema,
-  debtMintingFeePercentage: OnChainDecimalSchema,
-  liquidationProcessingFeePercentage: OnChainDecimalSchema,
-  stabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
-  redemptionReimbursementPercentage: OnChainDecimalSchema,
-  redemptionProcessingFeePercentage: OnChainDecimalSchema,
-  interestCollectorPortionPercentage: OnChainDecimalSchema,
-});
-export type ProposeAssetContent = Data.Static<typeof ProposeAssetContentSchema>;
-
-export const ProposalContentSchema = Data.Enum([
-  Data.Object({
-    ProposeAsset: ProposeAssetContentSchema,
-  }),
-  Data.Object({
-    ModifyAsset: Data.Object({
-      asset: Data.Bytes(),
-      newAssetPriceInfo: IAssetPriceInfoSchema,
-      newInterestOracleNft: AssetClassSchema,
-      newRedemptionRatioPercentage: OnChainDecimalSchema,
-      newMaintenanceRatioPercentage: OnChainDecimalSchema,
-      newLiquidationRatioPercentage: OnChainDecimalSchema,
-      newDebtMintingFeePercentage: OnChainDecimalSchema,
-      newLiquidationProcessingFeePercentage: OnChainDecimalSchema,
-      newStabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
-      newRedemptionReimbursementPercentage: OnChainDecimalSchema,
-      newRedemptionProcessingFeePercentage: OnChainDecimalSchema,
-      newInterestCollectorPortionPercentage: OnChainDecimalSchema,
-    }),
-  }),
-  Data.Object({
-    ModifyProtocolParams: Data.Object({
-      newParams: ProtocolParamsSchema,
-    }),
-  }),
-  Data.Object({
-    UpgradeProtocol: Data.Object({
-      content:
-        // NOTICE: This is replaced by evolution-sdk encoding of `UpgradePathsSchema` defined in this file.
-        Data.Any(),
-    }),
-  }),
-  Data.Object({
-    TextProposal: Data.Object({
-      bytes: Data.Bytes(),
-    }),
-  }),
-]);
-export type ProposalContent = Data.Static<typeof ProposalContentSchema>;
-export const ProposalContent =
-  ProposalContentSchema as unknown as ProposalContent;
-
-const UpgradePathSchema = EvoCore.TSchema.Struct({
-  upgradeSymbol: EvoCore.TSchema.ByteArray,
+const UpgradePathSchema = TSchema.Struct({
+  upgradeSymbol: TSchema.ByteArray,
 });
 
-const UpgradePathsSchema = EvoCore.TSchema.Struct({
-  upgradeId: EvoCore.TSchema.Integer,
+const UpgradePathsSchema = TSchema.Struct({
+  upgradeId: TSchema.Integer,
   /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: EvoCore.TSchema.Map(
-    EvoCore.TSchema.ByteArray,
-    UpgradePathSchema,
+  upgradePaths: TSchema.Array(
+    TSchema.Tuple([TSchema.ByteArray, UpgradePathSchema]),
   ),
 });
 export type UpgradePaths = typeof UpgradePathsSchema.Type;
 
-export function serialiseUpgradePaths(d: UpgradePaths): Data {
-  return Data.from(
-    EvoCore.Data.withSchema(
-      UpgradePathsSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).toCBORHex(d),
-  );
+const ProposeIAssetContentSchema = TSchema.Struct({
+  asset: TSchema.ByteArray,
+  debtMintingFeeRatio: RationalSchema,
+  liquidationProcessingFeeRatio: RationalSchema,
+  stabilityPoolWithdrawalFeeRatio: RationalSchema,
+  redemptionReimbursementRatio: RationalSchema,
+  redemptionProcessingFeeRatio: RationalSchema,
+});
+export type ProposeAssetContent = typeof ProposeIAssetContentSchema.Type;
+
+const ModifyIAssetContentSchema = TSchema.Struct({
+  asset: TSchema.ByteArray,
+  newDebtMintingFeeRatio: RationalSchema,
+  newLiquidationProcessingFeeRatio: RationalSchema,
+  newStabilityPoolWithdrawalFeeRatio: RationalSchema,
+  newRedemptionReimbursementRatio: RationalSchema,
+  newRedemptionProcessingFeeRatio: RationalSchema,
+});
+
+const AddCollateralAssetContentSchema = TSchema.Struct({
+  correspondingIAsset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
+  assetExtraDecimals: TSchema.Integer,
+  assetPriceInfo: IAssetPriceInfoSchema,
+  interestOracleNft: AssetClassSchema,
+  redemptionRatio: RationalSchema,
+  maintenanceRatio: RationalSchema,
+  liquidationRatio: RationalSchema,
+  minCollateralAmt: TSchema.Integer,
+});
+
+export type AddCollateralAsssetContent =
+  typeof AddCollateralAssetContentSchema.Type;
+
+const UpdateCollateralAssetContentSchema = TSchema.Struct({
+  correspondingIAsset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
+  newAssetExtraDecimals: TSchema.Integer,
+  newAssetPriceInfo: IAssetPriceInfoSchema,
+  newInterestOracleNft: AssetClassSchema,
+  newRedemptionRatio: RationalSchema,
+  newMaintenanceRatio: RationalSchema,
+  newLiquidationRatio: RationalSchema,
+  newMinCollateralAmt: TSchema.Integer,
+});
+
+const ProposeStableswapPoolContentSchema = TSchema.Struct({
+  iasset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
+  collateralToIassetRatio: RationalSchema,
+  mintingFeeRatio: RationalSchema,
+  redemptionFeeRatio: RationalSchema,
+  feeManager: TSchema.NullOr(TSchema.ByteArray),
+  minMintingAmount: TSchema.Integer,
+  minRedemptionAmount: TSchema.Integer,
+  stableswapValHash: TSchema.ByteArray,
+});
+
+export type ProposeStableswapPoolContent =
+  typeof ProposeStableswapPoolContentSchema.Type;
+
+const ModifyStableswapPoolContentSchema = TSchema.Struct({
+  iasset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
+  newCollateralToIassetRatio: RationalSchema,
+  newMintingFeeRatio: RationalSchema,
+  newRedemptionFeeRatio: RationalSchema,
+  newMintingEnabled: TSchema.Boolean,
+  newRedemptionEnabled: TSchema.Boolean,
+  newFeeManager: TSchema.NullOr(TSchema.ByteArray),
+  newMinMintingAmount: TSchema.Integer,
+  newMinRedemptionAmount: TSchema.Integer,
+  newStableswapValHash: TSchema.ByteArray,
+});
+
+export type ModifyStableswapPoolContent =
+  typeof ModifyStableswapPoolContentSchema.Type;
+
+export const ProposalContentSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      ProposeIAsset: ProposeIAssetContentSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      ModifyIAsset: ModifyIAssetContentSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      AddCollateralAsset: AddCollateralAssetContentSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      UpdateCollateralAsset: UpdateCollateralAssetContentSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      ProposeStableswapPool: ProposeStableswapPoolContentSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      ModifyStableswapPool: ModifyStableswapPoolContentSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      ModifyProtocolParams: TSchema.Struct(
+        {
+          newParams: ProtocolParamsSchema,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      UpgradeProtocol: TSchema.Struct(
+        {
+          content: UpgradePathsSchema,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      TextProposal: TSchema.ByteArray,
+    },
+    { flatInUnion: true },
+  ),
+);
+export type ProposalContent = typeof ProposalContentSchema.Type;
+
+const TreasuryWithdrawalItemSchema = TSchema.Struct({
+  currencySymbol: TSchema.ByteArray,
+  tokenName: TSchema.ByteArray,
+  amount: TSchema.Integer,
+});
+export type TreasuryWithdrawalItem = typeof TreasuryWithdrawalItemSchema.Type;
+
+export const TreasuryWithdrawalSchema = TSchema.Struct({
+  destination: AddressSchema,
+  value: TSchema.Array(TreasuryWithdrawalItemSchema),
+});
+export type TreasuryWithdrawal = typeof TreasuryWithdrawalSchema.Type;
+
+const GovRedeemerSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      CreatePoll: TSchema.Struct(
+        {
+          currentTime: TSchema.Integer,
+          proposalOwner: TSchema.ByteArray,
+          content: ProposalContentSchema,
+          treasuryWithdrawal: TSchema.NullOr(TreasuryWithdrawalSchema),
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      WitnessEndPoll: TSchema.Struct(
+        {
+          currentTime: TSchema.Integer,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('UpgradeGov', { flatInUnion: true }),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+export type GovRedeemer = typeof GovRedeemerSchema.Type;
+
+const GovDatumSchema = TSchema.Struct({
+  currentProposal: TSchema.Integer,
+  protocolParams: ProtocolParamsSchema,
+  currentVersion: TSchema.Integer,
+  iassetsCount: TSchema.Integer,
+  activeProposals: TSchema.Integer,
+});
+export type GovDatum = typeof GovDatumSchema.Type;
+
+export function serialiseGovRedeemer(r: GovRedeemer): string {
+  return Data.withSchema(GovRedeemerSchema).toCBORHex(r);
 }
 
-export function parseUpgradePaths(d: Data): UpgradePaths {
-  return EvoCore.Data.withSchema(
-    UpgradePathsSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).fromCBORHex(Data.to(d));
+export function serialiseGovDatum(d: GovDatum): string {
+  return Data.withSchema(GovDatumSchema).toCBORHex(d);
+}
+
+export function parseGovDatum(datum: string): O.Option<GovDatum> {
+  try {
+    return O.some(
+      Data.withSchema(GovDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum,
+      ),
+    );
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseGovDatumOrThrow(datum: string): GovDatum {
+  return F.pipe(
+    parseGovDatum(datum),
+    O.match(() => {
+      throw new Error('Expected a Gov datum.');
+    }, F.identity),
+  );
 }

package/src/contracts/gov/types.ts

@@ -1,18 +1,5 @@
-import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
-import { AddressSchema, AssetClassSchema } from '../../types/generic';
-import { option as O, function as F } from 'fp-ts';
-import { ProposalContentSchema, ProtocolParamsSchema } from './types-new';
-
-const GovDatumSchema = Data.Object({
-  currentProposal: Data.Integer(),
-  protocolParams: ProtocolParamsSchema,
-  currentVersion: Data.Integer(),
-  iassetsCount: Data.Integer(),
-  activeProposals: Data.Integer(),
-  treasuryIndyWithdrawnAmt: Data.Integer(),
-});
-export type GovDatum = Data.Static<typeof GovDatumSchema>;
-const GovDatum = GovDatumSchema as unknown as GovDatum;
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
 
 const GovParamsSchema = Data.Object({
   govNFT: AssetClassSchema,
@@ -20,7 +7,9 @@ const GovParamsSchema = Data.Object({
   upgradeToken: AssetClassSchema,
   indyAsset: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
+  iassetSymbol: Data.Bytes(),
   pollManagerValHash: Data.Bytes(),
+  iassetValHash: Data.Bytes(),
   gBiasTime: Data.Integer(),
   daoIdentityToken: AssetClassSchema,
   iAssetAuthToken: AssetClassSchema,
@@ -28,62 +17,6 @@ const GovParamsSchema = Data.Object({
 export type GovParams = Data.Static<typeof GovParamsSchema>;
 export const GovParams = GovParamsSchema as unknown as GovParams;
 
-const ValueWithdrawalItemSchema = Data.Tuple(
-  [Data.Bytes(), Data.Bytes(), Data.Integer()],
-  { hasConstr: true },
-);
-export type TreasuryWithdrawalItem = Data.Static<
-  typeof ValueWithdrawalItemSchema
->;
-
-export const TreasuryWithdrawalSchema = Data.Object({
-  destination: AddressSchema,
-  value: Data.Array(ValueWithdrawalItemSchema),
-});
-export type TreasuryWithdrawal = Data.Static<typeof TreasuryWithdrawalSchema>;
-
-const GovRedeemerSchema = Data.Enum([
-  Data.Object({
-    CreatePoll: Data.Object({
-      currentTime: Data.Integer(),
-      proposalOwner: Data.Bytes(),
-      content: ProposalContentSchema,
-      treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
-    }),
-  }),
-  Data.Object({ WitnessEndPoll: Data.Object({ currentTime: Data.Integer() }) }),
-  Data.Literal('UpgradeGov'),
-  Data.Literal('UpgradeVersion'),
-]);
-
-export type GovRedeemer = Data.Static<typeof GovRedeemerSchema>;
-export const GovRedeemer = GovRedeemerSchema as unknown as GovRedeemer;
-
-export function parseGovDatum(datum: Datum): O.Option<GovDatum> {
-  try {
-    return O.some(Data.from<GovDatum>(datum, GovDatum));
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseGovDatumOrThrow(datum: Datum): GovDatum {
-  return F.pipe(
-    parseGovDatum(datum),
-    O.match(() => {
-      throw new Error('Expected a Gov datum.');
-    }, F.identity),
-  );
-}
-
-export function serialiseGovDatum(d: GovDatum): Datum {
-  return Data.to<GovDatum>(d, GovDatum);
-}
-
-export function serialiseGovRedeemer(redeemer: GovRedeemer): Redeemer {
-  return Data.to<GovRedeemer>(redeemer, GovRedeemer);
-}
-
 export function castGovParams(params: GovParams): Data {
   return Data.castTo(params, GovParams);
 }

package/src/contracts/iasset/helpers.ts

@@ -0,0 +1,172 @@
+import {
+  credentialToRewardAddress,
+  Data,
+  fromHex,
+  LucidEvolution,
+  OutRef,
+  scriptHashToCredential,
+  slotToUnixTime,
+  toHex,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import { IAssetPriceInfo } from './types';
+import { matchSingle } from '../../utils/utils';
+import { parsePriceOracleDatum } from '../price-oracle/types-new';
+import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
+import { oracleExpirationAwareValidity } from '../price-oracle/helpers';
+import {
+  fromSysParamsDerivedPythPrice,
+  fromSystemParamsScriptRef,
+  getPythFeedConfig,
+  PythConfig,
+} from '../../types/system-params';
+import {
+  parsePythStateDatum,
+  serialisePythFeedRedeemer,
+  serialisePythUpdatesRedeemer,
+} from '../pyth-feed/types';
+import { match, P } from 'ts-pattern';
+import { derivePythPrice } from '../pyth-feed/helpers';
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import * as Core from '@evolution-sdk/evolution';
+import { decodePriceUpdate, decodePythMessage } from '../../utils/pyth';
+
+type Interval = {
+  validFrom: number;
+  validTo: number;
+};
+
+export function attachOracle(
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+  priceInfo: IAssetPriceInfo,
+  priceOracleOref: OutRef | undefined,
+  pythStateOref: OutRef | undefined,
+  pythMessage: string | undefined,
+  pythConfig: PythConfig,
+  biasTime: bigint,
+  currentSlot: number,
+  lucid: LucidEvolution,
+  tx: TxBuilder,
+): Promise<{ interval: Interval; referenceInputs: UTxO[] }> {
+  return match(priceInfo)
+    .returnType<Promise<{ interval: Interval; referenceInputs: UTxO[] }>>()
+    .with({ Delisted: P.any }, () => {
+      const currentTime = BigInt(
+        slotToUnixTime(lucid.config().network!, currentSlot),
+      );
+
+      // We want to make sure the transaction is valid within the bias time for interest tracking AND Pyth
+      // For validFrom, we take the higher of the two bias times
+      const validFrom = Number(currentTime - BigInt(biasTime / 2n));
+      // For validTo, we take the lower of the two bias times
+      const validTo = Number(currentTime + BigInt(biasTime / 2n));
+
+      return Promise.resolve({
+        interval: {
+          validFrom,
+          validTo,
+        },
+        referenceInputs: [],
+      });
+    })
+    .with({ OracleNft: P.any }, async () => {
+      if (!priceOracleOref) throw new Error('Missing price oracle');
+
+      const priceOracleUtxo = matchSingle<UTxO>(
+        await lucid.utxosByOutRef([priceOracleOref]),
+        (_) => new Error('Expected a single price oracle UTXO'),
+      );
+      const priceOracleDatum = parsePriceOracleDatum(
+        getInlineDatumOrThrow(priceOracleUtxo),
+      );
+
+      return {
+        interval: oracleExpirationAwareValidity(
+          currentSlot,
+          Number(biasTime),
+          Number(priceOracleDatum.expirationTime),
+          lucid.config().network!,
+        ),
+        referenceInputs: [priceOracleUtxo],
+      };
+    })
+    .with(
+      { DeferredValidation: { feedValHash: P.select() } },
+      async (feedValHash) => {
+        if (!pythMessage) throw new Error('Missing Pyth message');
+        if (!pythStateOref) throw new Error('Missing pyth state out ref');
+
+        const pythStateUtxo = matchSingle(
+          await lucid.utxosByOutRef([pythStateOref]),
+          (_) => new Error('Expected a single pyth state UTXO'),
+        );
+
+        const pythStateDatum = parsePythStateDatum(
+          getInlineDatumOrThrow(pythStateUtxo),
+        );
+
+        const pythFeedCfg = getPythFeedConfig(
+          pythConfig,
+          iasset,
+          collateralAsset,
+        );
+
+        // Lookup PFV Validator
+        const pfvScriptRefUtxo = matchSingle(
+          await lucid.utxosByOutRef([
+            fromSystemParamsScriptRef(pythFeedCfg.pythFeedValScriptRef),
+          ]),
+          (_) =>
+            new Error('Expected a single pyth feed validator Ref Script UTXO'),
+        );
+
+        const derivedPythPrice = fromSysParamsDerivedPythPrice(
+          pythFeedCfg.params.config,
+        );
+
+        const price = derivePythPrice(derivedPythPrice, pythMessage);
+
+        const decodedMessage = decodePythMessage(fromHex(pythMessage));
+        const pricePayload = decodePriceUpdate(decodedMessage.payload);
+        const pythTimestamp = Number(pricePayload.timestampUs) / 1_000;
+
+        tx.withdraw(
+          credentialToRewardAddress(
+            lucid.config().network!,
+            scriptHashToCredential(toHex(pythStateDatum.withdraw_script)),
+          ),
+          0n,
+          serialisePythUpdatesRedeemer([fromHex(pythMessage)]),
+        );
+
+        tx.withdraw(
+          credentialToRewardAddress(
+            lucid.config().network!,
+            scriptHashToCredential(toHex(feedValHash)),
+          ),
+          0n,
+          serialisePythFeedRedeemer({
+            price: price,
+            auxiliaryData: Core.Data.fromCBORHex(Data.void()),
+          }),
+        );
+
+        // 5 minutes - 20 seconds
+        const pythMaxDelay = 280 * 1000;
+
+        const validFrom = Number(pythTimestamp);
+        const validTo = Number(pythTimestamp + pythMaxDelay);
+
+        return {
+          interval: {
+            validFrom: validFrom,
+            validTo: validTo,
+          },
+          referenceInputs: [pythStateUtxo, pfvScriptRefUtxo],
+        };
+      },
+    )
+    .exhaustive();
+}

package/src/contracts/iasset/scripts.ts

@@ -0,0 +1,38 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import {
+  fromSystemParamsAssetLucid,
+  IAssetParamsSP,
+} from '../../types/system-params';
+import { _cdpValidator } from '../../validators/cdp-validator';
+import { _iassetValidator } from '../../validators/iasset-validator';
+
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
+
+const IAssetScriptParamsSchema = Data.Object({
+  upgradeToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+});
+
+export type IAssetScriptParams = Data.Static<typeof IAssetScriptParamsSchema>;
+export const IAssetScriptParams =
+  IAssetScriptParamsSchema as unknown as IAssetScriptParams;
+
+export const mkIAssetValidatorFromSP = (
+  params: IAssetParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_iassetValidator.cborHex, [
+      Data.castTo(
+        {
+          upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
+          versionRecordToken: fromSystemParamsAssetLucid(
+            params.versionRecordToken,
+          ),
+        },
+        IAssetScriptParams,
+      ),
+    ]),
+  };
+};