@indigo-labs/indigo-sdk 0.1.21 → 0.1.23

package/tests/endpoints/initialize.ts

@@ -2,70 +2,62 @@ import {
   Constr,
   credentialToAddress,
   Data,
-  fromHex,
   fromText,
   LucidEvolution,
   mintingPolicyToId,
   PolicyId,
   SpendingValidator,
+  validatorToAddress,
   validatorToScriptHash,
 } from '@lucid-evolution/lucid';
 import {
   addrDetails,
   AssetClass,
+  CDPContract,
   CDPCreatorParamsSP,
-  CdpParamsSP,
-  CollectorParamsSP,
-  createScriptAddress,
+  CdpParams,
+  CollectorContract,
+  CollectorParams,
   ExecuteParamsSP,
   GovDatum,
   GovParamsSP,
   IAssetContent,
   Input,
-  LrpParamsSP,
+  InterestOracleDatum,
+  InterestOracleParams,
   mkCDPCreatorValidatorFromSP,
-  mkCdpValidatorFromSP,
-  mkCollectorValidatorFromSP,
-  mkExecuteValidatorFromSP,
-  mkLrpValidatorFromSP,
+  mkInterestOracleValidator,
   mkPollManagerValidatorFromSP,
   mkPollShardValidatorFromSP,
-  mkTreasuryValidatorFromSP,
   PollManagerParamsSP,
   PollShardParamsSP,
+  PriceOracleDatum,
   PriceOracleParams,
   runOneShotMintTx,
   serialiseGovDatum,
   serialiseIAssetDatum,
+  serialiseInterestOracleDatum,
+  serialisePriceOracleDatum,
+  serialiseStabilityPoolDatum,
+  StabilityPoolContent,
   StabilityPoolParamsSP,
-  StakingParamsSP,
-  startInterestOracle,
+  StakingParams,
   SystemParams,
   toSystemParamsAsset,
-  TreasuryParamsSP,
+  TreasuryContract,
+  TreasuryParams,
   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 {
-  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';
+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';
 
 const indyTokenName = 'INDY';
 const daoTokenName = 'DAO';
@@ -85,16 +77,73 @@ const accountTokenName = 'SP_ACCOUNT';
 
 const totalIndySupply = 35000000000000n;
 // const totalIndyDistribution = 0n;
-const treasuryIndyAmount = 100_000n;
+const treasuryIndyAmount = 0n;
 
 const numCdpCreators = 2n;
 const numCollectors = 2n;
 
-export type AssetInfo = {
-  iassetTokenNameAscii: string;
-  oracleParams: PriceOracleParams;
+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;
 };
 
+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';
 
@@ -118,11 +167,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',
     }),
-    undefined,
+    null,
     undefined,
     validator,
   );
@@ -142,21 +191,15 @@ async function initScriptRef(
 
 async function initCollector(
   lucid: LucidEvolution,
-  collectorParams: CollectorParamsSP,
+  collectorParams: CollectorParams,
 ): Promise<void> {
   const tx = lucid.newTx();
 
   for (let i = 0; i < Number(numCollectors); i++) {
-    tx.pay.ToContract(
-      createScriptAddress(
-        lucid.config().network!,
-        validatorToScriptHash(mkCollectorValidatorFromSP(collectorParams)),
-      ),
-      {
-        kind: 'inline',
-        value: Data.to(new Constr(0, [])),
-      },
-    );
+    tx.pay.ToContract(CollectorContract.address(collectorParams, lucid), {
+      kind: 'inline',
+      value: Data.to(new Constr(0, [])),
+    });
   }
 
   const txHash = await tx
@@ -175,7 +218,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),
         ),
@@ -199,14 +242,14 @@ async function initCDPCreator(
 
 async function initTreasury(
   lucid: LucidEvolution,
-  treasuryParams: TreasuryParamsSP,
+  treasuryParams: TreasuryParams,
   daoAsset: AssetClass,
   indyAsset: AssetClass,
   treasuryIndyAmount: bigint,
 ): Promise<void> {
   const tx = lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network!, {
-      hash: validatorToScriptHash(mkTreasuryValidatorFromSP(treasuryParams)),
+    credentialToAddress(lucid.config().network, {
+      hash: TreasuryContract.validatorHash(treasuryParams),
       type: 'Script',
     }),
     { kind: 'inline', value: Data.to(new Constr(0, [])) },
@@ -226,20 +269,18 @@ async function initTreasury(
 
 async function initStakingManager(
   lucid: LucidEvolution,
-  stakingParams: StakingParamsSP,
+  stakingParams: StakingParams,
 ): Promise<void> {
   const txHash = await lucid
     .newTx()
     .pay.ToContract(
-      createScriptAddress(
-        lucid.config().network!,
-        validatorToScriptHash(mkStakingValidatorFromSP(stakingParams)),
-      ),
+      StakingContract.address(stakingParams, lucid),
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          totalStake: 0n,
-          managerSnapshot: { snapshotAda: 0n },
+          StakingManager: {
+            content: { totalStake: 0n, managerSnapshot: { snapshotAda: 0n } },
+          },
         }),
       },
       {
@@ -255,55 +296,128 @@ 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: CdpParamsSP,
+  cdpParams: CdpParams,
   iassetToken: AssetClass,
   stabilityPoolParams: StabilityPoolParamsSP,
   stabilityPoolToken: AssetClass,
   asset: InitialAsset,
   now: number = Date.now(),
-): Promise<AssetInfo> {
+): Promise<void> {
   const [pkh, _] = await addrDetails(lucid);
-  const priceOracleParams: PriceOracleParams = {
-    owner: pkh.hash,
-    biasTime: asset.priceOracle.params.biasTime,
-    expiration: asset.priceOracle.params.expirationTime,
-  };
-
-  const [priceOracleStartTx, priceOracleNft] = await startPriceOracleTx(
+  const priceOracleTokenName = asset.name + '_ORACLE';
+  const priceOraclePolicyId = await startPriceOracleTx(
     lucid,
-    asset.name + '_ORACLE',
+    priceOracleTokenName,
+    asset.priceOracle.startPrice,
     {
-      getOnChainInt: asset.priceOracle.startPrice,
+      owner: pkh.hash,
+      biasTime: asset.priceOracle.params.biasTime,
+      expiration: asset.priceOracle.params.expirationTime,
     },
-    priceOracleParams,
     now,
   );
-  await runAndAwaitTxBuilder(lucid, priceOracleStartTx);
 
   const interestOracleTokenName = asset.name + '_ORACLE';
-  const [startInterestOracleTx, interestOracleNft] = await startInterestOracle(
-    0n,
+  const interestOraclePolicyId = await startInterestOracleTx(
+    lucid,
+    interestOracleTokenName,
     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: {
-        content: priceOracleNft,
+        oracleNft: {
+          asset: {
+            currencySymbol: priceOraclePolicyId,
+            tokenName: fromText(priceOracleTokenName),
+          },
+        },
       },
     },
-    interestOracleNft: interestOracleNft,
+    interestOracleNft: {
+      currencySymbol: interestOraclePolicyId,
+      tokenName: fromText(interestOracleTokenName),
+    },
     redemptionRatio: { getOnChainInt: asset.redemptionRatioPercentage },
     maintenanceRatio: { getOnChainInt: asset.maintenanceRatioPercentage },
     liquidationRatio: { getOnChainInt: asset.liquidationRatioPercentage },
@@ -330,10 +444,7 @@ async function initializeAsset(
   const assetTx = lucid
     .newTx()
     .pay.ToContract(
-      createScriptAddress(
-        lucid.config().network!,
-        validatorToScriptHash(mkCdpValidatorFromSP(cdpParams)),
-      ),
+      CDPContract.address(cdpParams, lucid),
       { kind: 'inline', value: serialiseIAssetDatum(iassetDatum) },
       { [iassetToken.currencySymbol + iassetToken.tokenName]: 1n },
     );
@@ -346,13 +457,19 @@ async function initializeAsset(
   await lucid.awaitTx(assetTxHash);
 
   const stabilityPoolDatum: StabilityPoolContent = {
-    asset: fromHex(fromText(asset.name)),
-    poolSnapshot: initSpSnapshot,
-    epochToScaleToSum: initEpochToScaleToSumMap(),
+    asset: fromText(asset.name),
+    snapshot: {
+      productVal: { value: 1n },
+      depositVal: { value: 0n },
+      sumVal: { value: 0n },
+      epoch: 0n,
+      scale: 0n,
+    },
+    epochToScaleToSum: new Map(),
   };
 
   const spTx = lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network!, {
+    credentialToAddress(lucid.config().network, {
       hash: validatorToScriptHash(
         mkStabilityPoolValidatorFromSP(stabilityPoolParams),
       ),
@@ -360,7 +477,9 @@ async function initializeAsset(
     }),
     {
       kind: 'inline',
-      value: serialiseStabilityPoolDatum({ StabilityPool: stabilityPoolDatum }),
+      value: serialiseStabilityPoolDatum({
+        StabilityPool: { content: stabilityPoolDatum },
+      }),
     },
     {
       [stabilityPoolToken.currencySymbol + stabilityPoolToken.tokenName]: 1n,
@@ -373,15 +492,12 @@ 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,
@@ -389,12 +505,12 @@ async function initGovernance(
     protocolParams: {
       effectiveDelay: 1_000n,
       expirationPeriod: 180_000n,
-      proposalDeposit: 1_000n,
-      proposingPeriod: 100_000n,
+      proposalDeposit: 0n,
+      proposingPeriod: 8_000n,
       collateralFeePercentage: {
         getOnChainInt: 1_500_000n,
       },
-      votingPeriod: 1000_000n,
+      votingPeriod: 10_000n,
       totalShards: 4n,
       minimumQuorum: 100_000n,
       maxTreasuryLovelaceSpend: 10_000_000n,
@@ -405,7 +521,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',
     }),
@@ -461,9 +577,8 @@ async function mintAuthTokenDirect(
 
 export async function init(
   lucid: LucidEvolution,
-  initialAssets: InitialAsset[],
   now: number = Date.now(),
-): Promise<[SystemParams, AssetInfo[]]> {
+): Promise<SystemParams> {
   const indyAsset: AssetClass = {
     currencySymbol: await mintOneTimeToken(
       lucid,
@@ -574,15 +689,15 @@ export async function init(
     tokenName: fromText(stakingTokenName),
   };
 
-  const collectorParams: CollectorParamsSP = {
+  const collectorParams: CollectorParams = {
     stakingManagerNFT: toSystemParamsAsset(stakingManagerAsset),
     stakingToken: toSystemParamsAsset(stakingToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
   };
-  const collectorValidator = mkCollectorValidatorFromSP(collectorParams);
-  const collectorValHash = validatorToScriptHash(collectorValidator);
+  const collectorValidator = CollectorContract.validator(collectorParams);
+  const collectorValHash = CollectorContract.validatorHash(collectorParams);
 
-  const stakingParams: StakingParamsSP = {
+  const stakingParams: StakingParams = {
     stakingManagerNFT: toSystemParamsAsset(stakingManagerAsset),
     stakingToken: toSystemParamsAsset(stakingToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
@@ -590,9 +705,7 @@ export async function init(
     indyToken: toSystemParamsAsset(indyAsset),
     collectorValHash: collectorValHash,
   };
-  const stakingValHash = validatorToScriptHash(
-    mkStakingValidatorFromSP(stakingParams),
-  );
+  const stakingValHash = StakingContract.validatorHash(stakingParams);
 
   await initStakingManager(lucid, stakingParams);
 
@@ -637,14 +750,14 @@ export async function init(
     mkStabilityPoolValidatorFromSP(stabilityPoolParams);
   const stabilityPoolValHash = validatorToScriptHash(stabilityPoolValidator);
 
-  const treasuryParams: TreasuryParamsSP = {
+  const treasuryParams: TreasuryParams = {
     upgradeToken: toSystemParamsAsset(upgradeToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
-    treasuryUtxosStakeCredential: undefined,
+    treasuryUtxosStakeCredential: null,
   };
 
-  const treasuryValidator = mkTreasuryValidatorFromSP(treasuryParams);
-  const treasuryValHash = validatorToScriptHash(treasuryValidator);
+  const treasuryValidator = TreasuryContract.validator(treasuryParams);
+  const treasuryValHash = TreasuryContract.validatorHash(treasuryParams);
 
   await initTreasury(
     lucid,
@@ -654,7 +767,7 @@ export async function init(
     treasuryIndyAmount,
   );
 
-  const cdpParams: CdpParamsSP = {
+  const cdpParams: CdpParams = {
     cdpAuthToken: toSystemParamsAsset(cdpToken),
     cdpAssetSymbol: { unCurrencySymbol: assetSymbol },
     iAssetAuthToken: toSystemParamsAsset(iassetToken),
@@ -669,7 +782,7 @@ export async function init(
     biasTime: 120_000,
     treasuryValHash: treasuryValHash,
   };
-  const cdpValHash = validatorToScriptHash(mkCdpValidatorFromSP(cdpParams));
+  const cdpValHash = CDPContract.validatorHash(cdpParams);
 
   const cdpCreatorParams: CDPCreatorParamsSP = {
     cdpCreatorNft: toSystemParamsAsset(cdpCreatorAsset),
@@ -688,7 +801,6 @@ 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);
@@ -702,7 +814,7 @@ export async function init(
         1n,
       );
 
-      const assetInfo = await initializeAsset(
+      await initializeAsset(
         lucid,
         cdpParams,
         iassetToken,
@@ -711,8 +823,6 @@ export async function init(
         asset,
         now,
       );
-
-      assetInfos.push(assetInfo);
     }
 
     await mintAuthTokenDirect(lucid, pollToken, upgradeTokenName, -1n);
@@ -771,145 +881,133 @@ export async function init(
   const govValidator = mkGovValidatorFromSP(govParams);
   const govValHash = validatorToScriptHash(govValidator);
 
-  await initGovernance(lucid, govParams, govNftAsset, initialAssets);
+  await initGovernance(lucid, govParams, govNftAsset);
 
-  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,
+  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),
       },
-      lrpParams: lrpParams,
-      versionRecordParams: versionRecordParams,
-      startTime: {
-        slot: 0,
-        blockHeader: '',
+      cdpValidatorRef: {
+        input: await initScriptRef(lucid, CDPContract.validator(cdpParams)),
       },
-      scriptReferences: {
-        lrpValidatorRef: {
-          input: await initScriptRef(lucid, lrpValidator),
-        },
-        cdpCreatorValidatorRef: {
-          input: await initScriptRef(lucid, cdpCreatorValidator),
+      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,
+      },
+      vestingValidatorRef: {
+        input: undefined,
+      },
+      authTokenPolicies: {
+        cdpAuthTokenRef: {
+          input: await initScriptRef(lucid, cdpTokenPolicy),
         },
-        cdpValidatorRef: {
-          input: await initScriptRef(lucid, mkCdpValidatorFromSP(cdpParams)),
+        iAssetAuthTokenRef: {
+          input: await initScriptRef(lucid, iassetTokenPolicy),
         },
-        collectorValidatorRef: {
-          input: await initScriptRef(lucid, collectorValidator),
+        accountTokenRef: {
+          input: await initScriptRef(lucid, accountTokenPolicy),
         },
-        executeValidatorRef: {
-          input: await initScriptRef(lucid, executeValidator),
+        stabilityPoolAuthTokenRef: {
+          input: await initScriptRef(lucid, stabilityPoolTokenPolicy),
         },
-        govValidatorRef: {
-          input: await initScriptRef(lucid, govValidator),
+        pollManagerTokenRef: {
+          input: await initScriptRef(lucid, pollTokenPolicy),
         },
-        pollShardValidatorRef: {
-          input: await initScriptRef(lucid, pollShardValidator),
+        stakingTokenRef: {
+          input: await initScriptRef(lucid, stakingTokenPolicy),
         },
-        pollManagerValidatorRef: {
-          input: await initScriptRef(lucid, pollManagerValidator),
+        versionRecordTokenRef: {
+          input: await initScriptRef(lucid, versionRecordTokenPolicy),
         },
-        iAssetTokenPolicyRef: {
+        iAssetTokenRef: {
           input: await initScriptRef(lucid, assetSymbolPolicy),
         },
-        stakingValidatorRef: {
+        upgradeTokenRef: {
+          input: await initScriptRef(lucid, upgradeTokenPolicy),
+        },
+        stabilityPoolTokenRef: {
+          input: await initScriptRef(lucid, stabilityPoolTokenPolicy),
+        },
+        snapshotEpochToScaleToSumTokenRef: {
           input: await initScriptRef(
             lucid,
-            mkStakingValidatorFromSP(stakingParams),
+            snapshotEpochToScaleToSumTokenPolicy,
           ),
         },
-        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,
-        lrpHash: lrpValHash,
       },
-    } as SystemParams,
-    assetInfos,
-  ];
+    },
+    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;
 }