@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/stableswap/stableswap-actions.ts

@@ -0,0 +1,84 @@
+import { fromHex, fromText, paymentCredentialOf } from '@lucid-evolution/lucid';
+import { createProposal, fromSystemParamsAsset } from '../../src';
+import { processSuccessfulProposal } from '../gov/actions';
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import { findGov } from '../gov/governance-queries';
+import { IndigoTestContext, runAndAwaitTxBuilder } from '../test-helpers';
+import { findRandomCdpCreator } from '../cdp/cdp-queries';
+import { findIAsset } from '../queries/iasset-queries';
+import { Rational, rationalFromInt } from '../../src/types/rational';
+
+export async function runCreateStableswapPool(
+  iasset: string,
+  collateralAsset: AssetClass,
+  context: IndigoTestContext,
+  ratioAssets?: Rational,
+  mintingFeeRatio?: Rational,
+  redemptionFeeRatio?: Rational,
+): Promise<void> {
+  const feeManager = fromHex(
+    paymentCredentialOf(context.users.admin.address).hash,
+  );
+  const [tx, pollId] = await createProposal(
+    {
+      ProposeStableswapPool: {
+        iasset: fromHex(fromText(iasset)),
+        collateralAsset: collateralAsset,
+        collateralToIassetRatio: ratioAssets
+          ? ratioAssets
+          : rationalFromInt(1n),
+        mintingFeeRatio: mintingFeeRatio
+          ? mintingFeeRatio
+          : { numerator: 5n, denominator: 1_000n },
+        redemptionFeeRatio: redemptionFeeRatio
+          ? redemptionFeeRatio
+          : { numerator: 5n, denominator: 1_000n },
+        feeManager: feeManager,
+        minMintingAmount: 0n,
+        minRedemptionAmount: 0n,
+        stableswapValHash: fromHex(
+          context.systemParams.validatorHashes.stableswapHash,
+        ),
+      },
+    },
+    null,
+    context.systemParams,
+    context.lucid,
+    context.emulator.slot,
+    (
+      await findGov(
+        context.lucid,
+        context.systemParams.validatorHashes.govHash,
+        fromSystemParamsAsset(context.systemParams.govParams.govNFT),
+      )
+    ).utxo,
+    undefined,
+  );
+
+  await runAndAwaitTxBuilder(context.lucid, tx);
+
+  const iassetReference = await findIAsset(
+    context.lucid,
+    context.systemParams.validatorHashes.iassetHash,
+    fromSystemParamsAsset(context.systemParams.cdpParams.iAssetAuthToken),
+    'iUSD',
+  );
+
+  const cdpCreatorUtxo = await findRandomCdpCreator(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpCreatorHash,
+    fromSystemParamsAsset(context.systemParams.cdpCreatorParams.cdpCreatorNft),
+  );
+
+  await processSuccessfulProposal(
+    pollId,
+    null,
+    null,
+    iassetReference.utxo,
+    null,
+    null,
+    cdpCreatorUtxo,
+    context.systemParams,
+    context,
+  );
+}

package/tests/stableswap/stableswap-queries.ts

@@ -0,0 +1,89 @@
+import { AssetClass, matchSingle } from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  LucidEvolution,
+  ScriptHash,
+  toHex,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  parseStableswapOrderDatum,
+  StableswapOrderDatum,
+} from '../../src/contracts/stableswap/types-new';
+import { createScriptAddress } from '../../src';
+import { array as A, function as F, option as O } from 'fp-ts';
+
+export async function findSingleStableswapOrder(
+  lucid: LucidEvolution,
+  stableswapScriptHash: ScriptHash,
+  iassetName: string,
+  collateralAsset: AssetClass,
+): Promise<{ utxo: UTxO; datum: StableswapOrderDatum }> {
+  const cdpUtxos = await lucid.utxosAt(
+    createScriptAddress(lucid.config().network!, stableswapScriptHash),
+  );
+
+  return matchSingle(
+    F.pipe(
+      cdpUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseStableswapOrderDatum),
+          O.flatMap((datum) => {
+            if (
+              toHex(datum.iasset) === iassetName &&
+              toHex(datum.collateralAsset.currencySymbol) ===
+                toHex(collateralAsset.currencySymbol) &&
+              toHex(datum.collateralAsset.tokenName) ===
+                toHex(collateralAsset.tokenName)
+            ) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error(
+        'Expected a single stableswap order UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}
+
+export async function findStableswapOrders(
+  lucid: LucidEvolution,
+  stableswapScriptHash: ScriptHash,
+  iassetName: string,
+  collateralAsset: AssetClass,
+): Promise<{ utxo: UTxO; datum: StableswapOrderDatum }[]> {
+  const cdpUtxos = await lucid.utxosAt(
+    createScriptAddress(lucid.config().network!, stableswapScriptHash),
+  );
+
+  const orders = F.pipe(
+    cdpUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseStableswapOrderDatum),
+        O.flatMap((datum) => {
+          if (
+            toHex(datum.iasset) === iassetName &&
+            toHex(datum.collateralAsset.currencySymbol) ===
+              toHex(collateralAsset.currencySymbol) &&
+            toHex(datum.collateralAsset.tokenName) ===
+              toHex(collateralAsset.tokenName)
+          ) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+
+  return orders;
+}