@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/utils/oracle-helpers.ts

@@ -0,0 +1,62 @@
+import { match, P } from 'ts-pattern';
+import { IAssetPriceInfo } from '../contracts/iasset/types';
+import { Rational } from '../types/rational';
+import { LucidEvolution, OutRef, UTxO } from '@lucid-evolution/lucid';
+import { adjustPriceToDecimals } from '../contracts/cdp/helpers';
+import {
+  AssetClass,
+  getInlineDatumOrThrow,
+  matchSingle,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { parsePriceOracleDatum } from '../contracts/price-oracle/types-new';
+import { derivePythPrice } from '../contracts/pyth-feed/helpers';
+import {
+  fromSysParamsDerivedPythPrice,
+  getPythFeedConfig,
+  PythConfig,
+} from '../types/system-params';
+
+export async function retrieveAdjustedPrice(
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+  priceInfo: IAssetPriceInfo,
+  extraDecimals: bigint,
+  priceOracleOref: OutRef | undefined,
+  pythMessage: string | undefined,
+  pythConfig: PythConfig,
+  lucid: LucidEvolution,
+): Promise<[Rational, UTxO | undefined]> {
+  const [oraclePrice, maybePriceOracleUtxo] = await match(priceInfo)
+    .with({ OracleNft: P.any }, async () => {
+      if (!priceOracleOref) throw new Error('Missing price oracle');
+      const priceOracleUtxo = matchSingle(
+        await lucid.utxosByOutRef([priceOracleOref]),
+        (_) => new Error('Expected a single price oracle UTXO'),
+      );
+      const priceOracleDatum = parsePriceOracleDatum(
+        getInlineDatumOrThrow(priceOracleUtxo),
+      );
+      return [priceOracleDatum.price, priceOracleUtxo];
+    })
+    .with({ Delisted: P.select() }, (price) => [price.price, undefined])
+    .with({ DeferredValidation: P.select() }, () => {
+      if (!pythMessage) throw new Error('Missing Pyth message');
+
+      return [
+        derivePythPrice(
+          fromSysParamsDerivedPythPrice(
+            getPythFeedConfig(pythConfig, iasset, collateralAsset).params
+              .config,
+          ),
+          pythMessage,
+        ),
+        undefined,
+      ];
+    })
+    .exhaustive();
+
+  return [
+    adjustPriceToDecimals(extraDecimals, oraclePrice as Rational),
+    maybePriceOracleUtxo as UTxO | undefined,
+  ];
+}

package/src/utils/pyth/decode.ts

@@ -0,0 +1,223 @@
+import type { PriceUpdate, PythMessageParts } from './types.js';
+import type { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
+import {
+  MARKET_SESSION_ORDER,
+  PRICE_UPDATE_MAGIC,
+  PROP_ID,
+  SOLANA_FORMAT_MAGIC,
+} from './types.js';
+
+function expectMagic(
+  buf: Uint8Array,
+  offset: number,
+  magic: Uint8Array,
+  label: string,
+): void {
+  for (let i = 0; i < magic.length; i++) {
+    if (buf[offset + i] !== magic[i]) {
+      throw new Error(`Invalid ${label} magic byte at ${i}`);
+    }
+  }
+}
+
+function bigintToSdkNumber(v: bigint): number {
+  if (
+    v > BigInt(Number.MAX_SAFE_INTEGER) ||
+    v < BigInt(Number.MIN_SAFE_INTEGER)
+  ) {
+    throw new RangeError('Scalar does not fit in a safe integer');
+  }
+  return Number(v);
+}
+
+function decodeFeedPayload(
+  buf: Uint8Array,
+  view: DataView,
+  start: number,
+): { feed: ParsedFeedPayload; next: number } {
+  let o = start;
+  if (o + 5 > buf.length) throw new RangeError('Truncated feed header');
+  const priceFeedId = view.getUint32(o, true);
+  o += 4;
+  const nProps = buf[o];
+  o += 1;
+  const feed: ParsedFeedPayload = { priceFeedId };
+  for (let i = 0; i < nProps; i++) {
+    if (o >= buf.length) throw new RangeError('Truncated feed property header');
+    const propId = buf[o];
+    o += 1;
+    switch (propId) {
+      case PROP_ID.Price: {
+        const v = view.getBigInt64(o, true);
+        o += 8;
+        if (v !== 0n) feed.price = v.toString();
+        break;
+      }
+      case PROP_ID.BestBidPrice: {
+        const v = view.getBigInt64(o, true);
+        o += 8;
+        if (v !== 0n) feed.bestBidPrice = v.toString();
+        break;
+      }
+      case PROP_ID.BestAskPrice: {
+        const v = view.getBigInt64(o, true);
+        o += 8;
+        if (v !== 0n) feed.bestAskPrice = v.toString();
+        break;
+      }
+      case PROP_ID.PublisherCount: {
+        feed.publisherCount = view.getUint16(o, true);
+        o += 2;
+        break;
+      }
+      case PROP_ID.Exponent: {
+        feed.exponent = view.getInt16(o, true);
+        o += 2;
+        break;
+      }
+      case PROP_ID.Confidence: {
+        const v = view.getBigInt64(o, true);
+        o += 8;
+        if (v !== 0n) feed.confidence = bigintToSdkNumber(v);
+        break;
+      }
+      case PROP_ID.FundingRate: {
+        const tag = buf[o];
+        o += 1;
+        if (tag === 1) {
+          const v = view.getBigInt64(o, true);
+          o += 8;
+          feed.fundingRate = bigintToSdkNumber(v);
+        } else if (tag !== 0) {
+          throw new RangeError('Invalid FundingRate option tag');
+        }
+        break;
+      }
+      case PROP_ID.FundingTimestamp: {
+        const tag = buf[o];
+        o += 1;
+        if (tag === 1) {
+          const v = view.getBigUint64(o, true);
+          o += 8;
+          feed.fundingTimestamp = bigintToSdkNumber(v);
+        } else if (tag !== 0) {
+          throw new RangeError('Invalid FundingTimestamp option tag');
+        }
+        break;
+      }
+      case PROP_ID.FundingRateInterval: {
+        const tag = buf[o];
+        o += 1;
+        if (tag === 1) {
+          const v = view.getBigUint64(o, true);
+          o += 8;
+          feed.fundingRateInterval = bigintToSdkNumber(v);
+        } else if (tag !== 0) {
+          throw new RangeError('Invalid FundingRateInterval option tag');
+        }
+        break;
+      }
+      case PROP_ID.MarketSession: {
+        const idx = view.getUint16(o, true);
+        o += 2;
+        const session = MARKET_SESSION_ORDER[idx];
+        if (!session) throw new RangeError('Invalid marketSession index');
+        feed.marketSession = session;
+        break;
+      }
+      case PROP_ID.EmaPrice: {
+        const v = view.getBigInt64(o, true);
+        o += 8;
+        if (v !== 0n) feed.emaPrice = v.toString();
+        break;
+      }
+      case PROP_ID.EmaConfidence: {
+        const v = view.getBigInt64(o, true);
+        o += 8;
+        if (v !== 0n) feed.emaConfidence = bigintToSdkNumber(v);
+        break;
+      }
+      case PROP_ID.FeedUpdateTimestamp: {
+        const tag = buf[o];
+        o += 1;
+        if (tag === 1) {
+          const v = view.getBigUint64(o, true);
+          o += 8;
+          feed.feedUpdateTimestamp = bigintToSdkNumber(v);
+        } else if (tag !== 0) {
+          throw new RangeError('Invalid FeedUpdateTimestamp option tag');
+        }
+        break;
+      }
+      default:
+        throw new RangeError(`Unknown feed property id: ${propId}`);
+    }
+  }
+  return { feed, next: o };
+}
+
+/**
+ * Decode a PriceUpdate payload produced by {@link encodePriceUpdate}.
+ */
+export function decodePriceUpdate(payload: Uint8Array): PriceUpdate {
+  const min = 4 + 8 + 1 + 1;
+  if (payload.length < min) {
+    throw new RangeError('Price update payload too short');
+  }
+  expectMagic(payload, 0, PRICE_UPDATE_MAGIC, 'price update');
+  const view = new DataView(
+    payload.buffer,
+    payload.byteOffset,
+    payload.byteLength,
+  );
+  let o = 4;
+  const timestampUs = view.getBigUint64(o, true);
+  o += 8;
+  const channelId = payload[o];
+  o += 1;
+  const feedsLen = payload[o];
+  o += 1;
+  const priceFeeds: ParsedFeedPayload[] = [];
+  for (let f = 0; f < feedsLen; f++) {
+    const decoded = decodeFeedPayload(payload, view, o);
+    priceFeeds.push(decoded.feed);
+    o = decoded.next;
+  }
+  if (o !== payload.length) {
+    throw new RangeError('Trailing bytes in price update payload');
+  }
+  return {
+    timestampUs: timestampUs.toString(),
+    channelId,
+    priceFeeds,
+  };
+}
+
+const PYTH_MESSAGE_HEADER_LEN = 4 + 64 + 32 + 2;
+
+/**
+ * Decode a Solana-format Pyth message produced by {@link encodePythMessage}.
+ */
+export function decodePythMessage(message: Uint8Array): PythMessageParts {
+  if (message.length < PYTH_MESSAGE_HEADER_LEN) {
+    throw new RangeError('Pyth message too short');
+  }
+  expectMagic(message, 0, SOLANA_FORMAT_MAGIC, 'Solana format');
+  const view = new DataView(
+    message.buffer,
+    message.byteOffset,
+    message.byteLength,
+  );
+  const payloadLen = view.getUint16(100, true);
+  const total = PYTH_MESSAGE_HEADER_LEN + payloadLen;
+  if (message.length !== total) {
+    throw new RangeError(
+      `Pyth message length mismatch: expected ${total} bytes, got ${message.length}`,
+    );
+  }
+  return {
+    signature: message.subarray(4, 68).slice(),
+    publicKey: message.subarray(68, 100).slice(),
+    payload: message.subarray(102, total).slice(),
+  };
+}

package/src/utils/pyth/encode.ts

@@ -0,0 +1,262 @@
+import type {
+  Feed,
+  MarketSession,
+  PriceUpdate,
+  PythMessageParts,
+} from './types.js';
+import type { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
+import {
+  MARKET_SESSION_ORDER,
+  PRICE_UPDATE_MAGIC,
+  PROP_ID,
+  SOLANA_FORMAT_MAGIC,
+} from './types.js';
+
+export { PRICE_UPDATE_MAGIC, SOLANA_FORMAT_MAGIC } from './types.js';
+
+function u8(b: number): Uint8Array {
+  if (b < 0 || b > 255) throw new RangeError('u8 out of range');
+  return new Uint8Array([b & 0xff]);
+}
+
+function u16Le(n: number): Uint8Array {
+  if (n < 0 || n > 0xffff) throw new RangeError('u16 out of range');
+  const buf = new Uint8Array(2);
+  new DataView(buf.buffer).setUint16(0, n, true);
+  return buf;
+}
+
+function u32Le(n: number): Uint8Array {
+  if (n < 0 || n > 0xffff_ffff) throw new RangeError('u32 out of range');
+  const buf = new Uint8Array(4);
+  new DataView(buf.buffer).setUint32(0, n, true);
+  return buf;
+}
+
+function u64Le(n: bigint): Uint8Array {
+  const buf = new Uint8Array(8);
+  const view = new DataView(buf.buffer);
+  const lo = Number(n & 0xffff_ffff_ffff_ffffn);
+  const hi = Number((n >> 32n) & 0xffff_ffffn);
+  view.setUint32(0, lo & 0xffff_ffff, true);
+  view.setUint32(4, hi, true);
+  return buf;
+}
+
+function i16Le(n: number): Uint8Array {
+  const buf = new Uint8Array(2);
+  new DataView(buf.buffer).setInt16(0, n, true);
+  return buf;
+}
+
+function i64Le(n: bigint): Uint8Array {
+  const buf = new Uint8Array(8);
+  const view = new DataView(buf.buffer);
+  const lo = Number(n & 0xffff_ffff_ffff_ffffn);
+  const hi = Number(Number(n >> 32n) & 0xffff_ffff);
+  view.setUint32(0, lo & 0xffff_ffff, true);
+  view.setUint32(4, hi, true);
+  return buf;
+}
+
+function concat(...chunks: Uint8Array[]): Uint8Array {
+  const total = chunks.reduce((s, c) => s + c.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+
+/** Encode a single feed property (property_id byte + value bytes). */
+function encodeFeedProperty(id: number, value: Uint8Array): Uint8Array {
+  return concat(u8(id), value);
+}
+
+function toFeed(parsed: ParsedFeedPayload): Feed {
+  const toBigInt = (v: string | number | undefined): bigint | null =>
+    v === undefined ? null : BigInt(v);
+
+  const toBigIntOptional = (v: string | number | undefined): bigint | null =>
+    v === undefined ? null : BigInt(v);
+
+  return {
+    feedId: parsed.priceFeedId,
+    price: parsed.price === undefined ? null : BigInt(parsed.price),
+    bestBidPrice: toBigIntOptional(parsed.bestBidPrice),
+    bestAskPrice: toBigIntOptional(parsed.bestAskPrice),
+    publisherCount: parsed.publisherCount ?? 0,
+    exponent: parsed.exponent ?? 0,
+    confidence: toBigInt(parsed.confidence),
+    fundingRate: toBigInt(parsed.fundingRate),
+    fundingTimestamp: toBigInt(parsed.fundingTimestamp),
+    fundingRateInterval: toBigInt(parsed.fundingRateInterval),
+    marketSession: (parsed.marketSession as MarketSession) ?? 'Regular',
+    emaPrice: toBigIntOptional(parsed.emaPrice),
+    emaConfidence: toBigInt(parsed.emaConfidence),
+    feedUpdateTimestamp: toBigInt(parsed.feedUpdateTimestamp),
+  };
+}
+
+/** Encode feed properties that are defined, in the order expected by the parser. */
+function encodeFeed(feed: Feed): Uint8Array {
+  const parts: Uint8Array[] = [];
+
+  if (feed.price !== undefined) {
+    const v = feed.price === null ? 0n : feed.price;
+    parts.push(encodeFeedProperty(PROP_ID.Price, i64Le(v)));
+  }
+  if (feed.bestBidPrice !== undefined) {
+    const v = feed.bestBidPrice === null ? 0n : feed.bestBidPrice;
+    parts.push(encodeFeedProperty(PROP_ID.BestBidPrice, i64Le(v)));
+  }
+  if (feed.bestAskPrice !== undefined) {
+    const v = feed.bestAskPrice === null ? 0n : feed.bestAskPrice;
+    parts.push(encodeFeedProperty(PROP_ID.BestAskPrice, i64Le(v)));
+  }
+  if (feed.publisherCount !== undefined) {
+    parts.push(
+      encodeFeedProperty(PROP_ID.PublisherCount, u16Le(feed.publisherCount)),
+    );
+  }
+  if (feed.exponent !== undefined) {
+    parts.push(encodeFeedProperty(PROP_ID.Exponent, i16Le(feed.exponent)));
+  }
+  if (feed.confidence !== undefined) {
+    const v = feed.confidence === null ? 0n : feed.confidence;
+    parts.push(encodeFeedProperty(PROP_ID.Confidence, i64Le(v)));
+  }
+  if (feed.fundingRate !== undefined) {
+    if (feed.fundingRate === null) {
+      parts.push(encodeFeedProperty(PROP_ID.FundingRate, u8(0)));
+    } else {
+      parts.push(
+        encodeFeedProperty(
+          PROP_ID.FundingRate,
+          concat(u8(1), i64Le(feed.fundingRate)),
+        ),
+      );
+    }
+  }
+  if (feed.fundingTimestamp !== undefined) {
+    if (feed.fundingTimestamp === null) {
+      parts.push(encodeFeedProperty(PROP_ID.FundingTimestamp, u8(0)));
+    } else {
+      parts.push(
+        encodeFeedProperty(
+          PROP_ID.FundingTimestamp,
+          concat(u8(1), u64Le(feed.fundingTimestamp)),
+        ),
+      );
+    }
+  }
+  if (feed.fundingRateInterval !== undefined) {
+    if (feed.fundingRateInterval === null) {
+      parts.push(encodeFeedProperty(PROP_ID.FundingRateInterval, u8(0)));
+    } else {
+      parts.push(
+        encodeFeedProperty(
+          PROP_ID.FundingRateInterval,
+          concat(u8(1), u64Le(feed.fundingRateInterval)),
+        ),
+      );
+    }
+  }
+  if (feed.marketSession !== undefined) {
+    const idx = MARKET_SESSION_ORDER.indexOf(feed.marketSession);
+    if (idx < 0) throw new RangeError('Invalid marketSession');
+    parts.push(encodeFeedProperty(PROP_ID.MarketSession, u16Le(idx)));
+  }
+  if (feed.emaPrice !== undefined) {
+    const v = feed.emaPrice === null ? 0n : feed.emaPrice;
+    parts.push(encodeFeedProperty(PROP_ID.EmaPrice, i64Le(v)));
+  }
+  if (feed.emaConfidence !== undefined) {
+    const v = feed.emaConfidence === null ? 0n : feed.emaConfidence;
+    parts.push(encodeFeedProperty(PROP_ID.EmaConfidence, i64Le(v)));
+  }
+  if (feed.feedUpdateTimestamp !== undefined) {
+    if (feed.feedUpdateTimestamp === null) {
+      parts.push(encodeFeedProperty(PROP_ID.FeedUpdateTimestamp, u8(0)));
+    } else {
+      parts.push(
+        encodeFeedProperty(
+          PROP_ID.FeedUpdateTimestamp,
+          concat(u8(1), u64Le(feed.feedUpdateTimestamp)),
+        ),
+      );
+    }
+  }
+
+  const properties = concat(...parts);
+  if (parts.length > 255)
+    throw new RangeError('Feed has more than 255 properties');
+  return concat(
+    u32Le(feed.feedId),
+    u8(parts.length), // number of properties (parser.repeat count), not byte length
+    properties,
+  );
+}
+
+/**
+ * Encode a PriceUpdate to the binary payload format consumed by the on-chain parser.
+ * This is the payload that goes inside a PythMessage.
+ */
+export function encodePriceUpdate(update: PriceUpdate): Uint8Array {
+  if (update.priceFeeds.length > 255) {
+    throw new RangeError('At most 255 feeds allowed');
+  }
+  const feeds: Feed[] = update.priceFeeds.map(toFeed);
+  const feedBytes = feeds.map(encodeFeed);
+  return concat(
+    PRICE_UPDATE_MAGIC,
+    u64Le(BigInt(update.timestampUs)),
+    u8(update.channelId),
+    u8(feeds.length),
+    ...feedBytes,
+  );
+}
+
+/**
+ * Encode a full Pyth message (Solana format): magic + signature + key + payload length + payload.
+ * Use this when you already have a signed payload (e.g. from a Pyth API or after signing locally).
+ */
+export function encodePythMessage(parts: PythMessageParts): Uint8Array {
+  if (parts.signature.length !== 64) {
+    throw new RangeError('signature must be 64 bytes');
+  }
+  if (parts.publicKey.length !== 32) {
+    throw new RangeError('publicKey must be 32 bytes');
+  }
+  if (parts.payload.length > 0xffff) {
+    throw new RangeError('payload length exceeds u16 max');
+  }
+  return concat(
+    SOLANA_FORMAT_MAGIC,
+    parts.signature,
+    parts.publicKey,
+    u16Le(parts.payload.length),
+    parts.payload,
+  );
+}
+
+/**
+ * Encode a PythMessage whose payload is a PriceUpdate.
+ * Signs the payload with the given secret key (32-byte Ed25519 seed).
+ * Returns the full message bytes (hex-friendly).
+ */
+export async function encodeSignedPythMessage(
+  update: PriceUpdate,
+  secretKey: Uint8Array,
+): Promise<Uint8Array> {
+  if (secretKey.length !== 32) {
+    throw new RangeError('secretKey must be 32 bytes (Ed25519 seed)');
+  }
+  const noble = await import('@noble/ed25519');
+  const payload = encodePriceUpdate(update);
+  const publicKey = await noble.getPublicKeyAsync(secretKey);
+  const signature = await noble.signAsync(payload, secretKey);
+  return encodePythMessage({ signature, publicKey, payload });
+}

package/src/utils/pyth/index.ts

@@ -0,0 +1,14 @@
+export type {
+  Feed,
+  MarketSession,
+  PriceUpdate,
+  PythMessageParts,
+} from './types.js';
+export { decodePriceUpdate, decodePythMessage } from './decode.js';
+export {
+  encodePriceUpdate,
+  encodePythMessage,
+  encodeSignedPythMessage,
+  PRICE_UPDATE_MAGIC,
+  SOLANA_FORMAT_MAGIC,
+} from './encode.js';

package/src/utils/pyth/types.ts

@@ -0,0 +1,87 @@
+import type { ParsedPayload } from '@pythnetwork/pyth-lazer-sdk';
+
+/**
+ * Types mirroring the Aiken Pyth parser (lib/pyth).
+ * Use bigint for values that may exceed Number safe integer (2^53 - 1).
+ */
+
+export type MarketSession =
+  | 'Regular'
+  | 'PreMarket'
+  | 'PostMarket'
+  | 'OverNight'
+  | 'Closed';
+
+/** Price-update payload magic (4 bytes). Must match Aiken price_update_magic_le. */
+export const PRICE_UPDATE_MAGIC = new Uint8Array([0x75, 0xd3, 0xc7, 0x93]);
+/** Pyth message (Solana format) magic (4 bytes). Must match Aiken solana_format_magic_le. */
+export const SOLANA_FORMAT_MAGIC = new Uint8Array([0xb9, 0x01, 0x1a, 0x82]);
+
+// Property IDs (must match lib/pyth/pyth.ak feed_property)
+export const PROP_ID = {
+  Price: 0,
+  BestBidPrice: 1,
+  BestAskPrice: 2,
+  PublisherCount: 3,
+  Exponent: 4,
+  Confidence: 5,
+  FundingRate: 6,
+  FundingTimestamp: 7,
+  FundingRateInterval: 8,
+  MarketSession: 9,
+  EmaPrice: 10,
+  EmaConfidence: 11,
+  FeedUpdateTimestamp: 12,
+} as const;
+
+export const MARKET_SESSION_ORDER: MarketSession[] = [
+  'Regular',
+  'PreMarket',
+  'PostMarket',
+  'OverNight',
+  'Closed',
+];
+
+/**
+ * Optional<T> = undefined (property not present) | null (explicit None) | T (value)
+ * Matches Aiken Option<Option<T>> for feed properties.
+ */
+export interface Feed {
+  feedId: number; // u32
+  price?: bigint | null; // 0 encodes as None
+  bestBidPrice?: bigint | null;
+  bestAskPrice?: bigint | null;
+  publisherCount?: number; // u16
+  exponent?: number; // i16
+  confidence?: bigint | null;
+  fundingRate?: bigint | null;
+  fundingTimestamp?: bigint | null; // u64
+  fundingRateInterval?: bigint | null; // u64
+  marketSession?: MarketSession;
+  emaPrice?: bigint | null;
+  emaConfidence?: bigint | null;
+  feedUpdateTimestamp?: bigint | null; // u64
+}
+
+/**
+ * Price update payload based on the ParsedPayload returned by pyth-lazer-sdk,
+ * extended with the channel id used by the on-chain parser.
+ */
+export interface PriceUpdate extends ParsedPayload {
+  /** Channel id (u8) */
+  channelId: number;
+}
+
+/**
+ * Components of a Pyth message (Solana format).
+ * To produce a valid on-chain message, payload should be a PriceUpdate payload
+ * and signature must be Ed25519 over payload with the given public key.
+ */
+export interface PythMessageParts {
+  /** Ed25519 signature (64 bytes) */
+  signature: Uint8Array;
+  /** Ed25519 public key (32 bytes) */
+  publicKey: Uint8Array;
+  /** Payload bytes (e.g. encoded PriceUpdate) */
+  payload: Uint8Array;
+}

package/src/validators/always-succeed-validator.ts

@@ -0,0 +1,6 @@
+// Automatically generated by the sdk-export.sh script in aiken smart contracts repository
+export const _alwaysSucceedValidator = {
+  type: 'PlutusScriptV3',
+  description: 'Generated by Aiken',
+  cborHex: '525101010023259800a518a4d136564004ae69',
+};