@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/src/contracts/poll/types-poll-new.ts

@@ -1,196 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import {
-  ProposalContentSchema,
-  TreasuryWithdrawalSchema,
-} from '../gov/types-new';
-import {
-  AddressSchema,
-  OutputReferenceSchema,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { option as O, function as F } from 'fp-ts';
-import { match, P } from 'ts-pattern';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-const PollStatusSchema = TSchema.Struct({
-  yesVotes: TSchema.Integer,
-  noVotes: TSchema.Integer,
-});
-
-export type PollStatus = typeof PollStatusSchema.Type;
-
-const PollManagerContentSchema = TSchema.Struct({
-  pollId: TSchema.Integer,
-  pollOwner: TSchema.ByteArray,
-  content: ProposalContentSchema,
-  treasuryWithdrawal: TSchema.NullOr(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: TSchema.Integer,
-  createdShardsCount: TSchema.Integer,
-  talliedShardsCount: TSchema.Integer,
-  totalShardsCount: TSchema.Integer,
-  proposingEndTime: TSchema.Integer,
-  expirationTime: TSchema.Integer,
-  protocolVersion: TSchema.Integer,
-  minimumQuorum: TSchema.Integer,
-});
-
-export type PollManagerContent = typeof PollManagerContentSchema.Type;
-
-const PollShardContentSchema = TSchema.Struct({
-  pollId: TSchema.Integer,
-  status: PollStatusSchema,
-  votingEndTime: TSchema.Integer,
-  managerAddress: AddressSchema,
-});
-
-export type PollShardContent = typeof PollShardContentSchema.Type;
-
-const PollDatumSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      PollManager: PollManagerContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true }),
-);
-
-export type PollDatum = typeof PollDatumSchema.Type;
-
-const VoteOptionSchema = TSchema.Union(
-  TSchema.Literal('Yes', { flatInUnion: true }),
-  TSchema.Literal('No', { flatInUnion: true }),
-);
-export type VoteOption = typeof VoteOptionSchema.Type;
-
-const PollShardRedeemerSchema = TSchema.Union(
-  TSchema.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      MergeShards: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-          pollManagerRef: OutputReferenceSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-);
-export type PollShardRedeemer = typeof PollShardRedeemerSchema.Type;
-
-const PollManagerRedeemerSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      EndPoll: TSchema.Struct(
-        { currentTime: TSchema.Integer },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      CreateShards: TSchema.Struct(
-        { currentTime: TSchema.Integer },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      MergeShardsManager: TSchema.Struct(
-        { currentTime: TSchema.Integer },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-);
-export type PollManagerRedeemer = typeof PollManagerRedeemerSchema.Type;
-
-export function serialisePollManagerRedeemer(r: PollManagerRedeemer): string {
-  return Data.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
-}
-
-export function serialisePollShardRedeemer(r: PollShardRedeemer): string {
-  return Data.withSchema(PollShardRedeemerSchema).toCBORHex(r);
-}
-
-export function parsePollShardRedeemer(
-  datum: string,
-): O.Option<PollShardRedeemer> {
-  try {
-    return O.some(
-      Data.withSchema(
-        PollShardRedeemerSchema,
-        DEFAULT_SCHEMA_OPTIONS,
-      ).fromCBORHex(datum),
-    );
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollShardRedeemerOrThrow(
-  datum: string,
-): PollShardRedeemer {
-  return F.pipe(
-    parsePollShardRedeemer(datum),
-    O.match(() => {
-      throw new Error('Expected a poll shard redeemer.');
-    }, F.identity),
-  );
-}
-
-export function parsePollManager(datum: string): O.Option<PollManagerContent> {
-  try {
-    return match(
-      Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    )
-      .with({ PollManager: P.select() }, (res) => O.some(res))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollManagerOrThrow(datum: string): PollManagerContent {
-  return F.pipe(
-    parsePollManager(datum),
-    O.match(() => {
-      throw new Error('Expected a poll manager datum.');
-    }, F.identity),
-  );
-}
-
-export function parsePollShard(datum: string): O.Option<PollShardContent> {
-  try {
-    return match(
-      Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    )
-      .with({ PollShard: P.select() }, (res) => O.some(res))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollShardOrThrow(datum: string): PollShardContent {
-  return F.pipe(
-    parsePollShard(datum),
-    O.match(() => {
-      throw new Error('Expected a poll shard datum.');
-    }, F.identity),
-  );
-}
-
-export function serialisePollDatum(d: PollDatum): string {
-  return Data.withSchema(PollDatumSchema).toCBORHex(d);
-}

package/src/contracts/poll/types-poll-shard.ts

@@ -1,16 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const PollShardParamsSchema = Data.Object({
-  pollToken: AssetClassSchema,
-  stakingToken: AssetClassSchema,
-  indyAsset: AssetClassSchema,
-  stakingValHash: Data.Bytes(),
-});
-export type PollShardParams = Data.Static<typeof PollShardParamsSchema>;
-export const PollShardParams =
-  PollShardParamsSchema as unknown as PollShardParams;
-
-export function castPollShardParams(params: PollShardParams): Data {
-  return Data.castTo(params, PollShardParams);
-}

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

@@ -1,30 +0,0 @@
-import { LucidEvolution } from '@lucid-evolution/lucid';
-
-/**
- * Calculates the validity range based on the oracle expiration,
- * and caps the upper bound when necessary.
- */
-export function oracleExpirationAwareValidity(
-  lucid: LucidEvolution,
-  biasTime: number,
-  oracleExpiration: number,
-): {
-  validFrom: number;
-  validTo: number;
-} {
-  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-  const defaultValidateTo = validateFrom + biasTime;
-  /// Take the oracle expiration time - 1 slot which is the last acceptable non-expired valid_to time
-  /// for the current oracle.
-  const cappedValidateTo = lucid.slotToUnixTime(
-    lucid.unixTimeToSlot(oracleExpiration) - 1,
-  );
-  const isOracleActuallyExpired = cappedValidateTo <= validateFrom;
-
-  return {
-    validFrom: validateFrom,
-    validTo: isOracleActuallyExpired
-      ? defaultValidateTo
-      : Math.min(defaultValidateTo, cappedValidateTo),
-  };
-}

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

@@ -1,18 +0,0 @@
-import {
-  applyParamsToScript,
-  ScriptType,
-  SpendingValidator,
-} from '@lucid-evolution/lucid';
-import { castPriceOracleParams, PriceOracleParams } from './types';
-import { _priceOracleValidator } from '../../validators/price-oracle-validator';
-
-export function mkPriceOracleValidator(
-  params: PriceOracleParams,
-): SpendingValidator {
-  return {
-    type: 'PlutusV3' as ScriptType,
-    script: applyParamsToScript(_priceOracleValidator.cborHex, [
-      castPriceOracleParams(params),
-    ]),
-  };
-}

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

@@ -1,115 +0,0 @@
-import {
-  addAssets,
-  Data,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  OutRef,
-  TxBuilder,
-  validatorToAddress,
-} from '@lucid-evolution/lucid';
-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 {
-  PriceOracleDatum,
-  serialisePriceOracleDatum,
-  serialisePriceOracleRedeemer,
-} from './types-new';
-import * as Core from '@evolution-sdk/evolution';
-import { Rational } from '../../types/rational';
-
-export async function startPriceOracleTx(
-  lucid: LucidEvolution,
-  assetName: string,
-  startPrice: Rational,
-  oracleParams: PriceOracleParams,
-  refOutRef?: OutRef,
-  auxiliaryData?: Core.Data.Data,
-): Promise<[TxBuilder, AssetClass]> {
-  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  if (!refOutRef) {
-    refOutRef = (await lucid.wallet().getUtxos())[0];
-  }
-
-  const [tx, oracleNftPolicyId] = await oneShotMintTx(lucid, {
-    referenceOutRef: {
-      txHash: refOutRef.txHash,
-      outputIdx: BigInt(refOutRef.outputIndex),
-    },
-    mintAmounts: [
-      {
-        tokenName: fromText(assetName),
-        amount: 1n,
-      },
-    ],
-  });
-
-  const priceOracleNft: AssetClass = {
-    currencySymbol: fromHex(oracleNftPolicyId),
-    tokenName: fromHex(fromText(assetName)),
-  };
-
-  const oracleValidator = mkPriceOracleValidator(oracleParams);
-
-  const oracleDatum: PriceOracleDatum = {
-    price: startPrice,
-    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(mkAssetsOf(priceOracleNft, 1n)),
-  );
-
-  return [tx, priceOracleNft];
-}
-
-export async function feedPriceOracleTx(
-  lucid: LucidEvolution,
-  oracleOref: OutRef,
-  newPrice: Rational,
-  oracleParams: PriceOracleParams,
-  auxiliaryData?: Core.Data.Data,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([oracleOref]),
-    (_) => new Error('Expected a single price oracle UTXO'),
-  );
-
-  const oracleValidator = mkPriceOracleValidator(oracleParams);
-
-  return lucid
-    .newTx()
-    .validFrom(Number(currentTime - oracleParams.biasTime) + ONE_SECOND)
-    .validTo(Number(currentTime + oracleParams.biasTime) - ONE_SECOND)
-    .attach.SpendingValidator(oracleValidator)
-    .collectFrom(
-      [priceOracleUtxo],
-      serialisePriceOracleRedeemer({
-        currentTime: currentTime,
-        newPrice: newPrice,
-      }),
-    )
-    .pay.ToContract(
-      priceOracleUtxo.address,
-      {
-        kind: 'inline',
-        value: serialisePriceOracleDatum({
-          price: newPrice,
-          expirationTime: currentTime + oracleParams.expirationPeriod,
-          auxiliaryData: auxiliaryData ?? Core.Data.fromCBORHex(Data.void()),
-        }),
-      },
-      priceOracleUtxo.assets,
-    )
-    .addSignerKey(oracleParams.owner);
-}

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

@@ -1,50 +0,0 @@
-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.Type;
-
-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,16 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-
-export const PriceOracleParamsSchema = Data.Object({
-  owner: Data.Bytes(),
-  /**  Milliseconds */
-  biasTime: Data.Integer(),
-  /**  Milliseconds */
-  expirationPeriod: Data.Integer(),
-});
-export type PriceOracleParams = Data.Static<typeof PriceOracleParamsSchema>;
-const PriceOracleParams =
-  PriceOracleParamsSchema as unknown as PriceOracleParams;
-
-export function castPriceOracleParams(params: PriceOracleParams): Data {
-  return Data.castTo(params, PriceOracleParams);
-}

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

@@ -1,82 +0,0 @@
-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';
-import { array as A, function as F } from 'fp-ts';
-import { BigIntOrd } from '../../utils/bigint-utils';
-
-/**
- * Collect all unique price feed IDs in the derived price sorted ascending.
- */
-export function collectPriceFeedIds(
-  derivedPythPrice: DerivedPythPrice,
-): bigint[] {
-  const ids = match(derivedPythPrice)
-    .with({ Value: P.select() }, (value) => [
-      BigInt(value.configuration.priceFeedId),
-    ])
-    .with({ Inverse: P.select() }, (inverse) =>
-      collectPriceFeedIds(fromDataDerivedPythPrice(inverse.value)),
-    )
-    .with({ Divide: P.select() }, (divide) => [
-      ...collectPriceFeedIds(fromDataDerivedPythPrice(divide.x)),
-      ...collectPriceFeedIds(fromDataDerivedPythPrice(divide.y)),
-    ])
-    .exhaustive();
-
-  return F.pipe(ids, A.uniq(BigIntOrd), A.sort(BigIntOrd));
-}
-
-/** 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

@@ -1,15 +0,0 @@
-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),
-    ]),
-  };
-};