@indigo-labs/indigo-sdk 0.4.3 → 0.4.4

package/tests/pyth/pyth-feeds.test.ts

@@ -0,0 +1,943 @@
+import {
+  fromHex,
+  SpendingValidator,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import {
+  AssetClassSP,
+  fromSysParamsPythFeedParams,
+  mkPythFeedValidator,
+  PythFeedParamsSP,
+  toDataDerivedPythPrice,
+} from '../../src';
+import { expect, test } from 'vitest';
+
+/******************************
+ ** Pyth configs for iAssets **
+ ******************************/
+
+const pythStateAssetClass: AssetClassSP = [
+  {
+    unCurrencySymbol:
+      'c935c937d0deda8975142c7b77aeef8f8cd48791e89a8ca7a0edc154',
+  },
+  {
+    unTokenName: 'Pyth State',
+  },
+];
+
+/** Config: 1 / ADA/USD => USD/ADA */
+test('iusd pyth feed', () => {
+  const IUSD_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'inverse',
+      val: {
+        tag: 'value',
+        val: {
+          priceFeedId: 16,
+        },
+      },
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iusdPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IUSD_PYTH_FEED_PARAMS),
+  );
+
+  const iusdPythFeedValidatorHash = validatorToScriptHash(
+    iusdPythFeedValidator,
+  );
+
+  expect(iusdPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Inverse: {
+            value: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iusdPythFeedValidatorHash).toEqual(
+    '4cb907af98c1ed5ee9f251691a0ec909f2a26b583ed271f2a88a55cb',
+  );
+});
+
+/** Config: BTC/USD / ADA/USD => BTC/ADA */
+test('ibtc pyth feed', () => {
+  const IBTC_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 1,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 16,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ibtcPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IBTC_PYTH_FEED_PARAMS),
+  );
+
+  const ibtcPythFeedValidatorHash = validatorToScriptHash(
+    ibtcPythFeedValidator,
+  );
+
+  expect(ibtcPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 1n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ibtcPythFeedValidatorHash).toEqual(
+    '77f65e4d14ed8106e8a97814bdb0e7688f652fe41c71295a42f11a26',
+  );
+});
+
+/** Config: ETH/USD / ADA/USD => ETH/ADA */
+test('ieth pyth feed', () => {
+  const IETH_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 16,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iethPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IETH_PYTH_FEED_PARAMS),
+  );
+
+  const iethPythFeedValidatorHash = validatorToScriptHash(
+    iethPythFeedValidator,
+  );
+
+  expect(iethPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iethPythFeedValidatorHash).toEqual(
+    '893828eeaa8bf4322559da69b69f0f36795d430f5942e2472cef8a88',
+  );
+});
+
+/** Config: SOL/USD / ADA/USD => SOL/ADA */
+test('isol pyth feed', () => {
+  const ISOL_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 6,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 16,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const isolPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(ISOL_PYTH_FEED_PARAMS),
+  );
+
+  const isolPythFeedValidatorHash = validatorToScriptHash(
+    isolPythFeedValidator,
+  );
+
+  expect(isolPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 6n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(isolPythFeedValidatorHash).toEqual(
+    '9a899983b90e2c2cfbc985cd34812a1ba393e169d7f7d277085ab14a',
+  );
+});
+
+/** Config: EUR/USD / ADA/USD => EUR/ADA */
+test('ieur pyth feed', () => {
+  const IEUR_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 327,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 16,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ieurPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IEUR_PYTH_FEED_PARAMS),
+  );
+
+  const ieurPythFeedValidatorHash = validatorToScriptHash(
+    ieurPythFeedValidator,
+  );
+
+  expect(ieurPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 327n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ieurPythFeedValidatorHash).toEqual(
+    '9da7071e0abb11aa4e1b669ae60592d3dbcaade6e9724c45b1a654eb',
+  );
+});
+
+/** Config: (1 / USD/JPY) / ADA/USD => JPY/ADA */
+test('ijpy pyth feed', () => {
+  const IJPY_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'inverse',
+          val: {
+            tag: 'value',
+            val: {
+              priceFeedId: 340,
+            },
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 16,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ijpyPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IJPY_PYTH_FEED_PARAMS),
+  );
+
+  const ijpyPythFeedValidatorHash = validatorToScriptHash(
+    ijpyPythFeedValidator,
+  );
+
+  expect(ijpyPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Inverse: {
+                value: toDataDerivedPythPrice({
+                  Value: { configuration: { priceFeedId: 340n } },
+                }),
+              },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ijpyPythFeedValidatorHash).toEqual(
+    '0db1238594da8cb18260454e115dd63bd9789aad487ff1d80f59799a',
+  );
+});
+
+/** Config: 1 / NIGHT/USD => USD/NIGHT */
+test('iusd night pyth feed', () => {
+  const IUSD_NIGHT_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'inverse',
+      val: {
+        tag: 'value',
+        val: {
+          priceFeedId: 2970,
+        },
+      },
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iusdNightPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IUSD_NIGHT_PYTH_FEED_PARAMS),
+  );
+
+  const iusdNightPythFeedValidatorHash = validatorToScriptHash(
+    iusdNightPythFeedValidator,
+  );
+
+  expect(iusdNightPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Inverse: {
+            value: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2970n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iusdNightPythFeedValidatorHash).toEqual(
+    '1d4c0f85dcbcc230f1550f30574206c5b9bddff47b7b135edb12de69',
+  );
+});
+
+/** Config: (EUR / USD) / (NIGHT/USD) => EUR/NIGHT */
+test('ieur night pyth feed', () => {
+  const IEUR_NIGHT_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 327,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2970,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ieurNightPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IEUR_NIGHT_PYTH_FEED_PARAMS),
+  );
+
+  const ieurNightPythFeedValidatorHash = validatorToScriptHash(
+    ieurNightPythFeedValidator,
+  );
+
+  expect(ieurNightPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 327n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2970n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ieurNightPythFeedValidatorHash).toEqual(
+    '2104dd1545835d7b13f2dd482bcc3943cf42ec15fa968411d4632149',
+  );
+});
+
+/** Config: (1 / USD/JPY) / (NIGHT/USD) => JPY/NIGHT */
+test('ijpy night pyth feed', () => {
+  const IJPY_NIGHT_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'inverse',
+          val: {
+            tag: 'value',
+            val: {
+              priceFeedId: 340,
+            },
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2970,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ijpyNightPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IJPY_NIGHT_PYTH_FEED_PARAMS),
+  );
+
+  const ijpyNightPythFeedValidatorHash = validatorToScriptHash(
+    ijpyNightPythFeedValidator,
+  );
+
+  expect(ijpyNightPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Inverse: {
+                value: toDataDerivedPythPrice({
+                  Value: { configuration: { priceFeedId: 340n } },
+                }),
+              },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2970n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ijpyNightPythFeedValidatorHash).toEqual(
+    '00bc4b3a8710593c2e25c6e151fbdff3ec79106e828a48e16f9422f8',
+  );
+});
+
+/** Config: (EUR / USD) / (USDCx/USD) => EUR/USDCx */
+test('ieur usdcx pyth feed', () => {
+  const IEUR_USDCX_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 327,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 7,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ieurUSDCxPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IEUR_USDCX_PYTH_FEED_PARAMS),
+  );
+
+  const ieurUSDCxPythFeedValidatorHash = validatorToScriptHash(
+    ieurUSDCxPythFeedValidator,
+  );
+
+  expect(ieurUSDCxPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 327n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 7n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ieurUSDCxPythFeedValidatorHash).toEqual(
+    '0b1d64e558d1c38e420c2348e8674c99cf9a4552ebc4e18c1f20a20b',
+  );
+});
+
+/** Config: (1 / USD/JPY) / (USDCx/USD) => JPY/USDCx */
+test('ijpy usdcx pyth feed', () => {
+  const IJPY_USDCX_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'inverse',
+          val: {
+            tag: 'value',
+            val: {
+              priceFeedId: 340,
+            },
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 7,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ijpyUSDCxPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IJPY_USDCX_PYTH_FEED_PARAMS),
+  );
+
+  const ijpyUSDCxPythFeedValidatorHash = validatorToScriptHash(
+    ijpyUSDCxPythFeedValidator,
+  );
+
+  expect(ijpyUSDCxPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Inverse: {
+                value: toDataDerivedPythPrice({
+                  Value: { configuration: { priceFeedId: 340n } },
+                }),
+              },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 7n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ijpyUSDCxPythFeedValidatorHash).toEqual(
+    'f2c4e1f46052f4f1de0088a9c70889b3bef48bd6015fd4c0adb3195c',
+  );
+});
+
+/** Config: (BTC / USD) / (NIGHT/USD) => BTC/NIGHT */
+test('ibtc night pyth feed', () => {
+  const IBTC_NIGHT_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 1,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2970,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ibtcNightPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IBTC_NIGHT_PYTH_FEED_PARAMS),
+  );
+
+  const ibtcNightPythFeedValidatorHash = validatorToScriptHash(
+    ibtcNightPythFeedValidator,
+  );
+
+  expect(ibtcNightPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 1n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2970n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ibtcNightPythFeedValidatorHash).toEqual(
+    '176c55745286f4a139bf69719514fb4769be572f0b009b31ae482a3d',
+  );
+});
+
+/** Config: (ETH / USD) / (NIGHT/USD) => BTC/NIGHT */
+test('ieth night pyth feed', () => {
+  const IETH_NIGHT_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2970,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iethNightPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IETH_NIGHT_PYTH_FEED_PARAMS),
+  );
+
+  const iethNightPythFeedValidatorHash = validatorToScriptHash(
+    iethNightPythFeedValidator,
+  );
+
+  expect(iethNightPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2970n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iethNightPythFeedValidatorHash).toEqual(
+    '9fd83fdd93a6945790498fe47fdeff28a8beda1f611784edcd1fee98',
+  );
+});
+
+/** Config: (BTC / USD) / (USDCx/USD) => BTC/USDCx */
+test('ibtc usdcx pyth feed', () => {
+  const IBTC_USDCX_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 1,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 7,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const ibtcUSDCxPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IBTC_USDCX_PYTH_FEED_PARAMS),
+  );
+
+  const ibtcUSDCxPythFeedValidatorHash = validatorToScriptHash(
+    ibtcUSDCxPythFeedValidator,
+  );
+
+  expect(ibtcUSDCxPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 1n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 7n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(ibtcUSDCxPythFeedValidatorHash).toEqual(
+    'df5a33036a62f20fa23f07d50a8da0b56714ae6c69f7389b82318fef',
+  );
+});
+
+/** Config: (ETH / USD) / (USDCx/USD) => BTC/USDCx */
+test('ieth usdcx pyth feed', () => {
+  const IETH_USDCX_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 7,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iethUSDCxPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IETH_USDCX_PYTH_FEED_PARAMS),
+  );
+
+  const iethUSDCxPythFeedValidatorHash = validatorToScriptHash(
+    iethUSDCxPythFeedValidator,
+  );
+
+  expect(iethUSDCxPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 7n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iethUSDCxPythFeedValidatorHash).toEqual(
+    'f83f5e86412ad360e1f6f248503b11fa92edf4aaa4a6799f1f067317',
+  );
+});
+
+/** Config: (ADA / USD) / (USD/NIGHT) => ADA/NIGHT */
+test('iada night pyth feed', () => {
+  const IADA_NIGHT_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'divide',
+      val: [
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 16,
+          },
+        },
+        {
+          tag: 'value',
+          val: {
+            priceFeedId: 2970,
+          },
+        },
+      ],
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iadaNightPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IADA_NIGHT_PYTH_FEED_PARAMS),
+  );
+
+  const iadaNightPythFeedValidatorHash = validatorToScriptHash(
+    iadaNightPythFeedValidator,
+  );
+
+  expect(iadaNightPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Divide: {
+            x: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 16n } },
+            }),
+            y: toDataDerivedPythPrice({
+              Value: { configuration: { priceFeedId: 2970n } },
+            }),
+          },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iadaNightPythFeedValidatorHash).toEqual(
+    'c16544a7009549cf26bde1cead12859b1933186da3c2717cd30074b9',
+  );
+});
+
+/** Config: ADA / USD */
+test('iada usdcx pyth feed', () => {
+  const IADA_USDCX_PYTH_FEED_PARAMS: PythFeedParamsSP = {
+    config: {
+      tag: 'value',
+      val: {
+        priceFeedId: 16,
+      },
+    },
+    pythStatePolicyId: pythStateAssetClass[0],
+  };
+
+  const iadaUSDCxPythFeedValidator: SpendingValidator = mkPythFeedValidator(
+    fromSysParamsPythFeedParams(IADA_USDCX_PYTH_FEED_PARAMS),
+  );
+
+  const iadaUSDCxPythFeedValidatorHash = validatorToScriptHash(
+    iadaUSDCxPythFeedValidator,
+  );
+
+  expect(iadaUSDCxPythFeedValidatorHash).toEqual(
+    // Rebuild the params without conversion functions as well.
+    validatorToScriptHash(
+      mkPythFeedValidator({
+        config: {
+          Value: { configuration: { priceFeedId: 16n } },
+        },
+        pythStatePolicyId: fromHex(pythStateAssetClass[0].unCurrencySymbol),
+      }),
+    ),
+  );
+
+  expect(iadaUSDCxPythFeedValidatorHash).toEqual(
+    '075b0ce5d592d51262e6d3e1c8a88e94c86470f95dc7b8e7a9139782',
+  );
+});