@indigo-labs/indigo-sdk 0.1.3 → 0.1.4

package/tests/hash-checks.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  loadSystemParamsFromFile,
-  StakingContract,
-  CollectorContract,
-  CDPContract,
-  mkCDPCreatorValidatorFromSP,
-  mkInterestOracleValidator,
-} 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');
-  });
-});

package/tests/indigo-test-helpers.ts

@@ -1,115 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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,
-    ),
-  );
-});

package/tests/lrp.test.ts

@@ -1,149 +0,0 @@
-import { describe, it } from 'vitest';
-import {
-  Emulator,
-  fromText,
-  generateEmulatorAccount,
-  Lucid,
-  Network,
-  validatorToScriptHash,
-} from '@lucid-evolution/lucid';
-import { LRPParams } from '../src/types/indigo/lrp';
-import { mkLrpValidator } from '../src/scripts/lrp-validator';
-import { runCreateScriptRefTx } from '../src/helpers/helper-txs';
-import { runOneShotMintTx } from '../src/contracts/one-shot';
-import { cancelLrp, openLrp } from '../src/contracts/lrp';
-import { findLrp } from './queries/lrp-queries';
-import { addrDetails } from '../src/helpers/lucid-utils';
-import { runAndAwaitTx } from './test-helpers';
-import { matchSingle } from '../src/helpers/helpers';
-import { runCreateIAsset, runStartPriceOracle } from './indigo-test-helpers';
-import { mkPriceOracleValidator } from '../src/scripts/price-oracle-validator';
-import { AssetClass, PriceOracleParams } from '../src';
-import { alwaysFailValidator } from '../src/scripts/always-fail-validator';
-import { OCD_ONE, OCD_ZERO } from '../src/types/on-chain-decimal';
-
-describe('LRP', () => {
-  it('case 1', async () => {
-    const network: Network = 'Custom';
-    const account1 = generateEmulatorAccount({
-      lovelace: 80_000_000_000n, // 80,000 ADA
-    });
-    const emulator = new Emulator([account1]);
-
-    const lucid = await Lucid(emulator, network);
-    lucid.selectWallet.fromSeed(account1.seedPhrase);
-
-    const iassetTokenName = fromText('TEST_IBTC');
-    const utxos = await lucid.wallet().getUtxos();
-    const iassetPolicyId = await runOneShotMintTx(lucid, {
-      referenceOutRef: {
-        txHash: utxos[0].txHash,
-        outputIdx: BigInt(utxos[0].outputIndex),
-      },
-      mintAmounts: [{ tokenName: iassetTokenName, amount: 10_000_000n }],
-    });
-
-    const [ownPkh, _] = await addrDetails(lucid);
-
-    const priceOracleParams: PriceOracleParams = {
-      owner: ownPkh.hash,
-      // 1 minute
-      biasTime: 1n * 60n * 1000n,
-      // 10 minutes
-      expiration: 10n * 60n * 1000n,
-    };
-    const oracleValidator = mkPriceOracleValidator(priceOracleParams);
-    const oracleValidatorHash = validatorToScriptHash(oracleValidator);
-    const oracleNft = await runStartPriceOracle(
-      lucid,
-      oracleValidatorHash,
-      priceOracleParams,
-      network,
-      fromText('ORACLE_IBTC'),
-      OCD_ONE,
-    );
-
-    const iassetValHash = validatorToScriptHash(alwaysFailValidator);
-    const dummyAc: AssetClass = { currencySymbol: '', tokenName: '' };
-    const iassetNft = await runCreateIAsset(lucid, network, iassetValHash, {
-      assetName: iassetTokenName,
-      price: { Oracle: oracleNft },
-      interestOracleNft: dummyAc,
-      redemptionRatio: OCD_ONE,
-      maintenanceRatio: OCD_ONE,
-      liquidationRatio: OCD_ONE,
-      debtMintingFeePercentage: OCD_ZERO,
-      liquidationProcessingFeePercentage: OCD_ZERO,
-      stabilityPoolWithdrawalFeePercentage: OCD_ZERO,
-      redemptionReimbursementPercentage: OCD_ONE,
-      redemptionProcessingFeePercentage: OCD_ZERO,
-      interestCollectorPortionPercentage: OCD_ZERO,
-      firstIAsset: true,
-      nextIAsset: null,
-    });
-
-    const lrpParams: LRPParams = {
-      versionRecordToken: {
-        currencySymbol: fromText('smth'),
-        tokenName: fromText('version_record'),
-      },
-      iassetNft: iassetNft,
-      iassetPolicyId: iassetPolicyId,
-      minRedemptionLovelacesAmt: 1_000_000n,
-    };
-
-    const lrpValidator = mkLrpValidator(lrpParams);
-    const lrpValidatorHash = validatorToScriptHash(lrpValidator);
-
-    const lrpRefScriptOutRef = await runCreateScriptRefTx(
-      lucid,
-      lrpValidator,
-      network,
-    );
-
-    await runAndAwaitTx(
-      lucid,
-      openLrp(
-        iassetTokenName,
-        20_000_000n,
-        { getOnChainInt: 1_000_000n },
-        lucid,
-        lrpValidatorHash,
-        network,
-      ),
-    );
-
-    const lrpOutRef = matchSingle(
-      await findLrp(
-        lucid,
-        network,
-        lrpValidatorHash,
-        ownPkh.hash,
-        iassetTokenName,
-      ),
-      (res) => new Error('Expected a single LRP UTXO.: ' + JSON.stringify(res)),
-    );
-
-    await runAndAwaitTx(lucid, cancelLrp(lrpOutRef, lrpRefScriptOutRef, lucid));
-
-    // await runAndAwaitTx(
-    //   lucid,
-    //   redeemLrp(
-    //     [[lrpOutRef, 5_000_000n]],
-    //     lrpRefScriptOutRef,
-    //     await findPriceOracle(lucid, network, oracleValidatorHash, oracleNft),
-    //     await findIAsset(
-    //       lucid,
-    //       network,
-    //       iassetValHash,
-    //       iassetNft,
-    //       iassetTokenName,
-    //     ),
-    //     lucid,
-    //     lrpParams,
-    //     priceOracleParams,
-    //     network,
-    //   ),
-    // );
-  });
-});

package/tests/queries/governance-queries.ts

@@ -1,31 +0,0 @@
-import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/helpers/lucid-utils';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/helpers/value-helpers';
-import { matchSingle, parseGovDatum } from '../../src';
-
-export async function findGov(
-  lucid: LucidEvolution,
-  govScriptHash: ScriptHash,
-  govNft: AssetClass,
-): Promise<UTxO> {
-  const govUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network, govScriptHash),
-    assetClassToUnit(govNft),
-  );
-
-  return matchSingle(
-    govUtxos.filter((utxo) => {
-      if (utxo.datum != null) {
-        try {
-          parseGovDatum(utxo.datum);
-          return true; // TODO: implement Gov Datum
-        } catch (_) {
-          // when incompatible datum
-          return false;
-        }
-      }
-    }),
-    (res) => new Error('Expected a single Gov UTXO.: ' + JSON.stringify(res)),
-  );
-}

package/tests/queries/iasset-queries.ts

@@ -1,39 +0,0 @@
-import {
-  fromText,
-  LucidEvolution,
-  ScriptHash,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/helpers/lucid-utils';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/helpers/value-helpers';
-import { matchSingle, parseIAssetDatum } from '../../src';
-
-export async function findIAsset(
-  lucid: LucidEvolution,
-  iassetScriptHash: ScriptHash,
-  iassetNft: AssetClass,
-  iassetName: string,
-): Promise<UTxO> {
-  const iassetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network, iassetScriptHash),
-    assetClassToUnit(iassetNft),
-  );
-
-  return matchSingle(
-    iassetUtxos.filter((utxo) => {
-      if (utxo.datum != null) {
-        try {
-          const iassetDatum = parseIAssetDatum(utxo.datum);
-
-          return iassetDatum.assetName == fromText(iassetName);
-        } catch (_) {
-          // when incompatible datum
-          return false;
-        }
-      }
-    }),
-    (res) =>
-      new Error('Expected a single IAsset UTXO.: ' + JSON.stringify(res)),
-  );
-}

package/tests/queries/interest-oracle-queries.ts

@@ -1,13 +0,0 @@
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/helpers/value-helpers';
-import { InterestOracleDatum, parseInterestOracleDatum } from '../../src';
-
-export async function findInterestOracle(
-  lucid: LucidEvolution,
-  interestNft: AssetClass,
-): Promise<[UTxO, InterestOracleDatum]> {
-  const interestUtxo = await lucid.utxoByUnit(assetClassToUnit(interestNft));
-  if (!interestUtxo.datum) throw new Error('No interest oracle utxo found');
-  return [interestUtxo, parseInterestOracleDatum(interestUtxo.datum)];
-}

package/tests/queries/lrp-queries.ts

@@ -1,39 +0,0 @@
-import {
-  Credential,
-  LucidEvolution,
-  Network,
-  OutRef,
-  ScriptHash,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/helpers/lucid-utils';
-import { parseLrpDatum } from '../../src/types/indigo/lrp';
-
-/**
- * Beware, this shouldn't be used in production since it queries all the UTXOs
- * at an address and does the filtering in this function.
- */
-export async function findLrp(
-  lucid: LucidEvolution,
-  network: Network,
-  lrpScriptHash: ScriptHash,
-  owner: string,
-  assetTokenName: string,
-  stakeCredential?: Credential,
-): Promise<OutRef[]> {
-  const lrpUtxos = await lucid.utxosAt(
-    createScriptAddress(network, lrpScriptHash, stakeCredential),
-  );
-
-  return lrpUtxos.filter((utxo) => {
-    if (utxo.datum != null) {
-      try {
-        const lrpDatum = parseLrpDatum(utxo.datum);
-
-        return lrpDatum.owner == owner && lrpDatum.iasset == assetTokenName;
-      } catch (_) {
-        // when incompatible datum
-        return false;
-      }
-    }
-  });
-}