@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/stableswap/stableswap-actions.ts

@@ -1,83 +0,0 @@
-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,
-    (
-      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

@@ -1,98 +0,0 @@
-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 findAllStableswapOrders(
-  lucid: LucidEvolution,
-  stableswapScriptHash: ScriptHash,
-): Promise<{ utxo: UTxO; datum: StableswapOrderDatum }[]> {
-  const psmUtxos = await lucid.utxosAt(
-    createScriptAddress(lucid.config().network!, stableswapScriptHash),
-  );
-
-  const orders = F.pipe(
-    psmUtxos.map((utxo) =>
-      F.pipe(
-        O.fromNullable(utxo.datum),
-        O.flatMap(parseStableswapOrderDatum),
-        O.map((datum) => {
-          return { utxo, datum: datum };
-        }),
-      ),
-    ),
-    A.compact,
-  );
-
-  return orders;
-}
-
-export async function findStableswapOrders(
-  lucid: LucidEvolution,
-  stableswapScriptHash: ScriptHash,
-  iassetName: string,
-  collateralAsset: AssetClass,
-): Promise<{ utxo: UTxO; datum: StableswapOrderDatum }[]> {
-  const allPsmOrders = await findAllStableswapOrders(
-    lucid,
-    stableswapScriptHash,
-  );
-
-  return allPsmOrders.filter(
-    (order) =>
-      toHex(order.datum.iasset) === iassetName &&
-      toHex(order.datum.collateralAsset.currencySymbol) ===
-        toHex(collateralAsset.currencySymbol) &&
-      toHex(order.datum.collateralAsset.tokenName) ===
-        toHex(collateralAsset.tokenName),
-  );
-}