@indigo-labs/indigo-sdk 0.1.6 → 0.1.8

package/tests/hash-checks.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import {
+  loadSystemParamsFromFile,
+  StakingContract,
+  CollectorContract,
+  CDPContract,
+  mkCDPCreatorValidatorFromSP,
+  mkInterestOracleValidator,
+  mkLrpValidatorFromSP,
+} from '../src';
+import { validatorToScriptHash } from '@lucid-evolution/lucid';
+import { mkStabilityPoolValidatorFromSP } from '../src/scripts/stability-pool-validator';
+import { mkGovValidatorFromSP } from '../src/scripts/gov-validator';
+
+const systemParams = loadSystemParamsFromFile(
+  './tests/data/system-params.json',
+);
+
+describe('Validator Hash checks', () => {
+  it('CDP Creator validator hash', () => {
+    expect(
+      validatorToScriptHash(
+        mkCDPCreatorValidatorFromSP(systemParams.cdpCreatorParams),
+      ),
+    ).toBe(systemParams.validatorHashes.cdpCreatorHash);
+  });
+  it('CDP validator hash', () => {
+    expect(CDPContract.validatorHash(systemParams.cdpParams)).toBe(
+      systemParams.validatorHashes.cdpHash,
+    );
+  });
+  it('Collector validator hash', () => {
+    expect(CollectorContract.validatorHash(systemParams.collectorParams)).toBe(
+      systemParams.validatorHashes.collectorHash,
+    );
+  });
+  // TODO: Revisit this test, issues with cbor encoding on Lucid?
+  // Applying parameters to the validator using `aiken build` does not result in the same hash as the one generate by Lucid.
+  // it('Execute validator hash', () => {
+  //   expect(
+  //     validatorToScriptHash(mkExecuteValidatorFromSP(systemParams.executeParams)),
+  //   ).toBe(
+  //     systemParams.validatorHashes.executeHash,
+  //   );
+  // });
+  it('Gov validator hash', () => {
+    expect(
+      validatorToScriptHash(mkGovValidatorFromSP(systemParams.govParams)),
+    ).toBe(systemParams.validatorHashes.govHash);
+  });
+  it('Staking validator hash', () => {
+    expect(StakingContract.validatorHash(systemParams.stakingParams)).toBe(
+      systemParams.validatorHashes.stakingHash,
+    );
+  });
+  it('Stability Pool validator hash', () => {
+    expect(
+      validatorToScriptHash(
+        mkStabilityPoolValidatorFromSP(systemParams.stabilityPoolParams),
+      ),
+    ).toBe(systemParams.validatorHashes.stabilityPoolHash);
+  });
+
+  it('Interest Oracle validator hash', () => {
+    expect(
+      validatorToScriptHash(
+        mkInterestOracleValidator({
+          biasTime: 1_200_000n,
+          owner: 'a962c79bd58fc9fcecd78f8a963e0ce80e907264cd86cd5814d87333',
+        }),
+      ),
+    ).toBe('b970b3e0e1b591840627e6919898c12ee57e2f0225ab03e056d10d52');
+  });
+
+  it('LRP validator hash', () => {
+    expect(
+      validatorToScriptHash(mkLrpValidatorFromSP(systemParams.lrpParams)),
+    ).toBe(systemParams.validatorHashes.lrpHash);
+  });
+});

package/tests/indigo-test-helpers.ts

@@ -0,0 +1,115 @@
+import {
+  Assets,
+  fromText,
+  LucidEvolution,
+  Network,
+  ScriptHash,
+  toUnit,
+} from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../src/helpers/lucid-utils';
+import {
+  AssetClass,
+  IAssetContent,
+  OracleAssetNft,
+  PriceOracleParams,
+  runOneShotMintTx,
+  serialiseIAssetDatum,
+  serialisePriceOracleDatum,
+} from '../src';
+import { OnChainDecimal } from '../src/types/on-chain-decimal';
+
+export async function runStartPriceOracle(
+  lucid: LucidEvolution,
+  oracleScriptHash: ScriptHash,
+  oracleParams: PriceOracleParams,
+  network: Network,
+  // Hex encoded
+  oracleNftTokenName: string,
+  price: OnChainDecimal,
+): Promise<OracleAssetNft> {
+  const utxos = await lucid.wallet().getUtxos();
+
+  const nftPolicyId = await runOneShotMintTx(lucid, {
+    referenceOutRef: {
+      txHash: utxos[0].txHash,
+      outputIdx: BigInt(utxos[0].outputIndex),
+    },
+    mintAmounts: [{ tokenName: oracleNftTokenName, amount: 1n }],
+  });
+
+  const nftValue: Assets = { [toUnit(nftPolicyId, oracleNftTokenName)]: 1n };
+
+  const txHash = await lucid
+    .newTx()
+    .pay.ToContract(
+      createScriptAddress(network, oracleScriptHash),
+      {
+        kind: 'inline',
+        value: serialisePriceOracleDatum({
+          price: price,
+          expiration: BigInt(Date.now()) + oracleParams.expiration,
+        }),
+      },
+      nftValue,
+    )
+    .complete()
+    .then((tx) => tx.sign.withWallet().complete())
+    .then((tx) => tx.submit());
+
+  await lucid.awaitTx(txHash);
+
+  return {
+    oracleNft: {
+      asset: {
+        currencySymbol: nftPolicyId,
+        tokenName: oracleNftTokenName,
+      },
+    },
+  };
+}
+
+/**
+ * TODO: the NFT has to be minted using the auth policy based on execute NFT.
+ * This is just a mocked setup for test purposes.
+ *
+ * @returns NFT of the iAsset.
+ */
+export async function runCreateIAsset(
+  lucid: LucidEvolution,
+  network: Network,
+  cdpScriptHash: ScriptHash,
+  iasset: IAssetContent,
+): Promise<AssetClass> {
+  const nftTokenName = fromText('IASSET_NFT');
+  const utxos = await lucid.wallet().getUtxos();
+  const nftPolicyId = await runOneShotMintTx(lucid, {
+    referenceOutRef: {
+      txHash: utxos[0].txHash,
+      outputIdx: BigInt(utxos[0].outputIndex),
+    },
+    mintAmounts: [{ tokenName: nftTokenName, amount: 1n }],
+  });
+
+  const nftValue: Assets = { [toUnit(nftPolicyId, nftTokenName)]: 1n };
+
+  const txHash = await lucid
+    .newTx()
+    .pay.ToContract(
+      createScriptAddress(network, cdpScriptHash),
+      {
+        kind: 'inline',
+        value: serialiseIAssetDatum(iasset),
+      },
+      nftValue,
+    )
+    .complete()
+    .then((tx) => tx.sign.withWallet().complete())
+    .then((tx) => tx.submit());
+
+  await lucid.awaitTx(txHash);
+
+  return {
+    currencySymbol: nftPolicyId,
+    tokenName: nftTokenName,
+  };
+}

package/tests/initialize.test.ts

@@ -0,0 +1,27 @@
+import { beforeEach, test } from 'vitest';
+import { LucidContext } from './test-helpers';
+import { Lucid } from '@lucid-evolution/lucid';
+import { Emulator } from '@lucid-evolution/lucid';
+import { generateEmulatorAccount } from '@lucid-evolution/lucid';
+import { init } from './endpoints/initialize';
+
+beforeEach<LucidContext>(async (context: LucidContext) => {
+  context.users = {
+    admin: generateEmulatorAccount({
+      lovelace: BigInt(100_000_000_000_000),
+    }),
+  };
+
+  context.emulator = new Emulator([context.users.admin]);
+
+  context.lucid = await Lucid(context.emulator, 'Custom');
+});
+
+test<LucidContext>('Initialize Protocol - can initialize', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  await init(lucid);
+});

package/tests/interest-calculations.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { oneDay } from '../src/helpers/time-helpers';
+import {
+  calculateAccruedInterest,
+  calculateUnitaryInterestSinceOracleLastUpdated,
+} from '../src/helpers/interest-oracle';
+
+describe('Interest Calculations', () => {
+  describe('Calculate Unitary Interest', () => {
+    it('Should calculate the unitary interest correctly, 0', () => {
+      expect(
+        calculateUnitaryInterestSinceOracleLastUpdated(oneDay * 6n, {
+          unitaryInterest: 684_931_506_849_315n,
+          interestRate: { getOnChainInt: 100_000n },
+          lastUpdated: oneDay * 5n,
+        }),
+      ).toBe(273_972_602_739_726n);
+    });
+
+    it('Should calculate the unitary interest correctly, 1', () => {
+      expect(
+        calculateUnitaryInterestSinceOracleLastUpdated(oneDay * 6n, {
+          unitaryInterest: 0n,
+          interestRate: { getOnChainInt: 50_000n },
+          lastUpdated: 0n,
+        }),
+      ).toBe(821_917_808_219_178n);
+    });
+
+    it('Should calculate the unitary interest correctly, 2', () => {
+      expect(
+        calculateUnitaryInterestSinceOracleLastUpdated(1n, {
+          unitaryInterest: 0n,
+          interestRate: { getOnChainInt: 1n },
+          lastUpdated: 0n,
+        }),
+      ).toBe(31n);
+    });
+  });
+
+  describe('Calculate Accumulated Interest', () => {
+    it('Should calculate the accumulated interest correctly, 0', () => {
+      expect(
+        calculateAccruedInterest(oneDay, 0n, 1_000_000n, 0n, {
+          unitaryInterest: 0n,
+          interestRate: { getOnChainInt: 50_000n },
+          lastUpdated: 0n,
+        }),
+      ).toBe(136n);
+    });
+
+    it('Should calculate the accumulated interest correctly, 1', () => {
+      expect(
+        calculateAccruedInterest(oneDay * 6n, 0n, 1_000_000n, 0n, {
+          unitaryInterest: 684_931_506_849_315n,
+          interestRate: { getOnChainInt: 100_000n },
+          lastUpdated: oneDay * 5n,
+        }),
+      ).toBe(684n + 273n);
+    });
+
+    it('Should calculate the accumulated interest correctly, 2', () => {
+      expect(
+        calculateAccruedInterest(oneDay * 17n, 0n, 1_000_000n, 0n, {
+          unitaryInterest: 1_506_849_315_068_493n,
+          interestRate: { getOnChainInt: 100_000n },
+          lastUpdated: oneDay * 15n,
+        }),
+      ).toBe(1506n + 547n);
+    });
+
+    it('Should calculate the accumulated interest correctly, 3', () => {
+      expect(
+        calculateAccruedInterest(
+          oneDay * 17n,
+          410_958_904_109_589n,
+          1_000_000n,
+          oneDay * 3n,
+          {
+            unitaryInterest: 1_506_849_315_068_493n,
+            interestRate: { getOnChainInt: 100_000n },
+            lastUpdated: oneDay * 15n,
+          },
+        ),
+      ).toBe(1095n + 547n);
+    });
+
+    it('Should calculate the accumulated interest correctly, 4', () => {
+      expect(
+        calculateAccruedInterest(
+          oneDay * 17n,
+          767_123_287_671_232n,
+          1_000_000n,
+          oneDay * 6n,
+          {
+            unitaryInterest: 1_506_849_315_068_493n,
+            interestRate: { getOnChainInt: 100_000n },
+            lastUpdated: oneDay * 15n,
+          },
+        ),
+      ).toBe(739n + 547n);
+    });
+
+    it('Should calculate the accumulated interest correctly, 5', () => {
+      expect(
+        calculateAccruedInterest(
+          oneDay * 10n,
+          821_917_808_219_178n,
+          1_000_000n,
+          oneDay * 6n,
+          {
+            unitaryInterest: 0n,
+            interestRate: { getOnChainInt: 50_000n },
+            lastUpdated: 0n,
+          },
+        ),
+      ).toBe(547n);
+    });
+  });
+});

package/tests/interest-oracle.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, test } from 'vitest';
+import {
+  LucidContext,
+  runAndAwaitTx,
+  runAndAwaitTxBuilder,
+} from './test-helpers';
+import { Lucid } from '@lucid-evolution/lucid';
+import { Emulator } from '@lucid-evolution/lucid';
+import { generateEmulatorAccount } from '@lucid-evolution/lucid';
+import { addrDetails } from '../src/helpers/lucid-utils';
+import { InterestOracleContract, InterestOracleParams } from '../src';
+import { findInterestOracle } from './queries/interest-oracle-queries';
+
+let originalDateNow: () => number;
+
+beforeEach<LucidContext>(async (context: LucidContext) => {
+  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<LucidContext>('Interest Oracle - Start', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+
+  const [pkh, _] = await addrDetails(lucid);
+
+  const [tx, _ac] = await InterestOracleContract.startInterestOracle(
+    0n,
+    0n,
+    0n,
+    {
+      biasTime: 120_000n,
+      owner: pkh.hash,
+    },
+    lucid,
+  );
+
+  await runAndAwaitTxBuilder(lucid, tx);
+});
+
+test<LucidContext>('Interest Oracle - Update', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+
+  const [pkh, _] = await addrDetails(lucid);
+  const interestParams: InterestOracleParams = {
+    biasTime: 120_000n,
+    owner: pkh.hash,
+  };
+
+  const [tx, assetClass] = await InterestOracleContract.startInterestOracle(
+    0n,
+    0n,
+    0n,
+    interestParams,
+    lucid,
+  );
+
+  await runAndAwaitTxBuilder(lucid, tx);
+
+  const [utxo, _datum] = await findInterestOracle(lucid, assetClass);
+  await runAndAwaitTx(
+    lucid,
+    InterestOracleContract.feedInterestOracle(
+      interestParams,
+      500_000n,
+      lucid,
+      undefined,
+      utxo,
+    ),
+  );
+});