@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/interest-collection/interest-collector-queries.ts

@@ -0,0 +1,49 @@
+import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
+import { createScriptAddress, getRandomElement } from '../../src';
+import { option as O, function as F } from 'fp-ts';
+import {
+  AssetClass,
+  assetClassToUnit,
+  assetClassValueOf,
+  matchSingle,
+} from '@3rd-eye-labs/cardano-offchain-common';
+
+export async function findAllInterestCollectors(
+  lucid: LucidEvolution,
+  interestCollectorScriptHash: string,
+): Promise<UTxO[]> {
+  return lucid.utxosAt(
+    createScriptAddress(lucid.config().network!, interestCollectorScriptHash),
+  );
+}
+
+export async function findAdminInterestCollectors(
+  lucid: LucidEvolution,
+  interestCollectorScriptHash: string,
+  multisigUtxoNft: AssetClass,
+): Promise<UTxO> {
+  return matchSingle(
+    await lucid.utxosAtWithUnit(
+      createScriptAddress(lucid.config().network!, interestCollectorScriptHash),
+      assetClassToUnit(multisigUtxoNft),
+    ),
+    (_) => new Error('Expected a single admin interest collector UTXO'),
+  );
+}
+
+export async function findRandomNonAdminInterestCollector(
+  lucid: LucidEvolution,
+  interestCollectorScriptHash: string,
+  multisigUtxoNft: AssetClass,
+): Promise<UTxO> {
+  const allCollectors = (
+    await findAllInterestCollectors(lucid, interestCollectorScriptHash)
+  ).filter((utxo) => !assetClassValueOf(utxo.assets, multisigUtxoNft));
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(allCollectors)),
+    O.match(() => {
+      throw new Error('Expected some non-admin interest collector UTXOs.');
+    }, F.identity),
+  );
+}

package/tests/interest-collection/transactions-mutated.ts

@@ -0,0 +1,260 @@
+import {
+  addAssets,
+  Address,
+  Assets,
+  Data,
+  LucidEvolution,
+  OutputDatum,
+  OutRef,
+  toHex,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  fromSystemParamsScriptRef,
+  SystemParams,
+  matchSingle,
+  parseInterestCollectionDatum,
+  serialiseInterestCollectionDatum,
+  serialiseInterestCollectionRedeemer,
+  createScriptAddress,
+  fromSystemParamsAsset,
+} from '../../src';
+import {
+  assetClassValueOf,
+  getInlineDatumOrThrow,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { Multisig } from '../../src/types/multisig';
+
+type CollectSuccess = {
+  kind: 'CollectSuccess';
+};
+
+type CollectWithoutCDP = {
+  kind: 'CollectWithoutCDP';
+};
+
+type CollectFromMultipleInterestCollectors = {
+  kind: 'CollectFromMultipleInterestCollectors';
+  utxo: UTxO;
+};
+type CollectFromInterestAdmin = {
+  kind: 'CollectFromInterestAdmin';
+};
+type CollectCustomValue = {
+  kind: 'CollectCustomValue';
+  value: Assets;
+};
+
+export type CollectInterestVariation =
+  | CollectSuccess
+  | CollectWithoutCDP
+  | CollectFromInterestAdmin
+  | CollectFromMultipleInterestCollectors
+  | CollectCustomValue;
+
+export async function testCollectInterest(
+  value: Assets,
+  lucid: LucidEvolution,
+  params: SystemParams,
+  tx: TxBuilder,
+  interestCollectorOutRef: OutRef,
+  variation: CollectInterestVariation,
+): Promise<TxBuilder> {
+  const interestCollectorUtxo: UTxO = matchSingle(
+    await lucid.utxosByOutRef([interestCollectorOutRef]),
+    (_) => new Error('Expected a single interest collector UTXO'),
+  );
+
+  // Confirm that the interest collector UTXO is NOT of InterestCollectorDatum type
+  if (
+    variation.kind !== 'CollectFromInterestAdmin' &&
+    assetClassValueOf(
+      interestCollectorUtxo.assets,
+      fromSystemParamsAsset(params.interestCollectionParams.multisigUtxoNft),
+    )
+  ) {
+    throw new Error(
+      'Interest collector UTXO is of InterestCollectorDatum type',
+    );
+  }
+
+  // Find the script reference UTXO for the interest collection validator
+  const interestCollectionRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collection Ref Script UTXO'),
+  );
+
+  // Collect the interest from the interest collector UTXO and then pay back with more assets.
+  tx.readFrom([interestCollectionRefScriptUtxo])
+    .collectFrom(
+      [interestCollectorUtxo],
+      serialiseInterestCollectionRedeemer('CollectInterest'),
+    )
+    .pay.ToContract(
+      createScriptAddress(
+        lucid.config().network!,
+        params.validatorHashes.interestCollectionHash,
+      ),
+      { kind: 'inline', value: Data.void() },
+      variation.kind === 'CollectCustomValue'
+        ? variation.value
+        : addAssets(interestCollectorUtxo.assets, value),
+    );
+
+  if (variation.kind === 'CollectFromMultipleInterestCollectors') {
+    tx.collectFrom(
+      [variation.utxo],
+      serialiseInterestCollectionRedeemer('CollectInterest'),
+    );
+  }
+
+  return tx;
+}
+
+type DistributeInterestNoAdmin = {
+  kind: 'DistributeInterestNoAdmin';
+};
+type DistributeInterestWithDatum = {
+  kind: 'DistributeInterestWithDatum';
+  datum: OutputDatum;
+};
+export type DistributeInterestVariation =
+  | DistributeInterestNoAdmin
+  | DistributeInterestWithDatum;
+
+export async function testDistributeInterest(
+  interestCollectorOutRef: OutRef,
+  interestAdminOutRef: OutRef,
+  outputAddress: Address,
+  outputDatum: OutputDatum | undefined,
+  params: SystemParams,
+  lucid: LucidEvolution,
+  variation: DistributeInterestVariation,
+): Promise<TxBuilder> {
+  const interestCollectorUtxo: UTxO = matchSingle(
+    await lucid.utxosByOutRef([interestCollectorOutRef]),
+    (_) => new Error('Expected a single interest collector UTXO'),
+  );
+
+  const interestAdminUtxo: UTxO = matchSingle(
+    (await lucid.utxosByOutRef([interestAdminOutRef])).filter((utxo) =>
+      assetClassValueOf(
+        utxo.assets,
+        fromSystemParamsAsset(params.interestCollectionParams.multisigUtxoNft),
+      ),
+    ),
+    (_) => new Error('Expected a single interest admin UTXO'),
+  );
+
+  const interestAdminDatum = parseInterestCollectionDatum(
+    getInlineDatumOrThrow(interestAdminUtxo),
+  );
+
+  // Find the script reference UTXO for the interest collection validator
+  const interestCollectionRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collection Ref Script UTXO'),
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([interestCollectionRefScriptUtxo, interestAdminUtxo])
+    .collectFrom(
+      [interestCollectorUtxo],
+      serialiseInterestCollectionRedeemer('Distribute'),
+    )
+    .pay.ToContract(outputAddress, outputDatum, interestCollectorUtxo.assets);
+
+  if (variation.kind !== 'DistributeInterestNoAdmin') {
+    // TODO: Handle tx contruction for Multisig
+    if ('Signature' in interestAdminDatum.admin_permissions) {
+      tx.addSignerKey(
+        toHex(interestAdminDatum.admin_permissions.Signature.keyHash),
+      );
+    } else {
+      // TODO: Handle other admin permissions types
+      throw new Error('Unsupported admin permissions type');
+    }
+  }
+
+  return tx;
+}
+
+export async function updatePermissions(
+  interestAdminOutRef: OutRef,
+  newAdminPermissions: Multisig,
+  params: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const interestAdminUtxo: UTxO = matchSingle(
+    (await lucid.utxosByOutRef([interestAdminOutRef])).filter((utxo) =>
+      assetClassValueOf(
+        utxo.assets,
+        fromSystemParamsAsset(params.interestCollectionParams.multisigUtxoNft),
+      ),
+    ),
+    (_) => new Error('Expected a single interest admin UTXO'),
+  );
+
+  const interestAdminDatum = parseInterestCollectionDatum(
+    getInlineDatumOrThrow(interestAdminUtxo),
+  );
+
+  // Find the script reference UTXO for the interest collection validator
+  const interestCollectionRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collection Ref Script UTXO'),
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([interestCollectionRefScriptUtxo])
+    .collectFrom(
+      [interestAdminUtxo],
+      serialiseInterestCollectionRedeemer('UpdatePermissions'),
+    )
+    .pay.ToContract(
+      createScriptAddress(
+        lucid.config().network!,
+        params.validatorHashes.interestCollectionHash,
+      ),
+      {
+        kind: 'inline',
+        value: serialiseInterestCollectionDatum({
+          admin_permissions: newAdminPermissions,
+        }),
+      },
+      interestAdminUtxo.assets,
+    );
+
+  if ('Signature' in interestAdminDatum.admin_permissions) {
+    tx.addSignerKey(
+      toHex(interestAdminDatum.admin_permissions.Signature.keyHash),
+    );
+  } else {
+    // TODO: Handle other admin permissions types
+    throw new Error('Unsupported admin permissions type');
+  }
+
+  if ('Signature' in newAdminPermissions) {
+    tx.addSignerKey(toHex(newAdminPermissions.Signature.keyHash));
+  } else {
+    // TODO: Handle other admin permissions types
+    throw new Error('Unsupported admin permissions type');
+  }
+
+  return tx;
+}

package/tests/interest-oracle.test.ts

@@ -1,9 +1,5 @@
-import { afterEach, beforeEach, test } from 'vitest';
-import {
-  LucidContext,
-  runAndAwaitTx,
-  runAndAwaitTxBuilder,
-} from './test-helpers';
+import { beforeEach, test } from 'vitest';
+import { LucidContext, runAndAwaitTxBuilder } from './test-helpers';
 import { EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
 import { Emulator } from '@lucid-evolution/lucid';
 import { generateEmulatorAccount } from '@lucid-evolution/lucid';
@@ -14,36 +10,37 @@ import {
   startInterestOracle,
 } from '../src';
 import { findInterestOracle } from './queries/interest-oracle-queries';
+import { benchmarkAndAwaitTx } from './utils/benchmark-utils';
+import { MAINNET_PROTOCOL_PARAMETERS } from './indigo-test-helpers';
 
-type MyContext = LucidContext<{
+type InterestOracleTestContext = LucidContext<{
+  admin: EmulatorAccount;
   user: EmulatorAccount;
 }>;
 
-let originalDateNow: () => number;
-
-beforeEach<MyContext>(async (context: MyContext) => {
-  context.users = {
-    user: generateEmulatorAccount({
-      lovelace: BigInt(100_000_000_000_000),
-    }),
-  };
-
-  context.emulator = new Emulator([context.users.user]);
-
-  context.lucid = await Lucid(context.emulator, 'Custom');
-
-  originalDateNow = Date.now;
-  Date.now = () => context.emulator.now();
-});
-
-afterEach(() => {
-  Date.now = originalDateNow;
-});
-
-test<MyContext>('Interest Oracle - Start', async ({
+beforeEach<InterestOracleTestContext>(
+  async (context: InterestOracleTestContext) => {
+    context.users = {
+      admin: generateEmulatorAccount({}),
+      user: generateEmulatorAccount({
+        lovelace: BigInt(100_000_000_000_000),
+      }),
+    };
+
+    context.emulator = new Emulator(
+      [context.users.user],
+      MAINNET_PROTOCOL_PARAMETERS,
+    );
+
+    context.lucid = await Lucid(context.emulator, 'Custom');
+  },
+);
+
+test<InterestOracleTestContext>('Interest Oracle - Start', async ({
   lucid,
   users,
-}: MyContext) => {
+  emulator,
+}: InterestOracleTestContext) => {
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
 
   const [pkh, _] = await addrDetails(lucid);
@@ -59,13 +56,14 @@ test<MyContext>('Interest Oracle - Start', async ({
     lucid,
   );
 
-  await runAndAwaitTxBuilder(lucid, tx);
+  await benchmarkAndAwaitTx('Interest Oracle - Start', tx, lucid, emulator);
 });
 
-test<MyContext>('Interest Oracle - Update', async ({
+test<InterestOracleTestContext>('Interest Oracle - Update', async ({
   lucid,
   users,
-}: MyContext) => {
+  emulator,
+}: InterestOracleTestContext) => {
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
 
   const [pkh, _] = await addrDetails(lucid);
@@ -85,8 +83,18 @@ test<MyContext>('Interest Oracle - Update', async ({
   await runAndAwaitTxBuilder(lucid, tx);
 
   const utxo = await findInterestOracle(lucid, assetClass);
-  await runAndAwaitTx(
+
+  await benchmarkAndAwaitTx(
+    'Interest Oracle - Update',
+    await feedInterestOracle(
+      interestParams,
+      500_000n,
+      lucid,
+      emulator.slot,
+      undefined,
+      utxo,
+    ),
     lucid,
-    feedInterestOracle(interestParams, 500_000n, lucid, undefined, utxo),
+    emulator,
   );
 });

package/tests/mock/assets-mock.ts

@@ -1,32 +1,243 @@
-export type { InitialAsset } from '../../src/contracts/initialize/types';
-import type { InitialAsset } from '../../src/contracts/initialize/types';
+import {
+  AssetClass,
+  adaAssetClass,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { array as A, function as F, ord as Ord, string as Str } from 'fp-ts';
+import {
+  DerivedPythPriceSP,
+  getAssetClassComparisonStr,
+  InitialAssetParam,
+  InitialCollateralAssetParam,
+  InitialStablepoolParam,
+  PythFeedParamsSP,
+} from '../../src';
+import { toHex } from '@lucid-evolution/lucid';
+import { Rational, rationalFromInt } from '../../src/types/rational';
 
-export const iusdInitialAssetCfg: InitialAsset = {
-  name: 'iUSD',
-  priceOracle: {
-    tokenName: 'iUSD_ORACLE',
-    startPrice: 1_000_000n,
+export const DEFAULT_INTEREST = 1_000_000n;
+export const DEFAULT_PRICE = rationalFromInt(1n);
+
+type IndigoOracleNftConfig = {
+  tag: '_indigo_oracle_nft';
+  tokenName: string;
+  startPrice: Rational;
+  params: {
+    biasTime: bigint;
+    expirationPeriod: bigint;
+  };
+};
+
+type PythOracleConfig = {
+  tag: '_pyth_oracle_nft';
+  pythFeedParams: PythFeedParamsSP;
+};
+
+export type InitialCollateralAsset = {
+  collateralAsset: AssetClass;
+  extraDecimals: bigint;
+  priceOracle: IndigoOracleNftConfig | PythOracleConfig;
+  interestOracle: {
+    tokenName: string;
+    initialInterestRate: bigint;
     params: {
-      biasTime: 120_000n,
-      expirationTime: 1_800_000n,
-    },
-  },
+      biasTime: bigint;
+    };
+  };
+  redemptionRatio: Rational;
+  maintenanceRatio: Rational;
+  liquidationRatio: Rational;
+  minCollateralAmt: bigint;
+  firstCollateralAsset: boolean;
+  nextCollateralAsset: AssetClass | undefined;
+};
+
+export type InitialAsset = {
+  name: string;
+  collateralAssets: InitialCollateralAsset[];
+  debtMintingFeeRatio: Rational;
+  liquidationProcessingFeeRatio: Rational;
+  stabilityPoolWithdrawalFeeRatio: Rational;
+  redemptionReimbursementRatio: Rational;
+  redemptionProcessingFeeRatio: Rational;
+  firstAsset: boolean;
+  nextAsset: string | undefined;
+};
+
+export function mkAssetsChain(
+  assets: InitialAssetParam[],
+): InitialAssetParam[] {
+  const sortedAssets = F.pipe(
+    assets,
+    A.sort(Ord.contramap<string, InitialAssetParam>((a) => a.name)(Str.Ord)),
+  );
+
+  return sortedAssets.map((asset, idx) => {
+    const isFirst = idx === 0;
+    const hasNext = idx < sortedAssets.length - 1;
+
+    return {
+      ...asset,
+      firstAsset: isFirst,
+      nextAsset: hasNext ? sortedAssets[idx + 1].name : undefined,
+    } satisfies InitialAssetParam;
+  });
+}
+
+export function mkCollateralAssetsChain(
+  assets: InitialCollateralAssetParam[],
+): InitialCollateralAssetParam[] {
+  const sortedAssets = F.pipe(
+    assets,
+    A.sort(
+      Ord.contramap<string, InitialCollateralAssetParam>((a) =>
+        getAssetClassComparisonStr(a.collateralAsset),
+      )(Str.Ord),
+    ),
+  );
+
+  return sortedAssets.map((asset, idx) => {
+    const isFirst = idx === 0;
+    const hasNext = idx < sortedAssets.length - 1;
+
+    return {
+      ...asset,
+      firstCollateralAsset: isFirst,
+      nextCollateralAsset: hasNext
+        ? sortedAssets[idx + 1].collateralAsset
+        : undefined,
+    } satisfies InitialCollateralAssetParam;
+  });
+}
+
+export const mkBaseCollateralAsset = (
+  a: AssetClass,
+  interest: bigint = DEFAULT_INTEREST,
+  initialPrice: Rational = DEFAULT_PRICE,
+  extraDecimals: bigint = 0n,
+  pythStateNft?: AssetClass,
+  pythDerivedPrice?: DerivedPythPriceSP,
+): InitialCollateralAssetParam => ({
+  collateralAsset: a,
+  extraDecimals: extraDecimals,
+  priceOracle:
+    pythStateNft && pythDerivedPrice
+      ? {
+          tag: '_pyth_oracle_nft',
+          pythFeedParams: {
+            config: pythDerivedPrice,
+            pythStatePolicyId: {
+              unCurrencySymbol: toHex(pythStateNft.currencySymbol),
+            },
+          },
+        }
+      : {
+          tag: '_indigo_oracle_nft',
+          tokenName: 'IASSET_ADA_ORACLE',
+          startPrice: initialPrice,
+          params: {
+            biasTime: 120_000n,
+            expirationPeriod: 1_800_000n,
+          },
+        },
   interestOracle: {
-    tokenName: 'iUSD_ORACLE',
-    initialInterestRate: 1_000_000n,
+    tokenName: 'IASSET_ADA_INTEREST_ORACLE',
+    initialInterestRate: interest,
     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,
+  redemptionRatio: rationalFromInt(2n),
+  maintenanceRatio: { numerator: 15n, denominator: 10n },
+  liquidationRatio: { numerator: 12n, denominator: 10n },
+  minCollateralAmt: 10_000_000n,
+  firstCollateralAsset: true,
+  nextCollateralAsset: undefined,
+});
+
+export const iusdInitialAssetCfg = (
+  interest: bigint = DEFAULT_INTEREST,
+  stablepools: InitialStablepoolParam[] = [],
+): InitialAssetParam => ({
+  name: 'iUSD',
+  collateralAssets: [mkBaseCollateralAsset(adaAssetClass, interest)],
+  debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+  liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+  stabilityPoolWithdrawalFeeRatio: { numerator: 5n, denominator: 1_000n },
+  redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+  redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
   firstAsset: true,
   nextAsset: undefined,
-};
+  stablepools,
+});
+
+// Creates iUSD with a Pyth price oracle
+export const iusdInitialAssetCfgWithPyth = (
+  pythStatePolicyId: AssetClass,
+  mkCollaterals: (
+    pythStatePolicyId: AssetClass,
+  ) => InitialCollateralAssetParam[],
+): InitialAssetParam => ({
+  name: 'iUSD',
+  collateralAssets: mkCollaterals(pythStatePolicyId),
+  stablepools: [],
+  debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+  liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+  stabilityPoolWithdrawalFeeRatio: { numerator: 5n, denominator: 1_000n },
+  redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+  redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+  firstAsset: true,
+  nextAsset: undefined,
+});
+
+// Creates iETH with a Pyth price oracle
+export const iethInitialAssetCfgWithPyth = (
+  pythStatePolicyId: AssetClass,
+  mkCollaterals: (
+    pythStatePolicyId: AssetClass,
+  ) => InitialCollateralAssetParam[],
+): InitialAssetParam => ({
+  name: 'iETH',
+  collateralAssets: mkCollaterals(pythStatePolicyId),
+  stablepools: [],
+  debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+  liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+  stabilityPoolWithdrawalFeeRatio: { numerator: 5n, denominator: 1_000n },
+  redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+  redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+  firstAsset: true,
+  nextAsset: undefined,
+});
+
+// Creates iBTC with a Pyth price oracle
+export const ibtcInitialAssetCfgWithPyth = (
+  pythStatePolicyId: AssetClass,
+  mkCollaterals: (
+    pythStatePolicyId: AssetClass,
+  ) => InitialCollateralAssetParam[],
+): InitialAssetParam => ({
+  name: 'iBTC',
+  collateralAssets: mkCollaterals(pythStatePolicyId),
+  stablepools: [],
+  debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+  liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+  stabilityPoolWithdrawalFeeRatio: { numerator: 5n, denominator: 1_000n },
+  redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+  redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+  firstAsset: true,
+  nextAsset: undefined,
+});
+
+export const ieurInitialAssetCfg = (
+  interest: bigint = DEFAULT_INTEREST,
+): InitialAssetParam => ({
+  name: 'iEUR',
+  collateralAssets: [mkBaseCollateralAsset(adaAssetClass, interest)],
+  stablepools: [],
+  debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+  liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+  stabilityPoolWithdrawalFeeRatio: { numerator: 5n, denominator: 1_000n },
+  redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+  redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+  firstAsset: true,
+  nextAsset: undefined,
+});