@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/tests/pyth/pyth.test.ts

@@ -0,0 +1,300 @@
+import {
+  credentialToRewardAddress,
+  Data,
+  Emulator,
+  EmulatorAccount,
+  fromHex,
+  generateEmulatorAccount,
+  Lucid,
+  scriptHashToCredential,
+  slotToUnixTime,
+  toHex,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { LucidContext, runAndAwaitTxBuilder } from '../test-helpers';
+import {
+  initPyth,
+  TEST_TRUSTED_SIGNER_PRIV_KEY,
+  TEST_TRUSTED_SIGNER_PUB_KEY,
+} from './endpoints';
+import {
+  PythFeedParams,
+  PythStateDatum,
+  serialisePythFeedRedeemer,
+  serialisePythStateDatum,
+  serialisePythUpdatesRedeemer,
+  toDataDerivedPythPrice,
+} from '../../src/contracts/pyth-feed/types';
+import { assetClassToUnit } from '@3rd-eye-labs/cardano-offchain-common';
+import { mkPythFeedValidator } from '../../src/contracts/pyth-feed/scripts';
+import { alwaysSucceedValidator } from '../always-succeed/script';
+import {
+  encodePriceUpdate,
+  encodePythMessage,
+  type PriceUpdate,
+  type PythMessageParts,
+} from '../../src/utils/pyth';
+import { MAINNET_PROTOCOL_PARAMETERS } from '../indigo-test-helpers';
+import { createPythMessage } from './helpers';
+import { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
+import { derivePythPrice } from '../../src/contracts/pyth-feed/helpers';
+import * as Core from '@evolution-sdk/evolution';
+
+type MyContext = LucidContext<{
+  admin: EmulatorAccount;
+}>;
+
+describe('Pyth > Initialization', () => {
+  beforeEach<MyContext>(async (context: MyContext) => {
+    context.users = {
+      admin: generateEmulatorAccount({
+        lovelace: BigInt(100_000_000_000_000),
+      }),
+    };
+
+    context.emulator = new Emulator(
+      [context.users.admin],
+      MAINNET_PROTOCOL_PARAMETERS,
+    );
+
+    context.lucid = await Lucid(context.emulator, 'Custom');
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+  });
+
+  test('initPyth initializes the Pyth State NFT', async (context: MyContext) => {
+    const pythStateAsset = await initPyth(context.lucid);
+
+    expect(pythStateAsset).toBeDefined();
+  });
+
+  test('Properly serializes a Pyth State datum', (_context: MyContext) => {
+    const pythStateDatum: PythStateDatum = {
+      governance: {
+        wormhole: fromHex(''),
+        emitterChain: 0n,
+        emitterAddress: fromHex(''),
+        seenSequence: 0n,
+      },
+      trustedSigners: new Map([
+        [
+          fromHex(
+            '4a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71f',
+          ),
+          {
+            lower_bound: {
+              bound_type: {
+                _tag: 'NegativeInfinity',
+              },
+              is_inclusive: true,
+            },
+            upper_bound: {
+              bound_type: {
+                _tag: 'Finite',
+                finite: 1n,
+              },
+              is_inclusive: true,
+            },
+          },
+        ],
+      ]),
+      deprecatedWithdrawScripts: new Map(),
+      withdraw_script: fromHex(
+        '7688145a4fa7aa18c16ef0daafeec18091ab99ea4268cfe2d863c79fda131938',
+      ),
+    };
+
+    const serialisedPythStateDatum = serialisePythStateDatum(pythStateDatum);
+    expect(serialisedPythStateDatum).toBe(
+      'd8799fd8799f40004000ffa158204a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71fd8799fd8799fd87980d87a80ffd8799fd87a9f01ffd87a80ffffa058207688145a4fa7aa18c16ef0daafeec18091ab99ea4268cfe2d863c79fda131938ff',
+    );
+  });
+
+  test('Pyth Feed validator can confirm a Pyth Message', async (context: MyContext) => {
+    const pythStateAsset = await initPyth(context.lucid);
+
+    const noble = await import('@noble/ed25519');
+    const priceFeedId = 1;
+    const price = 1000n;
+    const exponent = -8;
+
+    const params: PythFeedParams = {
+      pythStatePolicyId: pythStateAsset.currencySymbol,
+      config: {
+        Value: { configuration: { priceFeedId: BigInt(priceFeedId) } },
+      },
+    };
+
+    const pfvValidator = mkPythFeedValidator(params);
+    const pfvValHash = validatorToScriptHash(pfvValidator);
+
+    // Register the stake key for pyth feed validator.
+    await runAndAwaitTxBuilder(
+      context.lucid,
+      context.lucid.newTx().register.Stake(
+        credentialToRewardAddress(context.lucid.config().network!, {
+          hash: pfvValHash,
+          type: 'Script',
+        }),
+      ),
+    );
+
+    const currentTime = BigInt(
+      slotToUnixTime(context.lucid.config().network!, context.emulator.slot),
+    );
+
+    // This is to test the transaction validity when using a timestamp different than the
+    // slot boundary (which is the usual and general case).
+    const timestamp = currentTime - 10n;
+
+    const update: PriceUpdate = {
+      timestampUs: (timestamp * 1_000n).toString(),
+      channelId: 0,
+      priceFeeds: [
+        {
+          priceFeedId,
+          price: price.toString(),
+          exponent,
+        },
+      ],
+    };
+    const payload = encodePriceUpdate(update);
+    const signature = await noble.signAsync(
+      payload,
+      fromHex(TEST_TRUSTED_SIGNER_PRIV_KEY),
+    );
+    const parts: PythMessageParts = {
+      signature,
+      publicKey: fromHex(TEST_TRUSTED_SIGNER_PUB_KEY),
+      payload,
+    };
+    const message = encodePythMessage(parts);
+
+    const pythStateUtxo = await context.lucid.utxoByUnit(
+      assetClassToUnit(pythStateAsset),
+    );
+
+    await runAndAwaitTxBuilder(
+      context.lucid,
+      context.lucid
+        .newTx()
+        .readFrom([pythStateUtxo])
+        .attach.Script(pfvValidator)
+        .validFrom(Number(timestamp))
+        .validTo(Number(timestamp) + 60 * 1000)
+        .withdraw(
+          credentialToRewardAddress(
+            context.lucid.config().network!,
+            scriptHashToCredential(pfvValHash),
+          ),
+          0n,
+          serialisePythFeedRedeemer({
+            price: {
+              numerator: 1_000n,
+              denominator: 100_000_000n,
+            },
+            auxiliaryData: Core.Data.fromCBORHex(Data.void()),
+          }),
+        )
+        .withdraw(
+          credentialToRewardAddress(
+            context.lucid.config().network!,
+            scriptHashToCredential(
+              validatorToScriptHash(alwaysSucceedValidator),
+            ),
+          ),
+          0n,
+          serialisePythUpdatesRedeemer([message]),
+        ),
+    );
+  });
+});
+
+describe('Pyth > Helper functions', () => {
+  test('derivePythPrice works', async () => {
+    const feed1: ParsedFeedPayload = {
+      priceFeedId: 1,
+      price: '1000',
+      exponent: -8,
+    };
+    const feed2: ParsedFeedPayload = {
+      priceFeedId: 2,
+      price: '99',
+      exponent: 0,
+    };
+    const feed3: ParsedFeedPayload = {
+      priceFeedId: 3,
+      price: '45',
+      exponent: 0,
+    };
+    const message = await createPythMessage(
+      [feed1, feed2, feed3],
+      BigInt(Date.now()),
+    );
+
+    // Single direct value
+    // 1000 * 10^-8 = 0.00001
+    {
+      const price = derivePythPrice(
+        {
+          Value: {
+            configuration: { priceFeedId: 1n },
+          },
+        },
+        toHex(message),
+      );
+
+      expect(price.numerator).toBe(1_000n);
+      expect(price.denominator).toBe(100_000_000n);
+    }
+
+    // Single inverse value: 1 / (1000 * 10^-8) = 1 / 0.00001 = 100000
+    {
+      const price = derivePythPrice(
+        {
+          Inverse: {
+            value: toDataDerivedPythPrice({
+              Value: {
+                configuration: {
+                  priceFeedId: 1n,
+                },
+              },
+            }),
+          },
+        },
+        toHex(message),
+      );
+
+      expect(price.numerator).toBe(100_000_000n);
+      expect(price.denominator).toBe(1_000n);
+    }
+
+    // Single divide value: 99 / 45 = 2.2
+    {
+      const price = derivePythPrice(
+        {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: {
+                configuration: {
+                  priceFeedId: 2n,
+                },
+              },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: {
+                configuration: {
+                  priceFeedId: 3n,
+                },
+              },
+            }),
+          },
+        },
+        toHex(message),
+      );
+
+      expect(price.numerator).toBe(99n);
+      expect(price.denominator).toBe(45n);
+    }
+  });
+});

package/tests/queries/execute-queries.ts

@@ -1,13 +1,14 @@
 import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
+import { createScriptAddress, matchSingle } from '../../src';
+import { option as O, array as A, function as F } from 'fp-ts';
 import {
   AssetClass,
-  createScriptAddress,
+  assetClassToUnit,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
   ExecuteDatum,
-  matchSingle,
   parseExecuteDatum,
-} from '../../src';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
-import { option as O, array as A, function as F } from 'fp-ts';
+} from '../../src/contracts/execute/types-new';
 
 export async function findExecute(
   lucid: LucidEvolution,

package/tests/queries/iasset-queries.ts

@@ -1,10 +1,27 @@
-import { fromText, LucidEvolution, ScriptHash } from '@lucid-evolution/lucid';
+import {
+  fromText,
+  LucidEvolution,
+  ScriptHash,
+  toHex,
+  toText,
+} from '@lucid-evolution/lucid';
 import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
-import { IAssetOutput, matchSingle, parseIAssetDatum } from '../../src';
+import { fromSystemParamsAsset, matchSingle, SystemParams } from '../../src';
 import { option as O, array as A, function as F } from 'fp-ts';
+import {
+  AssetClass,
+  assetClassToUnit,
+  isSameAssetClass,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  CollateralAssetOutput,
+  IAssetOutput,
+  parseCollateralAssetDatum,
+  parseIAssetDatum,
+} from '../../src/contracts/iasset/types';
+import { LucidContext } from '../test-helpers';
 
+// TODO: replace with the new variant defined below
 export async function findIAsset(
   lucid: LucidEvolution,
   iassetScriptHash: ScriptHash,
@@ -24,7 +41,45 @@ export async function findIAsset(
           O.fromNullable(utxo.datum),
           O.flatMap(parseIAssetDatum),
           O.flatMap((datum) => {
-            if (datum.assetName === fromText(iassetName)) {
+            if (toHex(datum.assetName) === fromText(iassetName)) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error('Expected a single IAsset UTXO.: ' + JSON.stringify(res)),
+  );
+}
+
+export async function findIAssetNew(
+  context: LucidContext,
+  sysParams: SystemParams,
+  // Ascii encoded
+  iassetName: string,
+): Promise<IAssetOutput> {
+  const iassetUtxos = await context.lucid.utxosAtWithUnit(
+    createScriptAddress(
+      context.lucid.config().network!,
+      sysParams.validatorHashes.iassetHash,
+    ),
+    assetClassToUnit(
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+    ),
+  );
+
+  return matchSingle(
+    F.pipe(
+      iassetUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseIAssetDatum),
+          O.flatMap((datum) => {
+            if (toHex(datum.assetName) === fromText(iassetName)) {
               return O.some({ utxo, datum: datum });
             } else {
               return O.none;
@@ -60,3 +115,118 @@ export async function findAllIAssets(
     A.compact,
   );
 }
+
+// TODO: replace by the new variant defined below
+export async function findCollateralAsset(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  collateralAssetNft: AssetClass,
+  // Ascii encoded
+  iassetName: string,
+  collateralAsset: AssetClass,
+): Promise<CollateralAssetOutput> {
+  const collateralAssetUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.iassetHash,
+    ),
+    assetClassToUnit(collateralAssetNft),
+  );
+
+  return matchSingle(
+    F.pipe(
+      collateralAssetUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseCollateralAssetDatum),
+          O.flatMap((datum) => {
+            if (
+              isSameAssetClass(datum.collateralAsset, collateralAsset) &&
+              fromText(iassetName) === toHex(datum.iasset)
+            ) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error(
+        'Expected a single Collateral Asset UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}
+
+export async function findCollateralAssetNew(
+  context: LucidContext,
+  sysParams: SystemParams,
+  // Ascii encoded
+  iassetName: string,
+  collateralAsset: AssetClass,
+): Promise<CollateralAssetOutput> {
+  const collateralAssetUtxos = await context.lucid.utxosAtWithUnit(
+    createScriptAddress(
+      context.lucid.config().network!,
+      sysParams.validatorHashes.iassetHash,
+    ),
+    assetClassToUnit(
+      fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
+    ),
+  );
+
+  return matchSingle(
+    F.pipe(
+      collateralAssetUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseCollateralAssetDatum),
+          O.flatMap((datum) => {
+            if (
+              isSameAssetClass(datum.collateralAsset, collateralAsset) &&
+              fromText(iassetName) === toHex(datum.iasset)
+            ) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error(
+        'Expected a single Collateral Asset UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}
+
+export async function findAllCollateralAssetsOfIAsset(
+  lucid: LucidEvolution,
+  iassetScriptHash: ScriptHash,
+  collateralAssetNft: AssetClass,
+  iasset: Uint8Array<ArrayBufferLike>,
+): Promise<CollateralAssetOutput[]> {
+  const collateralUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, iassetScriptHash),
+    assetClassToUnit(collateralAssetNft),
+  );
+
+  return F.pipe(
+    collateralUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseCollateralAssetDatum),
+        O.filter(
+          (collateralAsset) =>
+            toText(toHex(collateralAsset.iasset)) === toText(toHex(iasset)),
+        ),
+        O.map((datum) => ({ utxo, datum: datum })),
+      ),
+    ),
+    A.compact,
+  );
+}

package/tests/queries/interest-oracle-queries.ts

@@ -1,6 +1,8 @@
+import {
+  AssetClass,
+  assetClassToUnit,
+} from '@3rd-eye-labs/cardano-offchain-common';
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
 
 export async function findInterestOracle(
   lucid: LucidEvolution,

package/tests/queries/poll-queries.ts

@@ -1,18 +1,17 @@
 import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
+
+import { matchSingle, createScriptAddress, getRandomElement } from '../../src';
+import { option as O, array as A, function as F } from 'fp-ts';
+import {
+  AssetClass,
+  assetClassToUnit,
+} from '@3rd-eye-labs/cardano-offchain-common';
 import {
   parsePollManager,
   parsePollShard,
   PollManagerContent,
   PollShardContent,
-} from '../../src/contracts/poll/types-poll';
-import {
-  AssetClass,
-  matchSingle,
-  createScriptAddress,
-  getRandomElement,
-} from '../../src';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
-import { option as O, array as A, function as F } from 'fp-ts';
+} from '../../src/contracts/poll/types-poll-new';
 
 export async function findPollManager(
   lucid: LucidEvolution,