@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/src/contracts/initialize/helpers.ts

@@ -1,616 +0,0 @@
-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';
-
-/** 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,
-  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 { 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,
-): 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,
-      );
-      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,
-): 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,
-    );
-
-    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);
-}