@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/contracts/price-oracle/transactions.ts

@@ -1,5 +1,7 @@
 import {
   addAssets,
+  Data,
+  fromHex,
   fromText,
   LucidEvolution,
   OutRef,
@@ -7,29 +9,32 @@ import {
   TxBuilder,
   validatorToAddress,
 } from '@lucid-evolution/lucid';
-import { AssetClass } from '../../types/generic';
+import { PriceOracleParams } from './types';
+import { mkPriceOracleValidator } from './scripts';
+import { oneShotMintTx } from '../one-shot/transactions';
+import { AssetClass, mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
+import { matchSingle } from '../../utils/utils';
+import { ONE_SECOND } from '../../utils/time-helpers';
 import {
-  OracleAssetNft,
   PriceOracleDatum,
-  PriceOracleParams,
   serialisePriceOracleDatum,
   serialisePriceOracleRedeemer,
-} from './types';
-import { mkPriceOracleValidator } from './scripts';
-import { oneShotMintTx } from '../one-shot/transactions';
-import { mkAssetsOf, mkLovelacesOf } from '../../utils/value-helpers';
-import { OnChainDecimal } from '../../types/on-chain-decimal';
-import { ONE_SECOND } from '../../utils/time-helpers';
-import { resolveUtxo, UtxoOrOutRef } from '../../utils/lucid-utils';
+} from './types-new';
+import * as Core from '@evolution-sdk/evolution';
+import { Rational } from '../../types/rational';
 
 export async function startPriceOracleTx(
   lucid: LucidEvolution,
   assetName: string,
-  startPrice: OnChainDecimal,
+  startPrice: Rational,
   oracleParams: PriceOracleParams,
-  now: number = Date.now(),
+  currentSlot: number,
   refOutRef?: OutRef,
-): Promise<[TxBuilder, OracleAssetNft]> {
+  auxiliaryData?: Core.Data.Data,
+): Promise<[TxBuilder, AssetClass]> {
+  const network = lucid.config().network!;
+  const now = BigInt(slotToUnixTime(network, currentSlot));
+
   if (!refOutRef) {
     refOutRef = (await lucid.wallet().getUtxos())[0];
   }
@@ -48,40 +53,41 @@ export async function startPriceOracleTx(
   });
 
   const priceOracleNft: AssetClass = {
-    currencySymbol: oracleNftPolicyId,
-    tokenName: fromText(assetName),
+    currencySymbol: fromHex(oracleNftPolicyId),
+    tokenName: fromHex(fromText(assetName)),
   };
 
   const oracleValidator = mkPriceOracleValidator(oracleParams);
 
   const oracleDatum: PriceOracleDatum = {
     price: startPrice,
-    expiration: BigInt(now) + oracleParams.expiration,
+    expirationTime: BigInt(now) + oracleParams.expirationPeriod,
+    auxiliaryData: auxiliaryData ?? Core.Data.fromCBORHex(Data.void()),
   };
 
   tx.pay.ToContract(
     validatorToAddress(lucid.config().network!, oracleValidator),
     { kind: 'inline', value: serialisePriceOracleDatum(oracleDatum) },
-    addAssets(mkLovelacesOf(5_000_000n), mkAssetsOf(priceOracleNft, 1n)),
+    addAssets(mkAssetsOf(priceOracleNft, 1n)),
   );
 
-  return [tx, { oracleNft: priceOracleNft }];
+  return [tx, priceOracleNft];
 }
 
 export async function feedPriceOracleTx(
   lucid: LucidEvolution,
-  oracle: UtxoOrOutRef,
-  newPrice: OnChainDecimal,
+  oracleOref: OutRef,
+  newPrice: Rational,
   oracleParams: PriceOracleParams,
   currentSlot: number,
+  auxiliaryData?: Core.Data.Data,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
 
-  const priceOracleUtxo = await resolveUtxo(
-    oracle,
-    lucid,
-    'Expected a single price oracle UTXO',
+  const priceOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([oracleOref]),
+    (_) => new Error('Expected a single price oracle UTXO'),
   );
 
   const oracleValidator = mkPriceOracleValidator(oracleParams);
@@ -104,7 +110,8 @@ export async function feedPriceOracleTx(
         kind: 'inline',
         value: serialisePriceOracleDatum({
           price: newPrice,
-          expiration: currentTime + oracleParams.expiration,
+          expirationTime: currentTime + oracleParams.expirationPeriod,
+          auxiliaryData: auxiliaryData ?? Core.Data.fromCBORHex(Data.void()),
         }),
       },
       priceOracleUtxo.assets,

package/src/contracts/price-oracle/types-new.ts

@@ -0,0 +1,50 @@
+import { TSchema, Data } from '@evolution-sdk/evolution';
+import { Schema } from 'effect';
+import { RationalSchema } from '../../types/rational';
+
+const OpaqueData = Schema.typeSchema(Data.DataSchema);
+
+export const OracleIdxSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      OracleRefInputIdx: TSchema.Integer,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      OracleOutputIdx: TSchema.Integer,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('OracleVoid', { flatInUnion: true }),
+);
+
+export type OracleIdx = typeof OracleIdxSchema;
+
+const PriceOracleDatumSchema = TSchema.Struct({
+  price: RationalSchema,
+  expirationTime: TSchema.Integer,
+  auxiliaryData: OpaqueData,
+});
+
+export type PriceOracleDatum = typeof PriceOracleDatumSchema.Type;
+
+const PriceOracleRedeemerSchema = TSchema.Struct({
+  currentTime: TSchema.Integer,
+  newPrice: RationalSchema,
+});
+
+export type PriceOracleRedeemer = typeof PriceOracleRedeemerSchema.Type;
+
+export function serialisePriceOracleRedeemer(r: PriceOracleRedeemer): string {
+  return Data.withSchema(PriceOracleRedeemerSchema).toCBORHex(r);
+}
+
+export function serialisePriceOracleDatum(d: PriceOracleDatum): string {
+  return Data.withSchema(PriceOracleDatumSchema).toCBORHex(d);
+}
+
+export function parsePriceOracleDatum(datum: string): PriceOracleDatum {
+  return Data.withSchema(PriceOracleDatumSchema).fromCBORHex(datum);
+}

package/src/contracts/price-oracle/types.ts

@@ -1,50 +1,16 @@
-import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
-
-export const OracleAssetNftSchema = Data.Object({
-  oracleNft: AssetClassSchema,
-});
-export type OracleAssetNft = Data.Static<typeof OracleAssetNftSchema>;
+import { Data } from '@lucid-evolution/lucid';
 
 export const PriceOracleParamsSchema = Data.Object({
   owner: Data.Bytes(),
   /**  Milliseconds */
   biasTime: Data.Integer(),
   /**  Milliseconds */
-  expiration: Data.Integer(),
+  expirationPeriod: Data.Integer(),
 });
 export type PriceOracleParams = Data.Static<typeof PriceOracleParamsSchema>;
 const PriceOracleParams =
   PriceOracleParamsSchema as unknown as PriceOracleParams;
 
-export const PriceOracleDatumSchema = Data.Object({
-  price: OnChainDecimalSchema,
-  expiration: Data.Integer(),
-});
-export type PriceOracleDatum = Data.Static<typeof PriceOracleDatumSchema>;
-const PriceOracleDatum = PriceOracleDatumSchema as unknown as PriceOracleDatum;
-
-const PriceOracleRedeemerSchema = Data.Object({
-  currentTime: Data.Integer(),
-  newPrice: OnChainDecimalSchema,
-});
-export type PriceOracleRedeemer = Data.Static<typeof PriceOracleRedeemerSchema>;
-const PriceOracleRedeemer =
-  PriceOracleRedeemerSchema as unknown as PriceOracleRedeemer;
-
-export function serialisePriceOracleRedeemer(r: PriceOracleRedeemer): Redeemer {
-  return Data.to<PriceOracleRedeemer>(r, PriceOracleRedeemer);
-}
-
-export function parsePriceOracleDatum(datum: Datum): PriceOracleDatum {
-  return Data.from<PriceOracleDatum>(datum, PriceOracleDatum);
-}
-
-export function serialisePriceOracleDatum(datum: PriceOracleDatum): Datum {
-  return Data.to<PriceOracleDatum>(datum, PriceOracleDatum);
-}
-
 export function castPriceOracleParams(params: PriceOracleParams): Data {
   return Data.castTo(params, PriceOracleParams);
 }

package/src/contracts/pyth-feed/helpers.ts

@@ -0,0 +1,58 @@
+import { match, P } from 'ts-pattern';
+import { Rational } from '../../types/rational';
+import { decodePriceUpdate, decodePythMessage } from '../../utils/pyth';
+import {
+  DerivedPythPrice,
+  fromDataDerivedPythPrice,
+  PythConfiguration,
+} from './types';
+import { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
+import { fromHex } from '@lucid-evolution/lucid';
+
+/** Rational form { num, den } so we can do exact division (e.g. 1/0.00001 = 100000). */
+export function derivePythPrice(
+  derivedPythPrice: DerivedPythPrice,
+  messageHex: string,
+): Rational {
+  const decodedMessage = decodePythMessage(fromHex(messageHex));
+  const pricePayload = decodePriceUpdate(decodedMessage.payload);
+  return match(derivedPythPrice)
+    .with(
+      { Value: P.select() },
+      (value: { configuration: PythConfiguration }) => {
+        const payload = pricePayload.priceFeeds.find(
+          (p: ParsedFeedPayload) =>
+            p.priceFeedId === Number(value.configuration.priceFeedId),
+        );
+        if (!payload)
+          throw new Error(
+            `Pyth payload not found for feed ID: ${value.configuration.priceFeedId}`,
+          );
+        const priceStr = payload.price;
+        if (priceStr === undefined)
+          throw new Error(`Pyth feed ${payload.priceFeedId} has no price`);
+        const price = BigInt(priceStr);
+        const exp = payload.exponent ?? 0;
+        if (exp >= 0) {
+          return { numerator: price * 10n ** BigInt(exp), denominator: 1n };
+        }
+        return { numerator: price, denominator: 10n ** BigInt(-exp) };
+      },
+    )
+    .with({ Inverse: P.select() }, (inverse) => {
+      const inner = derivePythPrice(
+        fromDataDerivedPythPrice(inverse.value),
+        messageHex,
+      );
+      return { numerator: inner.denominator, denominator: inner.numerator };
+    })
+    .with({ Divide: P.select() }, (divide) => {
+      const x = derivePythPrice(fromDataDerivedPythPrice(divide.x), messageHex);
+      const y = derivePythPrice(fromDataDerivedPythPrice(divide.y), messageHex);
+      return {
+        numerator: x.numerator * y.denominator,
+        denominator: x.denominator * y.numerator,
+      };
+    })
+    .exhaustive();
+}

package/src/contracts/pyth-feed/scripts.ts

@@ -0,0 +1,15 @@
+import { SpendingValidator } from '@lucid-evolution/lucid';
+import { _pythFeedValidator } from '../../validators/pyth-feed-validator';
+import { applyParamsToScript } from '@evolution-sdk/evolution/uplc';
+import { PythFeedParams, serialisePythFeedParams } from './types';
+
+export const mkPythFeedValidator = (
+  params: PythFeedParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_pythFeedValidator.cborHex, [
+      serialisePythFeedParams(params),
+    ]),
+  };
+};

package/src/contracts/pyth-feed/types.ts

@@ -0,0 +1,181 @@
+import { TSchema, Data, Schema } from '@evolution-sdk/evolution';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+import { RationalSchema } from '../../types/rational';
+
+const PythConfigurationSchema = TSchema.Struct({
+  priceFeedId: TSchema.Integer,
+});
+
+export type PythConfiguration = typeof PythConfigurationSchema.Type;
+
+const OpaqueData = Schema.typeSchema(Data.DataSchema);
+
+export const DerivedPythPriceSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      Value: TSchema.Struct(
+        { configuration: PythConfigurationSchema },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      Inverse: TSchema.Struct({ value: OpaqueData }, { flatFields: true }),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      Divide: TSchema.Struct(
+        { x: OpaqueData, y: OpaqueData },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+);
+
+export type DerivedPythPrice = typeof DerivedPythPriceSchema.Type;
+
+export function fromDataDerivedPythPrice(data: Data.Data): DerivedPythPrice {
+  return Data.withSchema(DerivedPythPriceSchema).fromCBORHex(
+    Data.toCBORHex(data),
+  );
+}
+
+export function toDataDerivedPythPrice(
+  derivedPythPrice: DerivedPythPrice,
+): Data.Data {
+  return Data.withSchema(DerivedPythPriceSchema).toData(derivedPythPrice);
+}
+
+const PythFeedParamsSchema = TSchema.Struct({
+  config: DerivedPythPriceSchema,
+  pythStatePolicyId: TSchema.ByteArray,
+});
+
+export type PythFeedParams = typeof PythFeedParamsSchema.Type;
+
+export function serialisePythFeedParams(params: PythFeedParams): Data.Data {
+  return Data.withSchema(PythFeedParamsSchema).toData(params);
+}
+
+const PythFeedRedeemerSchema = TSchema.Struct(
+  {
+    price: RationalSchema,
+    auxiliaryData: OpaqueData,
+  },
+  { flatInUnion: true },
+);
+export type PythFeedRedeemer = typeof PythFeedRedeemerSchema.Type;
+
+export function serialisePythFeedRedeemer(r: PythFeedRedeemer): string {
+  return Data.withSchema(
+    PythFeedRedeemerSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}
+
+/**
+ * IntervalBoundType
+ * A type of interval bound. The value for the `Finite` case typically
+ represents a number of seconds or milliseconds.
+ */
+export const AikenIntervalIntervalBoundType = TSchema.Union(
+  TSchema.TaggedStruct('NegativeInfinity', {}, { flatInUnion: true }),
+  TSchema.TaggedStruct(
+    'Finite',
+    { finite: TSchema.Integer },
+    { flatInUnion: true },
+  ),
+  TSchema.TaggedStruct('PositiveInfinity', {}, { flatInUnion: true }),
+);
+
+/**
+ * IntervalBound
+ * An interval bound, either inclusive or exclusive.
+ */
+export const AikenIntervalIntervalBound = TSchema.Struct({
+  bound_type: AikenIntervalIntervalBoundType,
+  is_inclusive: TSchema.Boolean,
+});
+
+/**
+ * ValidityRange
+ * A type to represent intervals of values. Interval are inhabited by an
+ integer value representing  have a finite lower-bound and/or upper-bound.
+ This allows to represent all kind of mathematical intervals:
+ ```aiken
+ // [1; 10]
+ let i0: Interval = Interval
+   { lower_bound:
+       IntervalBound { bound_type: Finite(1), is_inclusive: True }
+   , upper_bound:
+       IntervalBound { bound_type: Finite(10), is_inclusive: True }
+   }
+ ```
+ ```aiken
+ // (20; infinity)
+ let i1: Interval = Interval
+   { lower_bound:
+       IntervalBound { bound_type: Finite(20), is_inclusive: False }
+   , upper_bound:
+       IntervalBound { bound_type: PositiveInfinity, is_inclusive: False }
+   }
+ ```
+ */
+export const CardanoTransactionValidityRange = TSchema.Struct({
+  lower_bound: AikenIntervalIntervalBound,
+  upper_bound: AikenIntervalIntervalBound,
+});
+
+const PythStateDatumSchema = TSchema.Struct(
+  {
+    governance: TSchema.Struct(
+      {
+        wormhole: TSchema.ByteArray,
+        emitterChain: TSchema.Integer,
+        emitterAddress: TSchema.ByteArray,
+        seenSequence: TSchema.Integer,
+      },
+      { flatInUnion: true },
+    ),
+    trustedSigners: TSchema.Map(
+      TSchema.ByteArray,
+      CardanoTransactionValidityRange,
+    ),
+    deprecatedWithdrawScripts: TSchema.Map(
+      CardanoTransactionValidityRange,
+      TSchema.ByteArray,
+    ),
+    withdraw_script: TSchema.ByteArray,
+  },
+  { flatInUnion: true },
+);
+export type PythStateDatum = typeof PythStateDatumSchema.Type;
+
+export function serialisePythStateDatum(r: PythStateDatum): string {
+  return Data.withSchema(
+    PythStateDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}
+
+export function parsePythStateDatum(datum: string): PythStateDatum {
+  return Data.withSchema(
+    PythStateDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).fromCBORHex(datum);
+}
+
+const PythUpdatesRedeemerSchema = TSchema.Array(TSchema.ByteArray);
+export type PythUpdatesRedeemer = typeof PythUpdatesRedeemerSchema.Type;
+
+export function serialisePythUpdatesRedeemer(r: PythUpdatesRedeemer): string {
+  return Data.withSchema(
+    PythUpdatesRedeemerSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}