@indigo-labs/indigo-sdk 0.1.19 → 0.1.21

package/tests/endpoints/initialize.ts

@@ -2,62 +2,70 @@ import {
   Constr,
   credentialToAddress,
   Data,
+  fromHex,
   fromText,
   LucidEvolution,
   mintingPolicyToId,
   PolicyId,
   SpendingValidator,
-  validatorToAddress,
   validatorToScriptHash,
 } from '@lucid-evolution/lucid';
 import {
   addrDetails,
   AssetClass,
-  CDPContract,
   CDPCreatorParamsSP,
-  CdpParams,
-  CollectorContract,
-  CollectorParams,
+  CdpParamsSP,
+  CollectorParamsSP,
+  createScriptAddress,
   ExecuteParamsSP,
   GovDatum,
   GovParamsSP,
   IAssetContent,
   Input,
-  InterestOracleDatum,
-  InterestOracleParams,
+  LrpParamsSP,
   mkCDPCreatorValidatorFromSP,
-  mkInterestOracleValidator,
+  mkCdpValidatorFromSP,
+  mkCollectorValidatorFromSP,
+  mkExecuteValidatorFromSP,
+  mkLrpValidatorFromSP,
   mkPollManagerValidatorFromSP,
   mkPollShardValidatorFromSP,
+  mkTreasuryValidatorFromSP,
   PollManagerParamsSP,
   PollShardParamsSP,
-  PriceOracleDatum,
   PriceOracleParams,
   runOneShotMintTx,
   serialiseGovDatum,
   serialiseIAssetDatum,
-  serialiseInterestOracleDatum,
-  serialisePriceOracleDatum,
-  serialiseStabilityPoolDatum,
-  StabilityPoolContent,
   StabilityPoolParamsSP,
-  StakingParams,
+  StakingParamsSP,
+  startInterestOracle,
   SystemParams,
   toSystemParamsAsset,
-  TreasuryContract,
-  TreasuryParams,
+  TreasuryParamsSP,
   VersionRecordParams,
 } from '../../src';
 import { mkAuthTokenPolicy } from '../../src/scripts/auth-token-policy';
-import { StakingContract } from '../../src/contracts/staking';
-import { serialiseStakingDatum } from '../../src/types/indigo/staking';
 import { mkIAssetTokenPolicy } from '../../src/scripts/iasset-policy';
-import { mkPriceOracleValidator } from '../../src/scripts/price-oracle-validator';
-import { mkVersionRecordTokenPolicy } from '../../src/scripts/version-record-policy';
-import { mkVersionRegistryValidator } from '../../src/scripts/version-registry';
-import { mkExecuteValidatorFromSP } from '../../src/scripts/execute-validator';
-import { mkGovValidatorFromSP } from '../../src/scripts/gov-validator';
-import { mkStabilityPoolValidatorFromSP } from '../../src/scripts/stability-pool-validator';
+import {
+  mkVersionRecordTokenPolicy,
+  mkVersionRegistryValidator,
+} from '../../src/contracts/version-registry/scripts';
+import { mkGovValidatorFromSP } from '../../src/contracts/gov/scripts';
+import { mkStabilityPoolValidatorFromSP } from '../../src/contracts/stability-pool/scripts';
+import { runAndAwaitTxBuilder } from '../test-helpers';
+import { startPriceOracleTx } from '../../src/contracts/price-oracle/transactions';
+import { serialiseStakingDatum } from '../../src/contracts/staking/types-new';
+import {
+  initEpochToScaleToSumMap,
+  initSpSnapshot,
+} from '../../src/contracts/stability-pool/helpers';
+import {
+  serialiseStabilityPoolDatum,
+  StabilityPoolContent,
+} from '../../src/contracts/stability-pool/types-new';
+import { InitialAsset } from '../mock/assets-mock';
+import { mkStakingValidatorFromSP } from '../../src/contracts/staking/scripts';
 
 const indyTokenName = 'INDY';
 const daoTokenName = 'DAO';
@@ -77,73 +85,16 @@ const accountTokenName = 'SP_ACCOUNT';
 
 const totalIndySupply = 35000000000000n;
 // const totalIndyDistribution = 0n;
-const treasuryIndyAmount = 0n;
+const treasuryIndyAmount = 100_000n;
 
 const numCdpCreators = 2n;
 const numCollectors = 2n;
 
-type InitialAsset = {
-  name: string;
-  priceOracle: {
-    tokenName: string;
-    startPrice: bigint;
-    params: {
-      biasTime: bigint;
-      expirationTime: bigint;
-    };
-  };
-  initerestOracle: {
-    tokenName: string;
-    initialInterestRate: bigint;
-    params: {
-      biasTime: bigint;
-    };
-  };
-  redemptionRatioPercentage: bigint;
-  maintenanceRatioPercentage: bigint;
-  liquidationRatioPercentage: bigint;
-  debtMintingFeePercentage: bigint;
-  liquidationProcessingFeePercentage: bigint;
-  stabilityPoolWithdrawalFeePercentage: bigint;
-  redemptionReimbursementPercentage: bigint;
-  redemptionProcessingFeePercentage: bigint;
-  interestCollectorPortionPercentage: bigint;
-  firstAsset: boolean;
-  nextAsset?: string;
+export type AssetInfo = {
+  iassetTokenNameAscii: string;
+  oracleParams: PriceOracleParams;
 };
 
-const initialAssets: InitialAsset[] = [
-  {
-    name: 'iUSD',
-    priceOracle: {
-      tokenName: 'iUSD_ORACLE',
-      startPrice: 1_000_000n,
-      params: {
-        biasTime: 120_000n,
-        expirationTime: 1_800_000n,
-      },
-    },
-    initerestOracle: {
-      tokenName: 'iUSD_ORACLE',
-      initialInterestRate: 1_000_000n,
-      params: {
-        biasTime: 120_000n,
-      },
-    },
-    redemptionRatioPercentage: 200_000_000n,
-    maintenanceRatioPercentage: 150_000_000n,
-    liquidationRatioPercentage: 120_000_000n,
-    debtMintingFeePercentage: 500_000n,
-    liquidationProcessingFeePercentage: 2_000_000n,
-    stabilityPoolWithdrawalFeePercentage: 500_000n,
-    redemptionReimbursementPercentage: 1_000_000n,
-    redemptionProcessingFeePercentage: 1_000_000n,
-    interestCollectorPortionPercentage: 40_000_000n,
-    firstAsset: true,
-    nextAsset: null,
-  },
-];
-
 const alwaysFailValidatorHash =
   'ea84d625650d066e1645e3e81d9c70a73f9ed837bd96dc49850ae744';
 
@@ -167,11 +118,11 @@ async function initScriptRef(
   validator: SpendingValidator,
 ): Promise<Input> {
   const tx = lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network, {
+    credentialToAddress(lucid.config().network!, {
       hash: alwaysFailValidatorHash,
       type: 'Script',
     }),
-    null,
+    undefined,
     undefined,
     validator,
   );
@@ -191,15 +142,21 @@ async function initScriptRef(
 
 async function initCollector(
   lucid: LucidEvolution,
-  collectorParams: CollectorParams,
+  collectorParams: CollectorParamsSP,
 ): Promise<void> {
   const tx = lucid.newTx();
 
   for (let i = 0; i < Number(numCollectors); i++) {
-    tx.pay.ToContract(CollectorContract.address(collectorParams, lucid), {
-      kind: 'inline',
-      value: Data.to(new Constr(0, [])),
-    });
+    tx.pay.ToContract(
+      createScriptAddress(
+        lucid.config().network!,
+        validatorToScriptHash(mkCollectorValidatorFromSP(collectorParams)),
+      ),
+      {
+        kind: 'inline',
+        value: Data.to(new Constr(0, [])),
+      },
+    );
   }
 
   const txHash = await tx
@@ -218,7 +175,7 @@ async function initCDPCreator(
 
   for (let i = 0; i < Number(numCdpCreators); i++) {
     tx.pay.ToContract(
-      credentialToAddress(lucid.config().network, {
+      credentialToAddress(lucid.config().network!, {
         hash: validatorToScriptHash(
           mkCDPCreatorValidatorFromSP(cdpCreatorParams),
         ),
@@ -242,14 +199,14 @@ async function initCDPCreator(
 
 async function initTreasury(
   lucid: LucidEvolution,
-  treasuryParams: TreasuryParams,
+  treasuryParams: TreasuryParamsSP,
   daoAsset: AssetClass,
   indyAsset: AssetClass,
   treasuryIndyAmount: bigint,
 ): Promise<void> {
   const tx = lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network, {
-      hash: TreasuryContract.validatorHash(treasuryParams),
+    credentialToAddress(lucid.config().network!, {
+      hash: validatorToScriptHash(mkTreasuryValidatorFromSP(treasuryParams)),
       type: 'Script',
     }),
     { kind: 'inline', value: Data.to(new Constr(0, [])) },
@@ -269,18 +226,20 @@ async function initTreasury(
 
 async function initStakingManager(
   lucid: LucidEvolution,
-  stakingParams: StakingParams,
+  stakingParams: StakingParamsSP,
 ): Promise<void> {
   const txHash = await lucid
     .newTx()
     .pay.ToContract(
-      StakingContract.address(stakingParams, lucid),
+      createScriptAddress(
+        lucid.config().network!,
+        validatorToScriptHash(mkStakingValidatorFromSP(stakingParams)),
+      ),
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          StakingManager: {
-            content: { totalStake: 0n, managerSnapshot: { snapshotAda: 0n } },
-          },
+          totalStake: 0n,
+          managerSnapshot: { snapshotAda: 0n },
         }),
       },
       {
@@ -296,128 +255,55 @@ async function initStakingManager(
   await lucid.awaitTx(txHash);
 }
 
-async function startPriceOracleTx(
-  lucid: LucidEvolution,
-  assetName: string,
-  startPrice: bigint,
-  oracleParams: PriceOracleParams,
-  now: number = Date.now(),
-): Promise<string> {
-  const oraclePolicyId = await mintOneTimeToken(lucid, fromText(assetName), 1n);
-  const oracleValidator = mkPriceOracleValidator(oracleParams);
-
-  const oracleDatum: PriceOracleDatum = {
-    price: {
-      getOnChainInt: startPrice,
-    },
-    expiration: BigInt(now) + oracleParams.expiration,
-  };
-
-  const tx = lucid.newTx().pay.ToContract(
-    validatorToAddress(lucid.config().network, oracleValidator),
-    { kind: 'inline', value: serialisePriceOracleDatum(oracleDatum) },
-    {
-      lovelace: 5_000_000n,
-      [oraclePolicyId + fromText(assetName)]: 1n,
-    },
-  );
-
-  const txHash = await tx
-    .complete()
-    .then((tx) => tx.sign.withWallet().complete())
-    .then((tx) => tx.submit());
-
-  await lucid.awaitTx(txHash);
-
-  return oraclePolicyId;
-}
-
-async function startInterestOracleTx(
-  lucid: LucidEvolution,
-  assetName: string,
-  initialInterestRate: bigint,
-  oracleParams: InterestOracleParams,
-): Promise<string> {
-  const oraclePolicyId = await mintOneTimeToken(lucid, fromText(assetName), 1n);
-  const oracleValidator = mkInterestOracleValidator(oracleParams);
-
-  const oracleDatum: InterestOracleDatum = {
-    unitaryInterest: 0n,
-    lastUpdated: 0n,
-    interestRate: {
-      getOnChainInt: initialInterestRate,
-    },
-  };
-
-  const tx = lucid.newTx().pay.ToContract(
-    validatorToAddress(lucid.config().network, oracleValidator),
-    { kind: 'inline', value: serialiseInterestOracleDatum(oracleDatum) },
-    {
-      lovelace: 5_000_000n,
-      [oraclePolicyId + fromText(assetName)]: 1n,
-    },
-  );
-
-  const txHash = await tx
-    .complete()
-    .then((tx) => tx.sign.withWallet().complete())
-    .then((tx) => tx.submit());
-
-  await lucid.awaitTx(txHash);
-
-  return oraclePolicyId;
-}
-
 async function initializeAsset(
   lucid: LucidEvolution,
-  cdpParams: CdpParams,
+  cdpParams: CdpParamsSP,
   iassetToken: AssetClass,
   stabilityPoolParams: StabilityPoolParamsSP,
   stabilityPoolToken: AssetClass,
   asset: InitialAsset,
   now: number = Date.now(),
-): Promise<void> {
+): Promise<AssetInfo> {
   const [pkh, _] = await addrDetails(lucid);
-  const priceOracleTokenName = asset.name + '_ORACLE';
-  const priceOraclePolicyId = await startPriceOracleTx(
+  const priceOracleParams: PriceOracleParams = {
+    owner: pkh.hash,
+    biasTime: asset.priceOracle.params.biasTime,
+    expiration: asset.priceOracle.params.expirationTime,
+  };
+
+  const [priceOracleStartTx, priceOracleNft] = await startPriceOracleTx(
     lucid,
-    priceOracleTokenName,
-    asset.priceOracle.startPrice,
+    asset.name + '_ORACLE',
     {
-      owner: pkh.hash,
-      biasTime: asset.priceOracle.params.biasTime,
-      expiration: asset.priceOracle.params.expirationTime,
+      getOnChainInt: asset.priceOracle.startPrice,
     },
+    priceOracleParams,
     now,
   );
+  await runAndAwaitTxBuilder(lucid, priceOracleStartTx);
 
   const interestOracleTokenName = asset.name + '_ORACLE';
-  const interestOraclePolicyId = await startInterestOracleTx(
-    lucid,
-    interestOracleTokenName,
+  const [startInterestOracleTx, interestOracleNft] = await startInterestOracle(
+    0n,
     asset.initerestOracle.initialInterestRate,
+    0n,
     {
       owner: pkh.hash,
       biasTime: asset.priceOracle.params.biasTime,
     },
+    lucid,
+    interestOracleTokenName,
   );
+  await runAndAwaitTxBuilder(lucid, startInterestOracleTx);
 
   const iassetDatum: IAssetContent = {
     assetName: fromText(asset.name),
     price: {
       Oracle: {
-        oracleNft: {
-          asset: {
-            currencySymbol: priceOraclePolicyId,
-            tokenName: fromText(priceOracleTokenName),
-          },
-        },
+        content: priceOracleNft,
       },
     },
-    interestOracleNft: {
-      currencySymbol: interestOraclePolicyId,
-      tokenName: fromText(interestOracleTokenName),
-    },
+    interestOracleNft: interestOracleNft,
     redemptionRatio: { getOnChainInt: asset.redemptionRatioPercentage },
     maintenanceRatio: { getOnChainInt: asset.maintenanceRatioPercentage },
     liquidationRatio: { getOnChainInt: asset.liquidationRatioPercentage },
@@ -444,7 +330,10 @@ async function initializeAsset(
   const assetTx = lucid
     .newTx()
     .pay.ToContract(
-      CDPContract.address(cdpParams, lucid),
+      createScriptAddress(
+        lucid.config().network!,
+        validatorToScriptHash(mkCdpValidatorFromSP(cdpParams)),
+      ),
       { kind: 'inline', value: serialiseIAssetDatum(iassetDatum) },
       { [iassetToken.currencySymbol + iassetToken.tokenName]: 1n },
     );
@@ -457,19 +346,13 @@ async function initializeAsset(
   await lucid.awaitTx(assetTxHash);
 
   const stabilityPoolDatum: StabilityPoolContent = {
-    asset: fromText(asset.name),
-    snapshot: {
-      productVal: { value: 1n },
-      depositVal: { value: 0n },
-      sumVal: { value: 0n },
-      epoch: 0n,
-      scale: 0n,
-    },
-    epochToScaleToSum: new Map(),
+    asset: fromHex(fromText(asset.name)),
+    poolSnapshot: initSpSnapshot,
+    epochToScaleToSum: initEpochToScaleToSumMap(),
   };
 
   const spTx = lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network, {
+    credentialToAddress(lucid.config().network!, {
       hash: validatorToScriptHash(
         mkStabilityPoolValidatorFromSP(stabilityPoolParams),
       ),
@@ -477,9 +360,7 @@ async function initializeAsset(
     }),
     {
       kind: 'inline',
-      value: serialiseStabilityPoolDatum({
-        StabilityPool: { content: stabilityPoolDatum },
-      }),
+      value: serialiseStabilityPoolDatum({ StabilityPool: stabilityPoolDatum }),
     },
     {
       [stabilityPoolToken.currencySymbol + stabilityPoolToken.tokenName]: 1n,
@@ -492,12 +373,15 @@ async function initializeAsset(
     .then((spTx) => spTx.submit());
 
   await lucid.awaitTx(spTxHash);
+
+  return { iassetTokenNameAscii: asset.name, oracleParams: priceOracleParams };
 }
 
 async function initGovernance(
   lucid: LucidEvolution,
   governanceParams: GovParamsSP,
   govToken: AssetClass,
+  initialAssets: InitialAsset[],
 ): Promise<void> {
   const datum: GovDatum = {
     currentProposal: 0n,
@@ -505,12 +389,12 @@ async function initGovernance(
     protocolParams: {
       effectiveDelay: 1_000n,
       expirationPeriod: 180_000n,
-      proposalDeposit: 0n,
-      proposingPeriod: 8_000n,
+      proposalDeposit: 1_000n,
+      proposingPeriod: 100_000n,
       collateralFeePercentage: {
         getOnChainInt: 1_500_000n,
       },
-      votingPeriod: 10_000n,
+      votingPeriod: 1000_000n,
       totalShards: 4n,
       minimumQuorum: 100_000n,
       maxTreasuryLovelaceSpend: 10_000_000n,
@@ -521,7 +405,7 @@ async function initGovernance(
     iassetsCount: BigInt(initialAssets.length),
   };
   const tx = lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network, {
+    credentialToAddress(lucid.config().network!, {
       hash: validatorToScriptHash(mkGovValidatorFromSP(governanceParams)),
       type: 'Script',
     }),
@@ -577,8 +461,9 @@ async function mintAuthTokenDirect(
 
 export async function init(
   lucid: LucidEvolution,
+  initialAssets: InitialAsset[],
   now: number = Date.now(),
-): Promise<SystemParams> {
+): Promise<[SystemParams, AssetInfo[]]> {
   const indyAsset: AssetClass = {
     currencySymbol: await mintOneTimeToken(
       lucid,
@@ -689,15 +574,15 @@ export async function init(
     tokenName: fromText(stakingTokenName),
   };
 
-  const collectorParams: CollectorParams = {
+  const collectorParams: CollectorParamsSP = {
     stakingManagerNFT: toSystemParamsAsset(stakingManagerAsset),
     stakingToken: toSystemParamsAsset(stakingToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
   };
-  const collectorValidator = CollectorContract.validator(collectorParams);
-  const collectorValHash = CollectorContract.validatorHash(collectorParams);
+  const collectorValidator = mkCollectorValidatorFromSP(collectorParams);
+  const collectorValHash = validatorToScriptHash(collectorValidator);
 
-  const stakingParams: StakingParams = {
+  const stakingParams: StakingParamsSP = {
     stakingManagerNFT: toSystemParamsAsset(stakingManagerAsset),
     stakingToken: toSystemParamsAsset(stakingToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
@@ -705,7 +590,9 @@ export async function init(
     indyToken: toSystemParamsAsset(indyAsset),
     collectorValHash: collectorValHash,
   };
-  const stakingValHash = StakingContract.validatorHash(stakingParams);
+  const stakingValHash = validatorToScriptHash(
+    mkStakingValidatorFromSP(stakingParams),
+  );
 
   await initStakingManager(lucid, stakingParams);
 
@@ -750,14 +637,14 @@ export async function init(
     mkStabilityPoolValidatorFromSP(stabilityPoolParams);
   const stabilityPoolValHash = validatorToScriptHash(stabilityPoolValidator);
 
-  const treasuryParams: TreasuryParams = {
+  const treasuryParams: TreasuryParamsSP = {
     upgradeToken: toSystemParamsAsset(upgradeToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
-    treasuryUtxosStakeCredential: null,
+    treasuryUtxosStakeCredential: undefined,
   };
 
-  const treasuryValidator = TreasuryContract.validator(treasuryParams);
-  const treasuryValHash = TreasuryContract.validatorHash(treasuryParams);
+  const treasuryValidator = mkTreasuryValidatorFromSP(treasuryParams);
+  const treasuryValHash = validatorToScriptHash(treasuryValidator);
 
   await initTreasury(
     lucid,
@@ -767,7 +654,7 @@ export async function init(
     treasuryIndyAmount,
   );
 
-  const cdpParams: CdpParams = {
+  const cdpParams: CdpParamsSP = {
     cdpAuthToken: toSystemParamsAsset(cdpToken),
     cdpAssetSymbol: { unCurrencySymbol: assetSymbol },
     iAssetAuthToken: toSystemParamsAsset(iassetToken),
@@ -782,7 +669,7 @@ export async function init(
     biasTime: 120_000,
     treasuryValHash: treasuryValHash,
   };
-  const cdpValHash = CDPContract.validatorHash(cdpParams);
+  const cdpValHash = validatorToScriptHash(mkCdpValidatorFromSP(cdpParams));
 
   const cdpCreatorParams: CDPCreatorParamsSP = {
     cdpCreatorNft: toSystemParamsAsset(cdpCreatorAsset),
@@ -801,6 +688,7 @@ export async function init(
   await initCDPCreator(lucid, cdpCreatorParams);
   await initCollector(lucid, collectorParams);
 
+  const assetInfos = [];
   if (initialAssets.length > 0) {
     await mintAuthTokenDirect(lucid, govNftAsset, pollManagerTokenName, 1n);
     await mintAuthTokenDirect(lucid, pollToken, upgradeTokenName, 1n);
@@ -814,7 +702,7 @@ export async function init(
         1n,
       );
 
-      await initializeAsset(
+      const assetInfo = await initializeAsset(
         lucid,
         cdpParams,
         iassetToken,
@@ -823,6 +711,8 @@ export async function init(
         asset,
         now,
       );
+
+      assetInfos.push(assetInfo);
     }
 
     await mintAuthTokenDirect(lucid, pollToken, upgradeTokenName, -1n);
@@ -881,133 +771,145 @@ export async function init(
   const govValidator = mkGovValidatorFromSP(govParams);
   const govValHash = validatorToScriptHash(govValidator);
 
-  await initGovernance(lucid, govParams, govNftAsset);
+  await initGovernance(lucid, govParams, govNftAsset, initialAssets);
 
-  return {
-    cdpParams: cdpParams,
-    cdpCreatorParams: cdpCreatorParams,
-    collectorParams: collectorParams,
-    executeParams: executeParams,
-    govParams: govParams,
-    stakingParams: stakingParams,
-    stabilityPoolParams: stabilityPoolParams,
-    treasuryParams: treasuryParams,
-    pollShardParams: pollShardParams,
-    pollManagerParams: pollManagerParams,
-    indyToken: toSystemParamsAsset(indyAsset),
-    distributionParams: {
-      treasuryIndyAmount: 1_575_000_000_000,
-      totalINDYSupply: 35_000_000_000_000,
-      initialIndyDistribution: 1_575_000_000_000,
-    },
-    versionRecordParams: versionRecordParams,
-    startTime: {
-      slot: 0,
-      blockHeader: '',
-    },
-    scriptReferences: {
-      cdpCreatorValidatorRef: {
-        input: await initScriptRef(lucid, cdpCreatorValidator),
-      },
-      cdpValidatorRef: {
-        input: await initScriptRef(lucid, CDPContract.validator(cdpParams)),
-      },
-      collectorValidatorRef: {
-        input: await initScriptRef(lucid, collectorValidator),
-      },
-      executeValidatorRef: {
-        input: await initScriptRef(lucid, executeValidator),
-      },
-      govValidatorRef: {
-        input: await initScriptRef(lucid, govValidator),
-      },
-      pollShardValidatorRef: {
-        input: await initScriptRef(lucid, pollShardValidator),
-      },
-      pollManagerValidatorRef: {
-        input: await initScriptRef(lucid, pollManagerValidator),
-      },
-      iAssetTokenPolicyRef: {
-        input: await initScriptRef(lucid, assetSymbolPolicy),
-      },
-      stakingValidatorRef: {
-        input: await initScriptRef(
-          lucid,
-          StakingContract.validator(stakingParams),
-        ),
-      },
-      stabilityPoolValidatorRef: {
-        input: await initScriptRef(lucid, stabilityPoolValidator),
-      },
-      treasuryValidatorRef: {
-        input: await initScriptRef(lucid, treasuryValidator),
-      },
-      governanceValidatorRef: {
-        input: await initScriptRef(lucid, govValidator),
-      },
-      versionRegistryValidatorRef: {
-        input: await initScriptRef(lucid, versionRegistryValidator),
-      },
-      versionRecordTokenPolicyRef: {
-        input: await initScriptRef(lucid, versionRecordTokenPolicy),
-      },
-      liquidityValidatorRef: {
-        input: undefined,
+  const lrpParams: LrpParamsSP = {
+    iassetNft: cdpParams.iAssetAuthToken,
+    iassetPolicyId: cdpParams.cdpAssetSymbol,
+    minRedemptionLovelacesAmt: 10_000_000n,
+    versionRecordToken: cdpParams.versionRecordToken,
+  };
+
+  const lrpValidator = mkLrpValidatorFromSP(lrpParams);
+  const lrpValHash = validatorToScriptHash(lrpValidator);
+
+  return [
+    {
+      cdpParams: cdpParams,
+      cdpCreatorParams: cdpCreatorParams,
+      collectorParams: collectorParams,
+      executeParams: executeParams,
+      govParams: govParams,
+      stakingParams: stakingParams,
+      stabilityPoolParams: stabilityPoolParams,
+      treasuryParams: treasuryParams,
+      pollShardParams: pollShardParams,
+      pollManagerParams: pollManagerParams,
+      indyToken: toSystemParamsAsset(indyAsset),
+      distributionParams: {
+        treasuryIndyAmount: 1_575_000_000_000,
+        totalINDYSupply: 35_000_000_000_000,
+        initialIndyDistribution: 1_575_000_000_000,
       },
-      vestingValidatorRef: {
-        input: undefined,
+      lrpParams: lrpParams,
+      versionRecordParams: versionRecordParams,
+      startTime: {
+        slot: 0,
+        blockHeader: '',
       },
-      authTokenPolicies: {
-        cdpAuthTokenRef: {
-          input: await initScriptRef(lucid, cdpTokenPolicy),
-        },
-        iAssetAuthTokenRef: {
-          input: await initScriptRef(lucid, iassetTokenPolicy),
+      scriptReferences: {
+        lrpValidatorRef: {
+          input: await initScriptRef(lucid, lrpValidator),
         },
-        accountTokenRef: {
-          input: await initScriptRef(lucid, accountTokenPolicy),
+        cdpCreatorValidatorRef: {
+          input: await initScriptRef(lucid, cdpCreatorValidator),
         },
-        stabilityPoolAuthTokenRef: {
-          input: await initScriptRef(lucid, stabilityPoolTokenPolicy),
+        cdpValidatorRef: {
+          input: await initScriptRef(lucid, mkCdpValidatorFromSP(cdpParams)),
         },
-        pollManagerTokenRef: {
-          input: await initScriptRef(lucid, pollTokenPolicy),
+        collectorValidatorRef: {
+          input: await initScriptRef(lucid, collectorValidator),
         },
-        stakingTokenRef: {
-          input: await initScriptRef(lucid, stakingTokenPolicy),
+        executeValidatorRef: {
+          input: await initScriptRef(lucid, executeValidator),
         },
-        versionRecordTokenRef: {
-          input: await initScriptRef(lucid, versionRecordTokenPolicy),
+        govValidatorRef: {
+          input: await initScriptRef(lucid, govValidator),
         },
-        iAssetTokenRef: {
-          input: await initScriptRef(lucid, assetSymbolPolicy),
+        pollShardValidatorRef: {
+          input: await initScriptRef(lucid, pollShardValidator),
         },
-        upgradeTokenRef: {
-          input: await initScriptRef(lucid, upgradeTokenPolicy),
+        pollManagerValidatorRef: {
+          input: await initScriptRef(lucid, pollManagerValidator),
         },
-        stabilityPoolTokenRef: {
-          input: await initScriptRef(lucid, stabilityPoolTokenPolicy),
+        iAssetTokenPolicyRef: {
+          input: await initScriptRef(lucid, assetSymbolPolicy),
         },
-        snapshotEpochToScaleToSumTokenRef: {
+        stakingValidatorRef: {
           input: await initScriptRef(
             lucid,
-            snapshotEpochToScaleToSumTokenPolicy,
+            mkStakingValidatorFromSP(stakingParams),
           ),
         },
+        stabilityPoolValidatorRef: {
+          input: await initScriptRef(lucid, stabilityPoolValidator),
+        },
+        treasuryValidatorRef: {
+          input: await initScriptRef(lucid, treasuryValidator),
+        },
+        governanceValidatorRef: {
+          input: await initScriptRef(lucid, govValidator),
+        },
+        versionRegistryValidatorRef: {
+          input: await initScriptRef(lucid, versionRegistryValidator),
+        },
+        versionRecordTokenPolicyRef: {
+          input: await initScriptRef(lucid, versionRecordTokenPolicy),
+        },
+        authTokenPolicies: {
+          cdpAuthTokenRef: {
+            input: await initScriptRef(lucid, cdpTokenPolicy),
+          },
+          iAssetAuthTokenRef: {
+            input: await initScriptRef(lucid, iassetTokenPolicy),
+          },
+          accountTokenRef: {
+            input: await initScriptRef(lucid, accountTokenPolicy),
+          },
+          stabilityPoolAuthTokenRef: {
+            input: await initScriptRef(lucid, stabilityPoolTokenPolicy),
+          },
+          pollManagerTokenRef: {
+            input: await initScriptRef(lucid, pollTokenPolicy),
+          },
+          stakingTokenRef: {
+            input: await initScriptRef(lucid, stakingTokenPolicy),
+          },
+          versionRecordTokenRef: {
+            input: await initScriptRef(lucid, versionRecordTokenPolicy),
+          },
+          iAssetTokenRef: {
+            input: await initScriptRef(lucid, assetSymbolPolicy),
+          },
+          upgradeTokenRef: {
+            input: await initScriptRef(lucid, upgradeTokenPolicy),
+          },
+          stabilityPoolTokenRef: {
+            input: await initScriptRef(lucid, stabilityPoolTokenPolicy),
+          },
+          snapshotEpochToScaleToSumTokenRef: {
+            input: await initScriptRef(
+              lucid,
+              snapshotEpochToScaleToSumTokenPolicy,
+            ),
+          },
+        },
       },
-    },
-    validatorHashes: {
-      cdpCreatorHash: cdpCreatorValHash,
-      cdpHash: cdpValHash,
-      executeHash: executeValHash,
-      govHash: govValHash,
-      pollShardHash: pollShardValHash,
-      pollManagerHash: pollManagerValHash,
-      treasuryHash: treasuryValHash,
-      stabilityPoolHash: stabilityPoolValHash,
-      stakingHash: stakingValHash,
-      collectorHash: collectorValHash,
-      versionRegistryHash: versionRegistryValHash,
-    },
-  } as SystemParams;
+      validatorHashes: {
+        cdpCreatorHash: cdpCreatorValHash,
+        cdpHash: cdpValHash,
+        executeHash: executeValHash,
+        govHash: govValHash,
+        pollShardHash: pollShardValHash,
+        pollManagerHash: pollManagerValHash,
+        treasuryHash: treasuryValHash,
+        stabilityPoolHash: stabilityPoolValHash,
+        stakingHash: stakingValHash,
+        collectorHash: collectorValHash,
+        versionRegistryHash: versionRegistryValHash,
+        lrpHash: lrpValHash,
+      },
+    } as SystemParams,
+    assetInfos,
+  ];
 }