@indigo-labs/indigo-sdk 0.1.19 → 0.1.20

package/tests/hash-checks.test.ts

@@ -1,16 +1,17 @@
 import { describe, expect, it } from 'vitest';
 import {
   loadSystemParamsFromFile,
-  StakingContract,
-  CollectorContract,
-  CDPContract,
   mkCDPCreatorValidatorFromSP,
   mkInterestOracleValidator,
   mkLrpValidatorFromSP,
+  mkCdpValidatorFromSP,
+  mkExecuteValidatorFromSP,
+  mkCollectorValidatorFromSP,
 } from '../src';
 import { validatorToScriptHash } from '@lucid-evolution/lucid';
-import { mkStabilityPoolValidatorFromSP } from '../src/scripts/stability-pool-validator';
-import { mkGovValidatorFromSP } from '../src/scripts/gov-validator';
+import { mkStabilityPoolValidatorFromSP } from '../src/contracts/stability-pool/scripts';
+import { mkGovValidatorFromSP } from '../src/contracts/gov/scripts';
+import { mkStakingValidatorFromSP } from '../src/contracts/staking/scripts';
 
 const systemParams = loadSystemParamsFromFile(
   './tests/data/system-params.json',
@@ -25,33 +26,37 @@ describe('Validator Hash checks', () => {
     ).toBe(systemParams.validatorHashes.cdpCreatorHash);
   });
   it('CDP validator hash', () => {
-    expect(CDPContract.validatorHash(systemParams.cdpParams)).toBe(
-      systemParams.validatorHashes.cdpHash,
-    );
+    expect(
+      validatorToScriptHash(mkCdpValidatorFromSP(systemParams.cdpParams)),
+    ).toBe(systemParams.validatorHashes.cdpHash);
   });
   it('Collector validator hash', () => {
-    expect(CollectorContract.validatorHash(systemParams.collectorParams)).toBe(
-      systemParams.validatorHashes.collectorHash,
-    );
+    expect(
+      validatorToScriptHash(
+        mkCollectorValidatorFromSP(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.todo('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,
-    );
+    expect(
+      validatorToScriptHash(
+        mkStakingValidatorFromSP(systemParams.stakingParams),
+      ),
+    ).toBe(systemParams.validatorHashes.stakingHash);
   });
   it('Stability Pool validator hash', () => {
     expect(

package/tests/indigo-test-helpers.ts

@@ -6,67 +6,13 @@ import {
   ScriptHash,
   toUnit,
 } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../src/helpers/lucid-utils';
+import { createScriptAddress } from '../src/utils/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.

package/tests/initialize.test.ts

@@ -1,11 +1,16 @@
 import { beforeEach, test } from 'vitest';
 import { LucidContext } from './test-helpers';
-import { Lucid } from '@lucid-evolution/lucid';
+import { EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
 import { Emulator } from '@lucid-evolution/lucid';
 import { generateEmulatorAccount } from '@lucid-evolution/lucid';
 import { init } from './endpoints/initialize';
+import { iusdInitialAssetCfg } from './mock/assets-mock';
 
-beforeEach<LucidContext>(async (context: LucidContext) => {
+type MyContext = LucidContext<{
+  admin: EmulatorAccount;
+}>;
+
+beforeEach<MyContext>(async (context: MyContext) => {
   context.users = {
     admin: generateEmulatorAccount({
       lovelace: BigInt(100_000_000_000_000),
@@ -17,11 +22,11 @@ beforeEach<LucidContext>(async (context: LucidContext) => {
   context.lucid = await Lucid(context.emulator, 'Custom');
 });
 
-test<LucidContext>('Initialize Protocol - can initialize', async ({
+test<MyContext>('Initialize Protocol - can initialize', async ({
   lucid,
   users,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
 
-  await init(lucid);
+  await init(lucid, [iusdInitialAssetCfg]);
 });

package/tests/interest-calculations.test.ts

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

package/tests/interest-oracle.test.ts

@@ -4,16 +4,24 @@ import {
   runAndAwaitTx,
   runAndAwaitTxBuilder,
 } from './test-helpers';
-import { Lucid } from '@lucid-evolution/lucid';
+import { EmulatorAccount, 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 { addrDetails } from '../src/utils/lucid-utils';
+import {
+  feedInterestOracle,
+  InterestOracleParams,
+  startInterestOracle,
+} from '../src';
 import { findInterestOracle } from './queries/interest-oracle-queries';
 
+type MyContext = LucidContext<{
+  user: EmulatorAccount;
+}>;
+
 let originalDateNow: () => number;
 
-beforeEach<LucidContext>(async (context: LucidContext) => {
+beforeEach<MyContext>(async (context: MyContext) => {
   context.users = {
     user: generateEmulatorAccount({
       lovelace: BigInt(100_000_000_000_000),
@@ -32,15 +40,15 @@ afterEach(() => {
   Date.now = originalDateNow;
 });
 
-test<LucidContext>('Interest Oracle - Start', async ({
+test<MyContext>('Interest Oracle - Start', async ({
   lucid,
   users,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
 
   const [pkh, _] = await addrDetails(lucid);
 
-  const [tx, _ac] = await InterestOracleContract.startInterestOracle(
+  const [tx, _ac] = await startInterestOracle(
     0n,
     0n,
     0n,
@@ -54,10 +62,10 @@ test<LucidContext>('Interest Oracle - Start', async ({
   await runAndAwaitTxBuilder(lucid, tx);
 });
 
-test<LucidContext>('Interest Oracle - Update', async ({
+test<MyContext>('Interest Oracle - Update', async ({
   lucid,
   users,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
 
   const [pkh, _] = await addrDetails(lucid);
@@ -66,7 +74,7 @@ test<LucidContext>('Interest Oracle - Update', async ({
     owner: pkh.hash,
   };
 
-  const [tx, assetClass] = await InterestOracleContract.startInterestOracle(
+  const [tx, assetClass] = await startInterestOracle(
     0n,
     0n,
     0n,
@@ -76,15 +84,9 @@ test<LucidContext>('Interest Oracle - Update', async ({
 
   await runAndAwaitTxBuilder(lucid, tx);
 
-  const [utxo, _datum] = await findInterestOracle(lucid, assetClass);
+  const utxo = await findInterestOracle(lucid, assetClass);
   await runAndAwaitTx(
     lucid,
-    InterestOracleContract.feedInterestOracle(
-      interestParams,
-      500_000n,
-      lucid,
-      undefined,
-      utxo,
-    ),
+    feedInterestOracle(interestParams, 500_000n, lucid, undefined, utxo),
   );
 });