@indigo-labs/indigo-sdk 0.1.1 → 0.1.3

package/tests/stability-pool.test.ts

@@ -0,0 +1,364 @@
+import { beforeEach, test, afterEach } from 'vitest';
+import { LucidContext, runAndAwaitTx } from './test-helpers';
+import { fromText, Lucid } from '@lucid-evolution/lucid';
+import { Emulator } from '@lucid-evolution/lucid';
+import { generateEmulatorAccount } from '@lucid-evolution/lucid';
+import { init } from './endpoints/initialize';
+import { addrDetails, CDPContract, StabilityPoolContract } from '../src';
+import {
+  findStabilityPool,
+  findStabilityPoolAccount,
+} from './queries/stability-pool-queries';
+import { findIAsset } from './queries/iasset-queries';
+import { findGov } from './queries/governance-queries';
+
+let originalDateNow: () => number;
+
+beforeEach<LucidContext>(async (context: LucidContext) => {
+  context.users = {
+    admin: generateEmulatorAccount({
+      lovelace: BigInt(100_000_000_000_000),
+    }),
+    user: generateEmulatorAccount({
+      lovelace: BigInt(100_000_000_000_000),
+    }),
+  };
+
+  context.emulator = new Emulator([context.users.admin, context.users.user]);
+
+  context.lucid = await Lucid(context.emulator, 'Custom');
+
+  originalDateNow = Date.now;
+  Date.now = () => context.emulator.now();
+});
+
+afterEach(() => {
+  Date.now = originalDateNow;
+});
+
+test<LucidContext>('Stability Pool - Create Account', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+  const [pkh, _] = await addrDetails(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    CDPContract.openPosition('iUSD', 1_000_000_000n, 20n, systemParams, lucid),
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+  );
+
+  const stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  const assetUtxo = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    {
+      currencySymbol:
+        systemParams.cdpParams.iAssetAuthToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
+    currencySymbol: systemParams.govParams.govNFT[0].unCurrencySymbol,
+    tokenName: fromText(systemParams.govParams.govNFT[1].unTokenName),
+  });
+
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+});
+
+test<LucidContext>('Stability Pool - Adjust Account', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+  const [pkh, _] = await addrDetails(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    CDPContract.openPosition('iUSD', 1_000_000_000n, 20n, systemParams, lucid),
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+  );
+
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  let stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  let accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  const assetUtxo = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    {
+      currencySymbol:
+        systemParams.cdpParams.iAssetAuthToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
+    currencySymbol: systemParams.govParams.govNFT[0].unCurrencySymbol,
+    tokenName: fromText(systemParams.govParams.govNFT[1].unTokenName),
+  });
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+
+  stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.adjustAccount(
+      'iUSD',
+      10n,
+      accountUtxo,
+      systemParams,
+      lucid,
+    ),
+  );
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+});
+
+test<LucidContext>('Stability Pool - Close Account', async ({
+  lucid,
+  users,
+  emulator,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid, emulator.now());
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+  const [pkh, _] = await addrDetails(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    CDPContract.openPosition('iUSD', 1_000_000_000n, 20n, systemParams, lucid),
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+  );
+
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  let stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  let accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  const assetUtxo = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    {
+      currencySymbol:
+        systemParams.cdpParams.iAssetAuthToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
+    currencySymbol: systemParams.govParams.govNFT[0].unCurrencySymbol,
+    tokenName: fromText(systemParams.govParams.govNFT[1].unTokenName),
+  });
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+
+  stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.closeAccount(accountUtxo, systemParams, lucid),
+  );
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+});

package/tests/staking.test.ts

@@ -0,0 +1,105 @@
+import { beforeEach, test } from 'vitest';
+import { LucidContext, runAndAwaitTx } from './test-helpers';
+import { fromText, Lucid } from '@lucid-evolution/lucid';
+import { Emulator } from '@lucid-evolution/lucid';
+import { generateEmulatorAccount } from '@lucid-evolution/lucid';
+import { StakingContract } from '../src/contracts/staking';
+import { init } from './endpoints/initialize';
+import { addrDetails } from '../src/helpers/lucid-utils';
+import { findStakingPosition } from './queries/staking-queries';
+
+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>('Staking - Create Position', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    StakingContract.openPosition(1_000_000n, systemParams, lucid),
+  );
+});
+
+test<LucidContext>('Staking - Adjust Position', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    StakingContract.openPosition(1_000_000n, systemParams, lucid),
+  );
+
+  const [pkh, _] = await addrDetails(lucid);
+  const myStakingPosition = await findStakingPosition(
+    lucid,
+    lucid.config().network,
+    systemParams.validatorHashes.stakingHash,
+    {
+      currencySymbol:
+        systemParams.stakingParams.stakingToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stakingParams.stakingToken[1].unTokenName,
+      ),
+    },
+    pkh.hash,
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StakingContract.adjustPosition(
+      myStakingPosition,
+      1_000_000n,
+      systemParams,
+      lucid,
+    ),
+  );
+});
+
+test<LucidContext>('Staking - Close Position', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    StakingContract.openPosition(1_000_000n, systemParams, lucid),
+  );
+
+  const [pkh, _] = await addrDetails(lucid);
+  const myStakingPosition = await findStakingPosition(
+    lucid,
+    lucid.config().network,
+    systemParams.validatorHashes.stakingHash,
+    {
+      currencySymbol:
+        systemParams.stakingParams.stakingToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stakingParams.stakingToken[1].unTokenName,
+      ),
+    },
+    pkh.hash,
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StakingContract.closePosition(myStakingPosition, systemParams, lucid),
+  );
+});

package/tests/test-helpers.ts

@@ -0,0 +1,38 @@
+import {
+  Emulator,
+  EmulatorAccount,
+  LucidEvolution,
+  TxBuilder,
+} from '@lucid-evolution/lucid';
+
+export type LucidContext = {
+  lucid: LucidEvolution;
+  users: { [key: string]: EmulatorAccount };
+  emulator: Emulator;
+};
+
+export async function runAndAwaitTx(
+  lucid: LucidEvolution,
+  transaction: Promise<TxBuilder>,
+): Promise<string> {
+  const txHash = await transaction
+    .then((tx) => tx.complete())
+    .then((tx) => tx.sign.withWallet().complete())
+    .then((tx) => tx.submit());
+
+  await lucid.awaitTx(txHash);
+  return txHash;
+}
+
+export async function runAndAwaitTxBuilder(
+  lucid: LucidEvolution,
+  transaction: TxBuilder,
+): Promise<string> {
+  const txHash = await transaction
+    .complete()
+    .then((tx) => tx.sign.withWallet().complete())
+    .then((tx) => tx.submit());
+
+  await lucid.awaitTx(txHash);
+  return txHash;
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["spec/**/*.spec.ts", "vitest.config.ts"]
+}

package/tsconfig.json

@@ -1,35 +1,16 @@
 {
   "compilerOptions": {
     "outDir": "./dist",
-    "noImplicitAny": true,
-    "module": "es2022",
-    "target": "es2022",
-    "lib": ["es2022", "DOM"],
-    "allowJs": true,
-    "moduleResolution": "node",
-    "declaration": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": false,
-    "noImplicitThis": true,
-    "alwaysStrict": false,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
+    "sourceMap": true,
+    "module": "nodenext",
+    "target": "ESNext",
+    "moduleResolution": "nodenext"
   },
   "ts-node": {
     "compilerOptions": {
-      "module": "ES2022",
+      "module": "ES2022"
     }
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "tests", "dist"],
-}
+  "include": ["src/**/*.ts", "tests/**/*.ts", "vitest.config.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    testTimeout: 120000, // 2 minutes
+    reporters: 'verbose',
+    include: ['./tests/**/*.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+  },
+});

package/babel.config.cjs

@@ -1,13 +0,0 @@
-module.exports = {
-    "presets": [
-        [
-            "@babel/preset-env",
-            {
-                "targets": {
-                    "node": "current"
-                }
-            }
-        ],
-        "@babel/preset-typescript",
-    ]
-};

package/jest.config.js

@@ -1,13 +0,0 @@
-module.exports = {
-  "presets": [
-      [
-          "@babel/preset-env",
-          {
-              "targets": {
-                  "node": "current"
-              }
-          }
-      ],
-      "@babel/preset-typescript",
-  ]
-};

package/src/contracts/cdp-creator.ts

@@ -1,86 +0,0 @@
-import {
-  Address,
-  applyParamsToScript,
-  Constr,
-  Credential,
-  Data,
-  fromText,
-  LucidEvolution,
-  SpendingValidator,
-  UTxO,
-  validatorToAddress,
-  validatorToScriptHash,
-} from '@lucid-evolution/lucid';
-import { _cdpCreatorValidator } from '../scripts/cdp-creator-validator';
-import { CdpCreatorParams, ScriptReferences } from '../types/system-params';
-import { scriptRef } from '../helpers/lucid-utils';
-
-export class CDPCreatorContract {
-  static address(params: CdpCreatorParams, lucid: LucidEvolution): Address {
-    const network = lucid.config().network;
-    if (!network) {
-      throw new Error('Network configuration is undefined');
-    }
-    return validatorToAddress(network, CDPCreatorContract.validator(params));
-  }
-
-  static validator(params: CdpCreatorParams): SpendingValidator {
-    return {
-      type: 'PlutusV2',
-      script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
-        new Constr(0, [
-          new Constr(0, [
-            params.cdpCreatorNft[0].unCurrencySymbol,
-            fromText(params.cdpCreatorNft[1].unTokenName),
-          ]),
-          params.cdpAssetCs.unCurrencySymbol,
-          new Constr(0, [
-            params.cdpAuthTk[0].unCurrencySymbol,
-            fromText(params.cdpAuthTk[1].unTokenName),
-          ]),
-          new Constr(0, [
-            params.iAssetAuthTk[0].unCurrencySymbol,
-            fromText(params.iAssetAuthTk[1].unTokenName),
-          ]),
-          new Constr(0, [
-            params.versionRecordToken[0].unCurrencySymbol,
-            fromText(params.versionRecordToken[1].unTokenName),
-          ]),
-          params.cdpScriptHash,
-          params.collectorValHash,
-          BigInt(params.minCollateralInLovelace),
-          BigInt(params.biasTime),
-        ]),
-      ]),
-    };
-  }
-
-  static validatorHash(
-    params: CdpCreatorParams
-  ): string {
-    return validatorToScriptHash(CDPCreatorContract.validator(params));
-  }
-
-  static redeemer(
-    hash: Credential,
-    mintedAmount: bigint,
-    collateralAmount: bigint,
-    currentTime: bigint,
-  ): Data {
-    if (hash.type !== 'Key') throw new Error('Cannot support script hash.');
-
-    return new Constr<Data>(0, [
-      hash.hash,
-      BigInt(mintedAmount),
-      BigInt(collateralAmount),
-      currentTime
-    ]);
-  }
-
-  static scriptRef(
-    params: ScriptReferences,
-    lucid: LucidEvolution,
-  ): Promise<UTxO> {
-    return scriptRef(params.cdpCreatorValidatorRef, lucid);
-  }
-}

package/src/contracts/price-oracle.ts

@@ -1,24 +0,0 @@
-import { Constr, Data } from "@lucid-evolution/lucid";
-import { PriceOracleDatum } from "../types/indigo/price-oracle";
-
-export class PriceOracleContract {
-    static decodePriceOracleDatum(datum: string): PriceOracleDatum {
-        const oracleDatum = Data.from(datum) as any;
-        if (oracleDatum.index != 0 || oracleDatum.fields.length !== 2 || oracleDatum.fields[0].index !== 0)
-            throw 'Invalid Price Oracle Datum provided.'
-        
-        return {
-            price: oracleDatum.fields[0].fields[0],
-            expiration: oracleDatum.fields[1],
-        }
-    }
-    
-    static encodePriceOracleDatum(datum: PriceOracleDatum): string {
-        return Data.to(
-            new Constr(0, [
-                new Constr(0, [datum.price]),
-                datum.expiration,
-            ])
-        )
-    }
-}