@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/gov/governance-queries.ts

@@ -1,37 +0,0 @@
-import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
-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,
-  govScriptHash: ScriptHash,
-  govNft: AssetClass,
-): Promise<{
-  utxo: UTxO;
-  datum: GovDatum;
-}> {
-  const govUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, govScriptHash),
-    assetClassToUnit(govNft),
-  );
-
-  return matchSingle(
-    F.pipe(
-      govUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseGovDatum),
-          O.map((datum) => ({ utxo, datum: datum })),
-        ),
-      ),
-      A.compact,
-    ),
-    (res) => new Error('Expected a single Gov UTXO.: ' + JSON.stringify(res)),
-  );
-}

package/tests/hash-checks.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  loadSystemParamsFromFile,
-  mkCDPCreatorValidatorFromSP,
-  mkInterestOracleValidator,
-  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.todo('CDP Creator validator hash', () => {
-    expect(
-      validatorToScriptHash(
-        mkCDPCreatorValidatorFromSP(systemParams.cdpCreatorParams),
-      ),
-    ).toBe(systemParams.validatorHashes.cdpCreatorHash);
-  });
-  it.todo('CDP validator hash', () => {
-    expect(
-      validatorToScriptHash(mkCdpValidatorFromSP(systemParams.cdpParams)),
-    ).toBe(systemParams.validatorHashes.cdpHash);
-  });
-  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', () => {
-    expect(
-      validatorToScriptHash(
-        mkExecuteValidatorFromSP(systemParams.executeParams),
-      ),
-    ).toBe(systemParams.validatorHashes.executeHash);
-  });
-  it.todo('Gov validator hash', () => {
-    expect(
-      validatorToScriptHash(mkGovValidatorFromSP(systemParams.govParams)),
-    ).toBe(systemParams.validatorHashes.govHash);
-  });
-  it.todo('Staking validator hash', () => {
-    expect(
-      validatorToScriptHash(
-        mkStakingValidatorFromSP(systemParams.stakingParams),
-      ),
-    ).toBe(systemParams.validatorHashes.stakingHash);
-  });
-  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.todo('Interest Oracle validator hash', () => {
-    expect(
-      validatorToScriptHash(
-        mkInterestOracleValidator({
-          biasTime: 1_200_000n,
-          owner: 'a962c79bd58fc9fcecd78f8a963e0ce80e907264cd86cd5814d87333',
-        }),
-      ),
-    ).toBe('b970b3e0e1b591840627e6919898c12ee57e2f0225ab03e056d10d52');
-  });
-
-  it.todo('ROB validator hash', () => {
-    expect(
-      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

@@ -1,99 +0,0 @@
-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 { ieurInitialAssetCfg, 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(), ieurInitialAssetCfg()],
-    () => [],
-    {
-      foundationMultisig: {
-        Signature: {
-          keyHash: fromHex(
-            paymentCredentialOf(context.users.admin.address).hash,
-          ),
-        },
-      },
-    },
-  );
-
-  context.systemParams = systemParams;
-  context.assetConfigs = assetConfigs;
-}

package/tests/initialize.test.ts

@@ -1,79 +0,0 @@
-import { assert, beforeEach, test } from 'vitest';
-import { LucidContext } from './test-helpers';
-import { addAssets, EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
-import { Emulator } from '@lucid-evolution/lucid';
-import { generateEmulatorAccount } from '@lucid-evolution/lucid';
-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;
-}>;
-
-beforeEach<MyContext>(async (context: MyContext) => {
-  context.users = {
-    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],
-    MAINNET_PROTOCOL_PARAMETERS,
-  );
-
-  context.lucid = await Lucid(context.emulator, 'Custom');
-});
-
-test<MyContext>('Initialize Protocol - can initialize', async ({
-  lucid,
-  users,
-}: MyContext) => {
-  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-
-  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 },
-      },
-    ]),
-  ]);
-});
-
-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',
-  );
-});

package/tests/interest-calculations.test.ts

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