@indigo-labs/indigo-sdk 0.1.20 → 0.1.22

package/tests/hash-checks.test.ts

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

package/tests/indigo-test-helpers.ts

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

package/tests/initialize.test.ts

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

package/tests/interest-calculations.test.ts

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

package/tests/interest-oracle.test.ts

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