@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/src/contracts/initialize/helpers.ts

@@ -1,45 +1,620 @@
-import { LucidEvolution, TxBuilder } from '@lucid-evolution/lucid';
-
-/** Token names used during protocol initialization. */
-export const INDY_TOKEN_NAME = 'INDY';
-export const DAO_TOKEN_NAME = 'DAO';
-export const GOV_NFT_TOKEN_NAME = 'GOV_NFT';
-export const POLL_MANAGER_TOKEN_NAME = 'POLL_MANAGER';
-export const UPGRADE_TOKEN_NAME = 'UPGRADE';
-export const IASSET_TOKEN_NAME = 'IASSET';
-export const STABILITY_POOL_TOKEN_NAME = 'STABILITY_POOL';
-export const VERSION_RECORD_TOKEN_NAME = 'VERSION_RECORD';
-export const CDP_CREATOR_TOKEN_NAME = 'CDP_CREATOR';
-export const CDP_TOKEN_NAME = 'CDP';
-export const STAKING_MANAGER_TOKEN_NAME = 'STAKING_MANAGER';
-export const STAKING_TOKEN_NAME = 'STAKING_POSITION';
-export const SNAPSHOT_EPOCH_TO_SCALE_TO_SUM_TOKEN_NAME =
-  'SNAPSHOT_EPOCH_TO_SCALE_TO_SUM';
-export const ACCOUNT_TOKEN_NAME = 'SP_ACCOUNT';
-
-export const TOTAL_INDY_SUPPLY = 35000000000000n;
-export const TREASURY_INDY_AMOUNT = 100_000n;
-export const NUM_CDP_CREATORS = 2n;
-export const NUM_COLLECTORS = 2n;
-
-/**
- * Script hash of a validator that always fails; used to create script reference UTxOs.
- */
-export const ALWAYS_FAIL_VALIDATOR_HASH =
+import {
+  addAssets,
+  credentialToAddress,
+  Data,
+  fromHex,
+  fromText,
+  LucidEvolution,
+  mintingPolicyToId,
+  PolicyId,
+  SpendingValidator,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import {
+  AssetClass,
+  assetClassToUnit,
+  assetClassValueOf,
+  lovelacesAmt,
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  addrDetails,
+  createScriptAddress,
+  submitTx,
+} from '../../utils/lucid-utils';
+import { runOneShotMintTx } from '../one-shot/transactions';
+import {
+  fromSysParamsCredential,
+  getPythFeedConfig,
+  Input,
+} from '../../types/system-params';
+import type {
+  AssetInfo,
+  CollateralAssetInfo,
+  InitialAssetParam,
+  InitialCollateralAssetParam,
+  InitializeOptions,
+} from './types';
+import type {
+  CdpParamsSP,
+  CollectorParamsSP,
+  PythConfig,
+} from '../../types/system-params';
+import type {
+  CDPCreatorParamsSP,
+  TreasuryParamsSP,
+} from '../../types/system-params';
+import type {
+  IAssetParamsSP,
+  StabilityPoolParamsSP,
+  StakingParamsSP,
+} from '../../types/system-params';
+import type { GovParamsSP } from '../../types/system-params';
+import type { InterestCollectionDatum } from '../interest-collection/types-new';
+import type { PriceOracleParams } from '../price-oracle/types';
+import type { InterestOracleParams } from '../interest-oracle/types';
+import { mkAuthTokenPolicy } from '../../scripts/auth-token-policy';
+import { mkIAssetValidatorFromSP } from '../iasset/scripts';
+import { mkCollectorValidatorFromSP } from '../collector/scripts';
+import { mkCDPCreatorValidatorFromSP } from '../cdp-creator/scripts';
+import { mkTreasuryValidatorFromSP } from '../treasury/scripts';
+import { mkStakingValidatorFromSP } from '../staking/scripts';
+import { mkGovValidatorFromSP } from '../gov/scripts';
+import { mkStabilityPoolValidatorFromSP } from '../stability-pool/scripts';
+import { serialiseInterestCollectionDatum } from '../interest-collection/types-new';
+import { startPriceOracleTx } from '../price-oracle/transactions';
+import { startInterestOracle } from '../interest-oracle/transactions';
+import { serialiseStakingDatum } from '../staking/types-new';
+import { initSpState } from '../stability-pool/helpers';
+import {
+  serialiseStabilityPoolDatum,
+  StabilityPoolContent,
+} from '../stability-pool/types-new';
+import {
+  CollateralAssetContent,
+  IAssetContent,
+  IAssetPriceInfo,
+  serialiseIAssetDatum,
+} from '../iasset/types';
+import { GovDatum, ProtocolParams, serialiseGovDatum } from '../gov/types-new';
+import { match } from 'ts-pattern';
+import { runAndAwaitTxBuilder } from '../../../tests/test-helpers';
+import {
+  serialiseStableswapPoolDatum,
+  StableswapPoolContent,
+} from '../cdp/types-new';
+import { mkCdpValidatorFromSP } from '../cdp/scripts';
+
+const alwaysFailValidatorHash =
   'ea84d625650d066e1645e3e81d9c70a73f9ed837bd96dc49850ae744';
 
-/**
- * Complete, sign, submit a TxBuilder and wait for confirmation.
- * Used by initialize transactions so the contract does not depend on test helpers.
- */
-export async function submitAndAwaitTx(
+/** Default init options used by tests; users must pass explicit options to init(). */
+export const DEFAULT_INIT_OPTIONS: InitializeOptions = {
+  numCdpCreators: 2n,
+  numCollectors: 2n,
+  numInterestCollectors: 2n,
+  numTreasuryUtxos: 5n,
+  treasuryIndyAmount: 1_000_000n,
+  totalIndySupply: 35000000000000n,
+
+  accountCreateFeeLovelaces: 5_000_000n,
+  accountProcessingCooldownMs: 300_000n,
+  accountProcessingBiasTime: 120_000n,
+
+  interestSettlementCooldown: 432_000_000n,
+
+  partialRedemptionExtraFeeLovelace: 10_000_000,
+  biasTime: 1200_000n,
+  gBiasTime: 120_000n,
+
+  interestCollectorUtxoLovelaces: 5_000_000n,
+};
+
+export const INIT_TOKEN_NAMES = {
+  indy: 'INDY',
+  dao: 'DAO',
+  multisigUtxo: 'INTEREST_COLLECTION_ADMIN',
+  govNft: 'GOV_NFT',
+  pollManager: 'POLL_MANAGER',
+  upgrade: 'UPGRADE',
+  iasset: 'IASSET',
+  collateralAsset: 'COLLATERAL_ASSET',
+  stabilityPool: 'STABILITY_POOL',
+  versionRecord: 'VERSION_RECORD',
+  cdpCreator: 'CDP_CREATOR',
+  cdp: 'CDP',
+  stakingManager: 'STAKING_MANAGER',
+  staking: 'STAKING_POSITION',
+  snapshotEpochToScaleToSum: 'SNAPSHOT_EPOCH_TO_SCALE_TO_SUM',
+  account: 'SP_ACCOUNT',
+} as const;
+
+export async function mintOneTimeToken(
+  lucid: LucidEvolution,
+  tokenName: string,
+  amount: bigint,
+): Promise<PolicyId> {
+  const utxos = await lucid.wallet().getUtxos();
+  return await runOneShotMintTx(lucid, {
+    referenceOutRef: {
+      txHash: utxos[0].txHash,
+      outputIdx: BigInt(utxos[0].outputIndex),
+    },
+    mintAmounts: [{ tokenName: tokenName, amount: amount }],
+  });
+}
+
+/** Mint a one-shot token and return its AssetClass. */
+export async function mintOneTimeAsset(
   lucid: LucidEvolution,
-  tx: TxBuilder,
-): Promise<string> {
+  tokenName: string,
+  amount: bigint,
+): Promise<AssetClass> {
+  const policyId = await mintOneTimeToken(lucid, fromText(tokenName), amount);
+  return {
+    currencySymbol: fromHex(policyId),
+    tokenName: fromHex(fromText(tokenName)),
+  };
+}
+
+/** Build an auth-token AssetClass derived from a parent token. */
+export function deriveAuthToken(
+  parent: AssetClass,
+  tokenName: string,
+): AssetClass {
+  const policy = mkAuthTokenPolicy(parent, fromText(tokenName));
+  return {
+    currencySymbol: fromHex(mintingPolicyToId(policy)),
+    tokenName: fromHex(fromText(tokenName)),
+  };
+}
+
+export async function initScriptRef(
+  lucid: LucidEvolution,
+  validator: SpendingValidator,
+): Promise<Input> {
+  const tx = lucid.newTx().pay.ToContract(
+    credentialToAddress(lucid.config().network!, {
+      hash: alwaysFailValidatorHash,
+      type: 'Script',
+    }),
+    undefined,
+    undefined,
+    validator,
+  );
   const txHash = await tx
     .complete()
     .then((t) => t.sign.withWallet().complete())
     .then((t) => t.submit());
   await lucid.awaitTx(txHash);
-  return txHash;
+  return { transactionId: txHash, index: 0 };
+}
+
+export async function initCollector(
+  lucid: LucidEvolution,
+  collectorParams: CollectorParamsSP,
+  numCollectors: bigint,
+): 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.void(),
+      },
+    );
+  }
+
+  await submitTx(lucid, tx);
+}
+
+export async function initInterestCollector(
+  lucid: LucidEvolution,
+  interestCollectionValHash: string,
+  multisigUtxoNft: AssetClass,
+  numInterestCollectors: bigint,
+  interestCollectorUtxoLovelaces: bigint,
+): Promise<void> {
+  const [pkh, _] = await addrDetails(lucid);
+  const interestCollectionAdminDatum: InterestCollectionDatum = {
+    admin_permissions: {
+      Signature: {
+        keyHash: fromHex(pkh.hash),
+      },
+    },
+  };
+
+  await submitTx(
+    lucid,
+    lucid.newTx().pay.ToContract(
+      createScriptAddress(lucid.config().network!, interestCollectionValHash),
+      {
+        kind: 'inline',
+        value: serialiseInterestCollectionDatum(interestCollectionAdminDatum),
+      },
+      mkAssetsOf(multisigUtxoNft, 1n),
+    ),
+  );
+
+  const interestCollectionUtxoDeploymentTx = lucid.newTx();
+
+  for (let i = 0; i < Number(numInterestCollectors); i++) {
+    interestCollectionUtxoDeploymentTx.pay.ToContract(
+      createScriptAddress(lucid.config().network!, interestCollectionValHash),
+      undefined,
+      mkLovelacesOf(interestCollectorUtxoLovelaces),
+    );
+  }
+
+  await submitTx(lucid, interestCollectionUtxoDeploymentTx);
+}
+
+export async function initCDPCreator(
+  lucid: LucidEvolution,
+  cdpCreatorParams: CDPCreatorParamsSP,
+  numCdpCreators: bigint,
+): Promise<void> {
+  const tx = lucid.newTx();
+
+  for (let i = 0; i < Number(numCdpCreators); i++) {
+    tx.pay.ToContract(
+      credentialToAddress(lucid.config().network!, {
+        hash: validatorToScriptHash(
+          mkCDPCreatorValidatorFromSP(cdpCreatorParams),
+        ),
+        type: 'Script',
+      }),
+      { kind: 'inline', value: Data.void() },
+      {
+        [cdpCreatorParams.cdpCreatorNft[0].unCurrencySymbol +
+        fromText(cdpCreatorParams.cdpCreatorNft[1].unTokenName)]: 1n,
+      },
+    );
+  }
+
+  await submitTx(lucid, tx);
+}
+
+export async function initTreasury(
+  lucid: LucidEvolution,
+  treasuryParams: TreasuryParamsSP,
+  daoAsset: AssetClass,
+  indyAsset: AssetClass,
+  treasuryIndyAmount: bigint,
+  numTreasuryCollectors: bigint,
+): Promise<void> {
+  const treasuryAddr = createScriptAddress(
+    lucid.config().network!,
+    validatorToScriptHash(mkTreasuryValidatorFromSP(treasuryParams)),
+    treasuryParams.treasuryUtxosStakeCredential != null
+      ? fromSysParamsCredential(treasuryParams.treasuryUtxosStakeCredential)
+      : undefined,
+  );
+  const tx = lucid
+    .newTx()
+    .pay.ToContract(
+      treasuryAddr,
+      { kind: 'inline', value: Data.void() },
+      addAssets(
+        mkAssetsOf(daoAsset, 1n),
+        mkAssetsOf(indyAsset, treasuryIndyAmount),
+      ),
+    );
+
+  for (let i = 0; i < Number(numTreasuryCollectors); i++) {
+    tx.pay.ToContract(treasuryAddr, {
+      kind: 'inline',
+      value: Data.void(),
+    });
+  }
+
+  await submitTx(lucid, tx);
+}
+
+export async function initStakingManager(
+  lucid: LucidEvolution,
+  stakingParams: StakingParamsSP,
+): Promise<void> {
+  const tx = lucid.newTx().pay.ToContract(
+    createScriptAddress(
+      lucid.config().network!,
+      validatorToScriptHash(mkStakingValidatorFromSP(stakingParams)),
+    ),
+    {
+      kind: 'inline',
+      value: serialiseStakingDatum({
+        totalStake: 0n,
+        managerSnapshot: { snapshotAda: 0n },
+      }),
+    },
+    {
+      [stakingParams.stakingManagerNFT[0].unCurrencySymbol +
+      fromText(stakingParams.stakingManagerNFT[1].unTokenName)]: 1n,
+    },
+  );
+  await submitTx(lucid, tx);
+}
+
+export async function handleOracleForCollateralAsset(
+  lucid: LucidEvolution,
+  iasset: InitialAssetParam,
+  collateralAsset: InitialCollateralAssetParam,
+  pythConfig: PythConfig,
+  currentSlot: number,
+): Promise<{ info: IAssetPriceInfo; params: PriceOracleParams | undefined }> {
+  return match(collateralAsset.priceOracle)
+    .returnType<
+      Promise<{ info: IAssetPriceInfo; params: PriceOracleParams | undefined }>
+    >()
+    .with({ tag: '_indigo_oracle_nft' }, async (val) => {
+      const [pkh, _] = await addrDetails(lucid);
+
+      const priceOracleParams: PriceOracleParams = {
+        owner: pkh.hash,
+        biasTime: val.params.biasTime,
+        expirationPeriod: val.params.expirationPeriod,
+      };
+
+      const [priceOracleStartTx, priceOracleNft] = await startPriceOracleTx(
+        lucid,
+        val.tokenName,
+        val.startPrice,
+        priceOracleParams,
+        currentSlot,
+      );
+      await runAndAwaitTxBuilder(lucid, priceOracleStartTx);
+
+      return { info: { OracleNft: priceOracleNft }, params: priceOracleParams };
+    })
+    .with({ tag: '_pyth_oracle_nft' }, () => {
+      return Promise.resolve({
+        info: {
+          DeferredValidation: {
+            feedValHash: fromHex(
+              getPythFeedConfig(
+                pythConfig,
+                fromHex(fromText(iasset.name)),
+                collateralAsset.collateralAsset,
+              ).pythFeedValHash,
+            ),
+          },
+        } satisfies IAssetPriceInfo,
+        params: undefined,
+      });
+    })
+    .exhaustive();
+}
+
+export async function initializeAsset(
+  lucid: LucidEvolution,
+  iassetParams: IAssetParamsSP,
+  iassetToken: AssetClass,
+  collateralAssetAuthToken: AssetClass,
+  cdpAuthToken: AssetClass,
+  cdpParams: CdpParamsSP,
+  stableswapValidatorHash: string,
+  stabilityPoolParams: StabilityPoolParamsSP,
+  stabilityPoolToken: AssetClass,
+  asset: InitialAssetParam,
+  pythConfig: PythConfig,
+  currentSlot: number,
+): Promise<AssetInfo> {
+  const iassetName = fromHex(fromText(asset.name));
+
+  const collateralAssetInfos: CollateralAssetInfo[] = [];
+
+  for (const collateralAsset of asset.collateralAssets) {
+    const [pkh, _] = await addrDetails(lucid);
+
+    const interestOracleParams: InterestOracleParams = {
+      owner: pkh.hash,
+      biasTime: collateralAsset.interestOracle.params.biasTime,
+    };
+    const [startInterestOracleTx, interestOracleNft] =
+      await startInterestOracle(
+        0n,
+        collateralAsset.interestOracle.initialInterestRate,
+        0n,
+        interestOracleParams,
+        lucid,
+        collateralAsset.interestOracle.tokenName,
+      );
+    await submitTx(lucid, startInterestOracleTx);
+    const priceInfo = await handleOracleForCollateralAsset(
+      lucid,
+      asset,
+      collateralAsset,
+      pythConfig,
+      currentSlot,
+    );
+
+    const collateralAssetContent: CollateralAssetContent = {
+      iasset: iassetName,
+      collateralAsset: collateralAsset.collateralAsset,
+      extraDecimals: collateralAsset.extraDecimals,
+      priceInfo: priceInfo.info,
+      interestOracleNft: interestOracleNft,
+      redemptionRatio: collateralAsset.redemptionRatio,
+      maintenanceRatio: collateralAsset.maintenanceRatio,
+      liquidationRatio: collateralAsset.liquidationRatio,
+      minCollateralAmt: collateralAsset.minCollateralAmt,
+      firstCollateralAsset: collateralAsset.firstCollateralAsset,
+      nextCollateralAsset:
+        collateralAsset.nextCollateralAsset != null
+          ? collateralAsset.nextCollateralAsset
+          : null,
+    };
+
+    const collateralAssetTx = lucid.newTx().pay.ToContract(
+      createScriptAddress(
+        lucid.config().network!,
+        validatorToScriptHash(mkIAssetValidatorFromSP(iassetParams)),
+      ),
+      {
+        kind: 'inline',
+        value: serialiseIAssetDatum({
+          CollateralAssetContent: collateralAssetContent,
+        }),
+      },
+      mkAssetsOf(collateralAssetAuthToken, 1n),
+    );
+    await submitTx(lucid, collateralAssetTx);
+
+    collateralAssetInfos.push({
+      collateralAsset: collateralAsset.collateralAsset,
+      interestOracleNft: interestOracleNft,
+      interestOracleParams: interestOracleParams,
+      oracleParams: priceInfo.params,
+    });
+  }
+
+  for (const stableswapPool of asset.stablepools) {
+    const stableswapPoolDatum: StableswapPoolContent = {
+      collateralAsset: stableswapPool.collateralAsset,
+      collateralToIassetRatio: stableswapPool.collateralToIassetRatio,
+      mintingFeeRatio: stableswapPool.mintingFeeRatio,
+      redemptionFeeRatio: stableswapPool.redemptionFeeRatio,
+      mintingEnabled: stableswapPool.mintingEnabled,
+      redemptionEnabled: stableswapPool.redemptionEnabled,
+      feeManager: stableswapPool.feeManager
+        ? fromHex(stableswapPool.feeManager)
+        : null,
+      minMintOrderAmount: stableswapPool.minMintOrderAmount,
+      minRedemptionOrderAmount: stableswapPool.minRedemptionOrderAmount,
+      iasset: iassetName,
+      stableswapValHash: fromHex(stableswapValidatorHash),
+    };
+
+    await submitTx(
+      lucid,
+      lucid.newTx().pay.ToContract(
+        createScriptAddress(
+          lucid.config().network!,
+          validatorToScriptHash(mkCdpValidatorFromSP(cdpParams)),
+        ),
+        {
+          kind: 'inline',
+          value: serialiseStableswapPoolDatum(stableswapPoolDatum),
+        },
+        mkAssetsOf(cdpAuthToken, 1n),
+      ),
+    );
+  }
+
+  const iassetDatum: IAssetContent = {
+    assetName: iassetName,
+    collateralAssetsCount: BigInt(asset.collateralAssets.length),
+    debtMintingFeeRatio: asset.debtMintingFeeRatio,
+    liquidationProcessingFeeRatio: asset.liquidationProcessingFeeRatio,
+    stabilityPoolWithdrawalFeeRatio: asset.stabilityPoolWithdrawalFeeRatio,
+    redemptionReimbursementRatio: asset.redemptionReimbursementRatio,
+    redemptionProcessingFeeRatio: asset.redemptionProcessingFeeRatio,
+    firstIAsset: asset.firstAsset,
+    nextIAsset: asset.nextAsset ? fromHex(fromText(asset.nextAsset)) : null,
+  };
+
+  const assetTx = lucid.newTx().pay.ToContract(
+    createScriptAddress(
+      lucid.config().network!,
+      validatorToScriptHash(mkIAssetValidatorFromSP(iassetParams)),
+    ),
+    {
+      kind: 'inline',
+      value: serialiseIAssetDatum({ IAssetContent: iassetDatum }),
+    },
+    mkAssetsOf(iassetToken, 1n),
+  );
+  await submitTx(lucid, assetTx);
+
+  const stabilityPoolDatum: StabilityPoolContent = {
+    iasset: fromHex(fromText(asset.name)),
+    state: initSpState,
+    assetStates: [],
+  };
+
+  const spTx = lucid.newTx().pay.ToContract(
+    credentialToAddress(lucid.config().network!, {
+      hash: validatorToScriptHash(
+        mkStabilityPoolValidatorFromSP(stabilityPoolParams),
+      ),
+      type: 'Script',
+    }),
+    {
+      kind: 'inline',
+      value: serialiseStabilityPoolDatum({ StabilityPool: stabilityPoolDatum }),
+    },
+    mkAssetsOf(stabilityPoolToken, 1n),
+  );
+  await submitTx(lucid, spTx);
+
+  return {
+    iassetTokenNameAscii: asset.name,
+    collateralAssets: collateralAssetInfos,
+  };
+}
+
+export async function initGovernance(
+  lucid: LucidEvolution,
+  governanceParams: GovParamsSP,
+  govToken: AssetClass,
+  initialAssets: InitialAssetParam[],
+  protocolParams: ProtocolParams,
+): Promise<void> {
+  const datum: GovDatum = {
+    currentProposal: 0n,
+    currentVersion: 0n,
+    protocolParams: protocolParams,
+    activeProposals: 0n,
+    iassetsCount: BigInt(initialAssets.length),
+  };
+  const tx = lucid.newTx().pay.ToContract(
+    credentialToAddress(lucid.config().network!, {
+      hash: validatorToScriptHash(mkGovValidatorFromSP(governanceParams)),
+      type: 'Script',
+    }),
+    { kind: 'inline', value: serialiseGovDatum(datum) },
+    mkAssetsOf(govToken, 1n),
+  );
+
+  await submitTx(lucid, tx);
+}
+
+export async function mintAuthTokenDirect(
+  lucid: LucidEvolution,
+  asset: AssetClass,
+  tokenName: string,
+  amount: bigint,
+): Promise<void> {
+  const script = mkAuthTokenPolicy(asset, fromText(tokenName));
+  const policyId = mintingPolicyToId(script);
+  const address = await lucid.wallet().address();
+
+  // Only select utxos that contain exactly 1 asset of the given asset class and sort by lovelaces amount in descending order
+  const utxos = (await lucid.utxosAtWithUnit(address, assetClassToUnit(asset)))
+    .filter((utxo) => assetClassValueOf(utxo.assets, asset) === 1n)
+    .sort((a, b) => Number(lovelacesAmt(b.assets) - lovelacesAmt(a.assets)));
+  if (utxos.length === 0) {
+    throw new Error('No utxos found');
+  }
+
+  const utxo = utxos[0];
+
+  const tx = lucid
+    .newTx()
+    .attach.MintingPolicy(script)
+    .collectFrom([utxo])
+    .mintAssets(
+      {
+        [policyId + fromText(tokenName)]: amount,
+      },
+      Data.void(),
+    );
+
+  await submitTx(lucid, tx);
 }