@indigo-labs/indigo-sdk 0.1.28 → 0.2.0

package/src/contracts/poll/scripts.ts

@@ -0,0 +1,72 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import {
+  castPollManagerParams,
+  PollManagerParams,
+} from '../poll/types-poll-manager';
+import {
+  PollManagerParamsSP,
+  PollShardParamsSP,
+  fromSystemParamsAsset,
+} from '../../types/system-params';
+import { castPollShardParams, PollShardParams } from './types-poll-shard';
+import { _pollManagerValidator } from '../../validators/poll-manager-validator';
+import { _pollShardValidator } from '../../validators/poll-shard-validator';
+
+export const mkPollManagerValidator = (
+  params: PollManagerParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_pollManagerValidator.cborHex, [
+      castPollManagerParams(params),
+    ]),
+  };
+};
+
+export const mkPollManagerValidatorFromSP = (
+  params: PollManagerParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_pollManagerValidator.cborHex, [
+      castPollManagerParams({
+        govNFT: fromSystemParamsAsset(params.govNFT),
+        pollToken: fromSystemParamsAsset(params.pollToken),
+        upgradeToken: fromSystemParamsAsset(params.upgradeToken),
+        indyAsset: fromSystemParamsAsset(params.indyAsset),
+        govExecuteValHash: params.govExecuteValHash,
+        pBiasTime: BigInt(params.pBiasTime),
+        shardValHash: params.shardsValHash,
+        treasuryValHash: params.treasuryValHash,
+        initialIndyDistribution: BigInt(params.initialIndyDistribution),
+      }),
+    ]),
+  };
+};
+
+export const mkPollShardValidator = (
+  params: PollShardParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_pollShardValidator.cborHex, [
+      castPollShardParams(params),
+    ]),
+  };
+};
+
+export const mkPollShardValidatorFromSP = (
+  params: PollShardParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_pollShardValidator.cborHex, [
+      castPollShardParams({
+        pollToken: fromSystemParamsAsset(params.pollToken),
+        stakingToken: fromSystemParamsAsset(params.stakingToken),
+        indyAsset: fromSystemParamsAsset(params.indyAsset),
+        stakingValHash: params.stakingValHash,
+      }),
+    ]),
+  };
+};

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

@@ -0,0 +1,38 @@
+import { Data, Redeemer } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
+
+const PollManagerParamsSchema = Data.Object({
+  govNFT: AssetClassSchema,
+  pollToken: AssetClassSchema,
+  upgradeToken: AssetClassSchema,
+  indyAsset: AssetClassSchema,
+  govExecuteValHash: Data.Bytes(),
+  pBiasTime: Data.Integer(),
+  shardValHash: Data.Bytes(),
+  treasuryValHash: Data.Bytes(),
+  initialIndyDistribution: Data.Integer(),
+});
+export type PollManagerParams = Data.Static<typeof PollManagerParamsSchema>;
+export const PollManagerParams =
+  PollManagerParamsSchema as unknown as PollManagerParams;
+
+const PollManagerRedeemerSchema = Data.Enum([
+  Data.Object({
+    EndPoll: Data.Object({ currentTime: Data.Integer() }),
+  }),
+  Data.Object({ CreateShards: Data.Object({ currentTime: Data.Integer() }) }),
+  Data.Object({
+    MergeShardsManager: Data.Object({ currentTime: Data.Integer() }),
+  }),
+]);
+export type PollManagerRedeemer = Data.Static<typeof PollManagerRedeemerSchema>;
+export const PollManagerRedeemer =
+  PollManagerRedeemerSchema as unknown as PollManagerRedeemer;
+
+export function serialisePollManagerRedeemer(r: PollManagerRedeemer): Redeemer {
+  return Data.to<PollManagerRedeemer>(r, PollManagerRedeemer);
+}
+
+export function castPollManagerParams(params: PollManagerParams): Data {
+  return Data.castTo(params, PollManagerParams);
+}

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

@@ -0,0 +1,38 @@
+import { Data, Redeemer } from '@lucid-evolution/lucid';
+import { AssetClassSchema, OutputReferenceSchema } 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;
+
+const VoteOptionSchema = Data.Enum([Data.Literal('Yes'), Data.Literal('No')]);
+export type VoteOption = Data.Static<typeof VoteOptionSchema>;
+
+const PollShardRedeemerSchema = Data.Enum([
+  Data.Object({ Vote: Data.Object({ content: VoteOptionSchema }) }),
+  Data.Object({
+    MergeShards: Data.Object({
+      currentTime: Data.Integer(),
+      pollManagerRef: OutputReferenceSchema,
+    }),
+  }),
+]);
+export type PollShardRedeemer = Data.Static<typeof PollShardRedeemerSchema>;
+export const PollShardRedeemer =
+  PollShardRedeemerSchema as unknown as PollShardRedeemer;
+
+export function serialisePollShardRedeemer(
+  redeemer: PollShardRedeemer,
+): Redeemer {
+  return Data.to<PollShardRedeemer>(redeemer, PollShardRedeemer);
+}
+
+export function castPollShardParams(params: PollShardParams): Data {
+  return Data.castTo(params, PollShardParams);
+}

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

@@ -0,0 +1,88 @@
+import { Data, Datum } from '@lucid-evolution/lucid';
+import { TreasuryWithdrawalSchema } from '../gov/types';
+import { AddressSchema } from '../../types/generic';
+import { option as O, function as F } from 'fp-ts';
+import { match, P } from 'ts-pattern';
+import { ProposalContentSchema } from '../gov/types-new';
+
+const PollStatusSchema = Data.Object({
+  yesVotes: Data.Integer(),
+  noVotes: Data.Integer(),
+});
+export type PollStatus = Data.Static<typeof PollStatusSchema>;
+
+const PollManagerContentSchema = Data.Object({
+  pollId: Data.Integer(),
+  pollOwner: Data.Bytes(),
+  content: ProposalContentSchema,
+  treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
+  status: PollStatusSchema,
+  votingEndTime: Data.Integer(),
+  createdShardsCount: Data.Integer(),
+  talliedShardsCount: Data.Integer(),
+  totalShardsCount: Data.Integer(),
+  proposingEndTime: Data.Integer(),
+  expirationTime: Data.Integer(),
+  protocolVersion: Data.Integer(),
+  minimumQuorum: Data.Integer(),
+});
+export type PollManagerContent = Data.Static<typeof PollManagerContentSchema>;
+
+const PollShardContentSchema = Data.Object({
+  pollId: Data.Integer(),
+  status: PollStatusSchema,
+  votingEndTime: Data.Integer(),
+  managerAddress: AddressSchema,
+});
+export type PollShardContent = Data.Static<typeof PollShardContentSchema>;
+
+const PollDatumSchema = Data.Enum([
+  Data.Object({
+    PollManager: Data.Object({ content: PollManagerContentSchema }),
+  }),
+  Data.Object({ PollShard: Data.Object({ content: PollShardContentSchema }) }),
+]);
+export type PollDatum = Data.Static<typeof PollDatumSchema>;
+export const PollDatum = PollDatumSchema as unknown as PollDatum;
+
+export function parsePollManager(datum: Datum): O.Option<PollManagerContent> {
+  try {
+    return match(Data.from<PollDatum>(datum, PollDatum))
+      .with({ PollManager: P.select() }, (res) => O.some(res.content))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parsePollManagerOrThrow(datum: Datum): PollManagerContent {
+  return F.pipe(
+    parsePollManager(datum),
+    O.match(() => {
+      throw new Error('Expected a Poll manager datum.');
+    }, F.identity),
+  );
+}
+
+export function parsePollShard(datum: Datum): O.Option<PollShardContent> {
+  try {
+    return match(Data.from<PollDatum>(datum, PollDatum))
+      .with({ PollShard: P.select() }, (res) => O.some(res.content))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parsePollShardOrThrow(datum: Datum): PollShardContent {
+  return F.pipe(
+    parsePollShard(datum),
+    O.match(() => {
+      throw new Error('Expected a Poll shard datum.');
+    }, F.identity),
+  );
+}
+
+export function serialisePollDatum(datum: PollDatum): Datum {
+  return Data.to<PollDatum>(datum, PollDatum);
+}

package/src/{scripts/price-oracle-validator.ts → contracts/price-oracle/scripts.ts}

@@ -3,10 +3,7 @@ import {
   ScriptType,
   SpendingValidator,
 } from '@lucid-evolution/lucid';
-import {
-  castPriceOracleParams,
-  PriceOracleParams,
-} from '../types/indigo/price-oracle';
+import { castPriceOracleParams, PriceOracleParams } from './types';
 
 const priceOracleValidatorData = {
   type: 'PlutusV2' as ScriptType,

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

@@ -0,0 +1,112 @@
+import {
+  addAssets,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  slotToUnixTime,
+  TxBuilder,
+  validatorToAddress,
+} from '@lucid-evolution/lucid';
+import { AssetClass } from '../../types/generic';
+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 { matchSingle } from '../../utils/utils';
+import { ONE_SECOND } from '../../utils/time-helpers';
+
+export async function startPriceOracleTx(
+  lucid: LucidEvolution,
+  assetName: string,
+  startPrice: OnChainDecimal,
+  oracleParams: PriceOracleParams,
+  now: number = Date.now(),
+  refOutRef?: OutRef,
+): Promise<[TxBuilder, OracleAssetNft]> {
+  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: oracleNftPolicyId,
+    tokenName: fromText(assetName),
+  };
+
+  const oracleValidator = mkPriceOracleValidator(oracleParams);
+
+  const oracleDatum: PriceOracleDatum = {
+    price: startPrice,
+    expiration: BigInt(now) + oracleParams.expiration,
+  };
+
+  tx.pay.ToContract(
+    validatorToAddress(lucid.config().network!, oracleValidator),
+    { kind: 'inline', value: serialisePriceOracleDatum(oracleDatum) },
+    addAssets(mkLovelacesOf(5_000_000n), mkAssetsOf(priceOracleNft, 1n)),
+  );
+
+  return [tx, { oracleNft: priceOracleNft }];
+}
+
+export async function feedPriceOracleTx(
+  lucid: LucidEvolution,
+  oracleOref: OutRef,
+  newPrice: OnChainDecimal,
+  oracleParams: PriceOracleParams,
+  currentSlot: number,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, 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,
+          expiration: currentTime + oracleParams.expiration,
+        }),
+      },
+      priceOracleUtxo.assets,
+    )
+    .addSignerKey(oracleParams.owner);
+}

package/src/{types/indigo/price-oracle.ts → contracts/price-oracle/types.ts}

@@ -1,9 +1,9 @@
-import { Data, Datum } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../generic';
-import { OnChainDecimalSchema } from '../on-chain-decimal';
+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: Data.Object({ asset: AssetClassSchema }),
+  oracleNft: AssetClassSchema,
 });
 export type OracleAssetNft = Data.Static<typeof OracleAssetNftSchema>;
 
@@ -25,6 +25,18 @@ export const PriceOracleDatumSchema = Data.Object({
 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);
 }

package/src/{helpers/stability-pool-helpers.ts → contracts/stability-pool/helpers.ts}

@@ -1,4 +1,5 @@
 import { UTxO } from '@lucid-evolution/lucid';
+import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
 import {
   EpochToScaleToSum,
   fromSPInteger,
@@ -10,10 +11,23 @@ import {
   SPInteger,
   spMul,
   spSub,
+  StabilityPoolContent,
   StabilityPoolSnapshot,
-} from '../types/indigo/stability-pool';
+} from './types-new';
+import { match } from 'ts-pattern';
 
-const newScaleMultiplier = 1000000000n;
+const newScaleMultiplier = 1_000_000_000n;
+
+export const initSpSnapshot: StabilityPoolSnapshot = {
+  productVal: { value: 1_000_000_000_000_000_000n },
+  depositVal: { value: 0n },
+  sumVal: { value: 0n },
+  epoch: 0n,
+  scale: 0n,
+};
+
+export const initEpochToScaleToSumMap = (): EpochToScaleToSum =>
+  new Map([[{ epoch: 0n, scale: 0n }, { value: 0n }]]);
 
 export function getSumFromEpochToScaleToSum(
   e2s2s: EpochToScaleToSum,
@@ -28,6 +42,9 @@ export function getSumFromEpochToScaleToSum(
   return undefined;
 }
 
+/**
+ * It's necessary to use this to update map entries because typescript can't compare keys as objects.
+ */
 export function setSumInEpochToScaleToSum(
   e2s2s: EpochToScaleToSum,
   epoch: bigint,
@@ -42,7 +59,6 @@ export function setSumInEpochToScaleToSum(
   }
 
   map.set({ epoch, scale }, sum);
-
   return map;
 }
 
@@ -104,11 +120,11 @@ function findEpochToScaleToSum(
   let ess1: EpochToScaleToSum;
   try {
     ess1 = parseSnapshotEpochToScaleToSumDatum(
-      snapshotEpochToScaleToSumTokenRef1.datum,
+      getInlineDatumOrThrow(snapshotEpochToScaleToSumTokenRef1),
     ).snapshot;
   } catch (_) {
     ess1 = parseStabilityPoolDatum(
-      snapshotEpochToScaleToSumTokenRef1.datum,
+      getInlineDatumOrThrow(snapshotEpochToScaleToSumTokenRef1),
     ).epochToScaleToSum;
   }
 
@@ -119,7 +135,7 @@ function findEpochToScaleToSum(
 
   if (snapshotEpochToScaleToSumTokenRef2) {
     const ess2 = parseSnapshotEpochToScaleToSumDatum(
-      snapshotEpochToScaleToSumTokenRef2.datum,
+      getInlineDatumOrThrow(snapshotEpochToScaleToSumTokenRef2),
     );
     const ess2Ref: SnapshotESSSearchResult = {
       utxo: snapshotEpochToScaleToSumTokenRef2,
@@ -205,3 +221,91 @@ export function updatePoolSnapshotWithdrawalFee(
 
   return [newPoolDepositVal, newPoolProduct];
 }
+
+export function liquidationHelper(
+  spContent: StabilityPoolContent,
+  iassetBurnAmt: bigint,
+  /**
+   * The collateral absorbed
+   */
+  reward: bigint,
+): { newSpContent: StabilityPoolContent } {
+  const lossPerUnitStaked = spDiv(
+    mkSPInteger(iassetBurnAmt),
+    spContent.poolSnapshot.depositVal,
+  );
+  const productFactor = spSub(mkSPInteger(1n), lossPerUnitStaked);
+
+  const isScaleIncrease =
+    spMul(spContent.poolSnapshot.productVal, productFactor).value <
+    newScaleMultiplier;
+
+  const newSumSnapshot = spAdd(
+    spContent.poolSnapshot.sumVal,
+    spDiv(
+      spMul(mkSPInteger(reward), spContent.poolSnapshot.productVal),
+      spContent.poolSnapshot.depositVal,
+    ),
+  );
+  const newProductSnapshot = spMul(
+    {
+      value:
+        spContent.poolSnapshot.productVal.value *
+        (isScaleIncrease ? newScaleMultiplier : 1n),
+    },
+    productFactor,
+  );
+
+  const isEpochIncrease = newProductSnapshot.value <= 0n;
+
+  const newSnapshot: StabilityPoolSnapshot = isEpochIncrease
+    ? { ...initSpSnapshot, epoch: spContent.poolSnapshot.epoch + 1n }
+    : {
+        productVal: newProductSnapshot,
+        depositVal: spSub(
+          spContent.poolSnapshot.depositVal,
+          mkSPInteger(iassetBurnAmt),
+        ),
+        sumVal: newSumSnapshot,
+        epoch: spContent.poolSnapshot.epoch,
+        scale: spContent.poolSnapshot.scale + (isScaleIncrease ? 1n : 0n),
+      };
+
+  const newMap = setSumInEpochToScaleToSum(
+    spContent.epochToScaleToSum,
+    spContent.poolSnapshot.epoch,
+    spContent.poolSnapshot.scale,
+    newSumSnapshot,
+  );
+
+  const newEpochToScaleToSum = match(true)
+    .when(
+      () => isEpochIncrease,
+      () =>
+        setSumInEpochToScaleToSum(
+          newMap,
+          spContent.poolSnapshot.epoch + 1n,
+          spContent.poolSnapshot.scale,
+          { value: 0n },
+        ),
+    )
+    .when(
+      () => isScaleIncrease,
+      () =>
+        setSumInEpochToScaleToSum(
+          newMap,
+          spContent.poolSnapshot.epoch,
+          spContent.poolSnapshot.scale + 1n,
+          newSumSnapshot,
+        ),
+    )
+    .otherwise(() => newMap);
+
+  return {
+    newSpContent: {
+      asset: spContent.asset,
+      epochToScaleToSum: newEpochToScaleToSum,
+      poolSnapshot: newSnapshot,
+    },
+  };
+}

package/src/contracts/stability-pool/scripts.ts

@@ -0,0 +1,46 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import { castStabilityPoolParams, StabilityPoolParams } from './types';
+import {
+  fromSystemParamsAsset,
+  StabilityPoolParamsSP,
+} from '../../types/system-params';
+import { _stabilityPoolValidator } from '../../validators/stability-pool-validator';
+
+export const mkStabilityPoolValidator = (
+  params: StabilityPoolParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_stabilityPoolValidator.cborHex, [
+      castStabilityPoolParams(params),
+    ]),
+  };
+};
+
+export const mkStabilityPoolValidatorFromSP = (
+  params: StabilityPoolParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_stabilityPoolValidator.cborHex, [
+      castStabilityPoolParams({
+        assetSymbol: params.assetSymbol.unCurrencySymbol,
+        stabilityPoolToken: fromSystemParamsAsset(params.stabilityPoolToken),
+        snapshotEpochToScaleToSumToken: fromSystemParamsAsset(
+          params.snapshotEpochToScaleToSumToken,
+        ),
+        accountToken: fromSystemParamsAsset(params.accountToken),
+        cdpToken: fromSystemParamsAsset(params.cdpToken),
+        iAssetAuthToken: fromSystemParamsAsset(params.iAssetAuthToken),
+        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
+        collectorValHash: params.collectorValHash,
+        govNFT: fromSystemParamsAsset(params.govNFT),
+        accountCreateFeeLovelaces: BigInt(params.accountCreateFeeLovelaces),
+        accountAdjustmentFeeLovelaces: BigInt(
+          params.accountAdjustmentFeeLovelaces,
+        ),
+        requestCollateralLovelaces: BigInt(params.requestCollateralLovelaces),
+      }),
+    ]),
+  };
+};