@indigo-labs/indigo-sdk 0.1.2 → 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/examples/sample-cdp.ts

@@ -1,43 +0,0 @@
-import { Blockfrost, Lucid, OutRef } from "@lucid-evolution/lucid";
-import { balance, CDPContract, loadSystemParamsFromUrl } from "../src";
-
-async function main() {
-    const lucid = await Lucid(
-        new Blockfrost(
-            'https://cardano-mainnet.blockfrost.io/api/v0', 
-            'mainnetpb1Y1PczllObhmQKFMO6wm3la39p70k5'
-        ),
-        'Mainnet'
-    );
-
-    lucid.selectWallet.fromSeed('helmet coconut robot path message library verb lobster rigid taxi recall ribbon vacuum uniform horse thumb praise sibling wise frown cattle settle century sad');
-
-    const systemParams = await loadSystemParamsFromUrl('https://config.indigoprotocol.io/mainnet/mainnet-system-params-v21.json')
-    const address = await lucid.wallet().address();
-    const utxos = await lucid.wallet().getUtxos();
-    const walletBalance = balance(utxos);
-
-    console.log('Wallet Address', address);
-    console.log('Wallet Balance', walletBalance);
-
-    // const cdpOutRef: OutRef = {txHash: '70b09ded453b6122688d3cd51e2c75a007f2d801d1104eae734d8f5314b2b393', outputIndex: 0};
-
-    const cdpTx = await CDPContract.openPosition('iUSD', 10_000_000n, 7_820_000n,  systemParams, lucid);
-    const cdpBTx = await cdpTx.complete();
-    const cdpBsTx = await cdpBTx.sign.withWallet().complete();
-
-    console.log(cdpBsTx.toCBOR());
-    // const cdpTx = await CDPContract.openPosition(
-    //     'iUSD',
-    //     10_000_000n,
-    //     1_000_000n,
-    //     systemParams,
-    //     lucid
-    // );
-    // const cdpBTx = await cdpTx.complete()
-    // const cdpBsTx = await cdpBTx.sign.withWallet().complete()
-
-    // console.log(cdpBsTx.toCBOR());
-}
-
-main();

package/jest.config.js

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