@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/{queries → gov}/governance-queries.ts

@@ -1,9 +1,12 @@
 import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
 import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
-import { GovDatum, matchSingle, parseGovDatum } from '../../src';
+import { matchSingle } from '../../src';
 import { option as O, array as A, function as F } from 'fp-ts';
+import { GovDatum, parseGovDatum } from '../../src/contracts/gov/types-new';
+import {
+  AssetClass,
+  assetClassToUnit,
+} from '@3rd-eye-labs/cardano-offchain-common';
 
 export async function findGov(
   lucid: LucidEvolution,

package/tests/hash-checks.test.ts

@@ -3,40 +3,52 @@ import {
   loadSystemParamsFromFile,
   mkCDPCreatorValidatorFromSP,
   mkInterestOracleValidator,
-  mkLrpValidatorFromSP,
+  mkRobValidatorFromSP,
   mkCdpValidatorFromSP,
   mkExecuteValidatorFromSP,
   mkCollectorValidatorFromSP,
+  mkInterestCollectionValidatorFromSP,
+  mkTreasuryValidatorFromSP,
 } 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 { mkStableswapValidatorFromSP } from '../src/contracts/stableswap/scripts';
 
 const systemParams = loadSystemParamsFromFile(
   './tests/data/system-params.json',
 );
 
 describe('Validator Hash checks', () => {
-  it('CDP Creator validator hash', () => {
+  it.todo('CDP Creator validator hash', () => {
     expect(
       validatorToScriptHash(
         mkCDPCreatorValidatorFromSP(systemParams.cdpCreatorParams),
       ),
     ).toBe(systemParams.validatorHashes.cdpCreatorHash);
   });
-  it('CDP validator hash', () => {
+  it.todo('CDP validator hash', () => {
     expect(
       validatorToScriptHash(mkCdpValidatorFromSP(systemParams.cdpParams)),
     ).toBe(systemParams.validatorHashes.cdpHash);
   });
-  it('Collector validator hash', () => {
+  it.todo('Collector validator hash', () => {
     expect(
       validatorToScriptHash(
         mkCollectorValidatorFromSP(systemParams.collectorParams),
       ),
     ).toBe(systemParams.validatorHashes.collectorHash);
   });
+  it.todo('Interest collector validator hash', () => {
+    expect(
+      validatorToScriptHash(
+        mkInterestCollectionValidatorFromSP(
+          systemParams.interestCollectionParams,
+        ),
+      ),
+    ).toBe(systemParams.validatorHashes.interestCollectionHash);
+  });
   // 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', () => {
@@ -46,27 +58,34 @@ describe('Validator Hash checks', () => {
       ),
     ).toBe(systemParams.validatorHashes.executeHash);
   });
-  it('Gov validator hash', () => {
+  it.todo('Gov validator hash', () => {
     expect(
       validatorToScriptHash(mkGovValidatorFromSP(systemParams.govParams)),
     ).toBe(systemParams.validatorHashes.govHash);
   });
-  it('Staking validator hash', () => {
+  it.todo('Staking validator hash', () => {
     expect(
       validatorToScriptHash(
         mkStakingValidatorFromSP(systemParams.stakingParams),
       ),
     ).toBe(systemParams.validatorHashes.stakingHash);
   });
-  it('Stability Pool validator hash', () => {
+  it.todo('Stability Pool validator hash', () => {
     expect(
       validatorToScriptHash(
         mkStabilityPoolValidatorFromSP(systemParams.stabilityPoolParams),
       ),
     ).toBe(systemParams.validatorHashes.stabilityPoolHash);
   });
+  it.todo('Stableswap validator hash', () => {
+    expect(
+      validatorToScriptHash(
+        mkStableswapValidatorFromSP(systemParams.stableswapParams),
+      ),
+    ).toBe(systemParams.validatorHashes.stabilityPoolHash);
+  });
 
-  it('Interest Oracle validator hash', () => {
+  it.todo('Interest Oracle validator hash', () => {
     expect(
       validatorToScriptHash(
         mkInterestOracleValidator({
@@ -77,9 +96,17 @@ describe('Validator Hash checks', () => {
     ).toBe('b970b3e0e1b591840627e6919898c12ee57e2f0225ab03e056d10d52');
   });
 
-  it('LRP validator hash', () => {
+  it.todo('ROB validator hash', () => {
     expect(
-      validatorToScriptHash(mkLrpValidatorFromSP(systemParams.lrpParams)),
-    ).toBe(systemParams.validatorHashes.lrpHash);
+      validatorToScriptHash(mkRobValidatorFromSP(systemParams.robParams)),
+    ).toBe(systemParams.validatorHashes.robHash);
+  });
+
+  it.todo('Treasury validator hash', () => {
+    expect(
+      validatorToScriptHash(
+        mkTreasuryValidatorFromSP(systemParams.treasuryParams),
+      ),
+    ).toBe(systemParams.validatorHashes.treasuryHash);
   });
 });

package/tests/indigo-test-helpers.ts

@@ -0,0 +1,100 @@
+import {
+  addAssets,
+  Emulator,
+  fromHex,
+  fromText,
+  generateEmulatorAccount,
+  generateEmulatorAccountFromPrivateKey,
+  Lucid,
+  paymentCredentialOf,
+  PROTOCOL_PARAMETERS_DEFAULT,
+  ProtocolParameters,
+} from '@lucid-evolution/lucid';
+import {
+  AssetClass,
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { IndigoTestContext } from './test-helpers';
+import { init } from './endpoints/initialize';
+import { iusdInitialAssetCfg } from './mock/assets-mock';
+
+export const MAINNET_PROTOCOL_PARAMETERS: ProtocolParameters = {
+  ...PROTOCOL_PARAMETERS_DEFAULT,
+  maxTxExMem: 16500000n,
+};
+
+export const EXAMPLE_TOKEN_1: AssetClass = {
+  currencySymbol: fromHex(
+    '00000000000000000000000000000000000000000000000000000000',
+  ),
+  tokenName: fromHex(fromText('example-token-1')),
+};
+export const EXAMPLE_TOKEN_2: AssetClass = {
+  currencySymbol: fromHex(
+    '00000000000000000000000000000000000000000000000000000001',
+  ),
+  tokenName: fromHex(fromText('example-token-2')),
+};
+export const EXAMPLE_TOKEN_3: AssetClass = {
+  currencySymbol: fromHex(
+    '00000000000000000000000000000000000000000000000000000002',
+  ),
+  tokenName: fromHex(fromText('example-token-3')),
+};
+
+export async function createIndigoTestContext(
+  context: IndigoTestContext,
+): Promise<void> {
+  context.users = {
+    admin: generateEmulatorAccount(
+      addAssets(
+        mkLovelacesOf(100_000_000_000_000n),
+        mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000_000_000n),
+      ),
+    ),
+    user: generateEmulatorAccount(
+      addAssets(
+        mkLovelacesOf(100_000_000_000_000n),
+        mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000_000_000n),
+        mkAssetsOf(EXAMPLE_TOKEN_2, 1_000_000_000_000_000n),
+        mkAssetsOf(EXAMPLE_TOKEN_3, 1_000_000_000_000_000n),
+      ),
+    ),
+    user2: generateEmulatorAccount({
+      lovelace: BigInt(100_000_000_000_000),
+    }),
+    withdrawalAccount: generateEmulatorAccountFromPrivateKey({}),
+  };
+
+  context.emulator = new Emulator(
+    [
+      context.users.admin,
+      context.users.user,
+      context.users.user2,
+      context.users.withdrawalAccount,
+    ],
+    MAINNET_PROTOCOL_PARAMETERS,
+  );
+  context.lucid = await Lucid(context.emulator, 'Custom');
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const [systemParams, assetConfigs] = await init(
+    context.lucid,
+    [iusdInitialAssetCfg()],
+    context.emulator.slot,
+    () => [],
+    {
+      foundationMultisig: {
+        Signature: {
+          keyHash: fromHex(
+            paymentCredentialOf(context.users.admin.address).hash,
+          ),
+        },
+      },
+    },
+  );
+
+  context.systemParams = systemParams;
+  context.assetConfigs = assetConfigs;
+}

package/tests/initialize.test.ts

@@ -1,10 +1,19 @@
-import { beforeEach, test } from 'vitest';
+import { assert, beforeEach, test } from 'vitest';
 import { LucidContext } from './test-helpers';
-import { EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
+import { addAssets, EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
 import { Emulator } from '@lucid-evolution/lucid';
 import { generateEmulatorAccount } from '@lucid-evolution/lucid';
-import { init } from '../src/contracts/initialize/transactions';
-import { iusdInitialAssetCfg } from './mock/assets-mock';
+import { DEFAULT_INTEREST, iusdInitialAssetCfg } from './mock/assets-mock';
+import {
+  EXAMPLE_TOKEN_1,
+  MAINNET_PROTOCOL_PARAMETERS,
+} from './indigo-test-helpers';
+import {
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { rationalFromInt } from '../src/types/rational';
+import { init } from './endpoints/initialize';
 
 type MyContext = LucidContext<{
   admin: EmulatorAccount;
@@ -12,12 +21,18 @@ type MyContext = LucidContext<{
 
 beforeEach<MyContext>(async (context: MyContext) => {
   context.users = {
-    admin: generateEmulatorAccount({
-      lovelace: BigInt(100_000_000_000_000),
-    }),
+    admin: generateEmulatorAccount(
+      addAssets(
+        mkLovelacesOf(100_000_000_000_000n),
+        mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000_000_000n),
+      ),
+    ),
   };
 
-  context.emulator = new Emulator([context.users.admin]);
+  context.emulator = new Emulator(
+    [context.users.admin],
+    MAINNET_PROTOCOL_PARAMETERS,
+  );
 
   context.lucid = await Lucid(context.emulator, 'Custom');
 });
@@ -25,8 +40,45 @@ beforeEach<MyContext>(async (context: MyContext) => {
 test<MyContext>('Initialize Protocol - can initialize', async ({
   lucid,
   users,
+  emulator,
 }: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
 
-  await init(lucid, [iusdInitialAssetCfg]);
+  await init(
+    lucid,
+    [
+      iusdInitialAssetCfg(DEFAULT_INTEREST, [
+        {
+          collateralAsset: EXAMPLE_TOKEN_1,
+          collateralToIassetRatio: rationalFromInt(1n),
+          feeManager: undefined,
+          minMintOrderAmount: 0n,
+          minRedemptionOrderAmount: 0n,
+          mintingEnabled: true,
+          redemptionEnabled: true,
+          mintingFeeRatio: { numerator: 1n, denominator: 100n },
+          redemptionFeeRatio: { numerator: 1n, denominator: 100n },
+        },
+      ]),
+    ],
+    emulator.slot,
+  );
+});
+
+test<MyContext>('Validate Lucid protocol parameters match Mainnet', ({
+  lucid,
+}: MyContext) => {
+  const protocolParameters = lucid.config().protocolParameters!;
+  assert(
+    protocolParameters.maxTxSize === 16384,
+    'Lucid maxTxSize does not match Cardano Mainnet',
+  );
+  assert(
+    protocolParameters.maxTxExMem === 16500000n,
+    'Lucid maxTxExMem does not match Cardano Mainnet',
+  );
+  assert(
+    protocolParameters.maxTxExSteps === 10000000000n,
+    'Lucid maxTxExSteps does not match Cardano Mainnet',
+  );
 });