@indigo-labs/indigo-sdk 0.1.7 → 0.1.9

package/src/types/indigo/interest-oracle.ts

@@ -0,0 +1,55 @@
+import { Data, Datum } from '@lucid-evolution/lucid';
+import { OnChainDecimalSchema } from '../on-chain-decimal';
+
+export const InterestOracleDatumSchema = Data.Object({
+  unitaryInterest: Data.Integer(),
+  interestRate: OnChainDecimalSchema,
+  lastUpdated: Data.Integer(),
+});
+export type InterestOracleDatum = Data.Static<typeof InterestOracleDatumSchema>;
+const InterestOracleDatum =
+  InterestOracleDatumSchema as unknown as InterestOracleDatum;
+
+export function parseInterestOracleDatum(datum: Datum): InterestOracleDatum {
+  return Data.from<InterestOracleDatum>(datum, InterestOracleDatum);
+}
+
+export function serialiseInterestOracleDatum(
+  datum: InterestOracleDatum,
+): Datum {
+  return Data.to<InterestOracleDatum>(datum, InterestOracleDatum);
+}
+
+export const FeedInterestOracleRedeemerSchema = Data.Object({
+  newInterestRate: OnChainDecimalSchema,
+  currentTime: Data.Integer(),
+});
+export type FeedInterestOracleRedeemer = Data.Static<
+  typeof FeedInterestOracleRedeemerSchema
+>;
+const FeedInterestOracleRedeemer =
+  FeedInterestOracleRedeemerSchema as unknown as FeedInterestOracleRedeemer;
+
+export function serialiseFeedInterestOracleRedeemer(
+  redeemer: FeedInterestOracleRedeemer,
+): Datum {
+  return Data.to<FeedInterestOracleRedeemer>(
+    redeemer,
+    FeedInterestOracleRedeemer,
+  );
+}
+
+export const InterestOracleParamsSchema = Data.Object({
+  /**  Milliseconds */
+  biasTime: Data.Integer(),
+  owner: Data.Bytes(),
+});
+export type InterestOracleParams = Data.Static<
+  typeof InterestOracleParamsSchema
+>;
+const InterestOracleParams =
+  InterestOracleParamsSchema as unknown as InterestOracleParams;
+
+export function castInterestOracleParams(params: InterestOracleParams): Data {
+  return Data.castTo(params, InterestOracleParams);
+}

package/src/types/indigo/lrp.ts

@@ -0,0 +1,59 @@
+import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import { AssetClassSchema, OutputReferenceSchema } from '../generic';
+import { OnChainDecimalSchema } from '../on-chain-decimal';
+
+export const LRPParamsSchema = Data.Object({
+  versionRecordToken: AssetClassSchema,
+  iassetNft: AssetClassSchema,
+  iassetPolicyId: Data.Bytes(),
+  minRedemptionLovelacesAmt: Data.Integer(),
+});
+export type LRPParams = Data.Static<typeof LRPParamsSchema>;
+const LRPParams = LRPParamsSchema as unknown as LRPParams;
+
+export const LRPDatumSchema = Data.Object({
+  owner: Data.Bytes(),
+  iasset: Data.Bytes(),
+  maxPrice: OnChainDecimalSchema,
+  /**
+   * The amount of lovelaces that is available to be spent.
+   * This doesn't correspond to the lovelaces in UTXO's value,
+   * since that can contain fees, too.
+   */
+  lovelacesToSpend: Data.Integer(),
+});
+export type LRPDatum = Data.Static<typeof LRPDatumSchema>;
+const LRPDatum = LRPDatumSchema as unknown as LRPDatum;
+
+export const LRPRedeemerSchema = Data.Enum([
+  Data.Object({ Redeem: Data.Object({ continuingOutputIdx: Data.Integer() }) }),
+  Data.Object({
+    RedeemAuxiliary: Data.Object({
+      continuingOutputIdx: Data.Integer(),
+      mainRedeemOutRef: OutputReferenceSchema,
+      asset: Data.Bytes(),
+      assetPrice: OnChainDecimalSchema,
+      redemptionReimbursementPercentage: OnChainDecimalSchema,
+    }),
+  }),
+  Data.Literal('Cancel'),
+  Data.Literal('UpgradeVersion'),
+]);
+export type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
+const LRPRedeemer = LRPRedeemerSchema as unknown as LRPRedeemer;
+
+export function parseLrpDatum(datum: Datum): LRPDatum {
+  return Data.from<LRPDatum>(datum, LRPDatum);
+}
+
+export function serialiseLrpDatum(datum: LRPDatum): Datum {
+  return Data.to<LRPDatum>(datum, LRPDatum);
+}
+
+export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {
+  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer);
+}
+
+export function castLrpParams(params: LRPParams): Data {
+  return Data.castTo(params, LRPParams);
+}

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

@@ -0,0 +1,21 @@
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../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;
+
+export function castPollManagerParams(params: PollManagerParams): Data {
+  return Data.castTo(params, PollManagerParams);
+}

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

@@ -0,0 +1,16 @@
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../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/types/indigo/price-oracle.ts

@@ -0,0 +1,38 @@
+import { Data, Datum } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../generic';
+import { OnChainDecimalSchema } from '../on-chain-decimal';
+
+export const OracleAssetNftSchema = Data.Object({
+  oracleNft: Data.Object({ asset: AssetClassSchema }),
+});
+export type OracleAssetNft = Data.Static<typeof OracleAssetNftSchema>;
+
+export const PriceOracleParamsSchema = Data.Object({
+  owner: Data.Bytes(),
+  /**  Milliseconds */
+  biasTime: Data.Integer(),
+  /**  Milliseconds */
+  expiration: 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;
+
+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/types/indigo/stability-pool.ts

@@ -0,0 +1,233 @@
+import { Data, Datum } from '@lucid-evolution/lucid';
+import { match, P } from 'ts-pattern';
+import {
+  AddressSchema,
+  AssetClassSchema,
+  OutputReferenceSchema,
+} from '../generic';
+
+export const SPIntegerSchema = Data.Object({
+  value: Data.Integer(),
+});
+
+export type SPInteger = Data.Static<typeof SPIntegerSchema>;
+export const SPInteger = SPIntegerSchema as unknown as SPInteger;
+
+const StabilityPoolSnapshotSchema = Data.Object({
+  productVal: SPIntegerSchema,
+  depositVal: SPIntegerSchema,
+  sumVal: SPIntegerSchema,
+  epoch: Data.Integer(),
+  scale: Data.Integer(),
+});
+
+export type StabilityPoolSnapshot = Data.Static<
+  typeof StabilityPoolSnapshotSchema
+>;
+export const StabilityPoolSnapshot =
+  StabilityPoolSnapshotSchema as unknown as StabilityPoolSnapshot;
+
+export const EpochToScaleToSumSchema = Data.Map(
+  Data.Object({ epoch: Data.Integer(), scale: Data.Integer() }),
+  SPIntegerSchema,
+  { minItems: 0 },
+);
+
+export type EpochToScaleToSum = Data.Static<typeof EpochToScaleToSumSchema>;
+export const EpochToScaleToSum =
+  EpochToScaleToSumSchema as unknown as EpochToScaleToSum;
+
+export const StabilityPoolContentSchema = Data.Object({
+  asset: Data.Bytes(),
+  snapshot: StabilityPoolSnapshotSchema,
+  epochToScaleToSum: EpochToScaleToSumSchema,
+});
+
+export type StabilityPoolContent = Data.Static<
+  typeof StabilityPoolContentSchema
+>;
+export const StabilityPoolContent =
+  StabilityPoolContentSchema as unknown as StabilityPoolContent;
+
+export const AccountActionSchema = Data.Enum([
+  Data.Literal('Create'),
+  Data.Object({
+    Adjust: Data.Object({
+      amount: Data.Integer(),
+      outputAddress: AddressSchema,
+    }),
+  }),
+  Data.Object({ Close: Data.Object({ outputAddress: AddressSchema }) }),
+]);
+
+export type AccountAction = Data.Static<typeof AccountActionSchema>;
+export const AccountAction = AccountActionSchema as unknown as AccountAction;
+
+export const AccountContentSchema = Data.Object({
+  owner: Data.Bytes(),
+  asset: Data.Bytes(),
+  snapshot: StabilityPoolSnapshotSchema,
+  request: Data.Nullable(AccountActionSchema),
+});
+
+export type AccountContent = Data.Static<typeof AccountContentSchema>;
+export const AccountContent = AccountContentSchema as unknown as AccountContent;
+
+export const SnapshotEpochToScaleToSumContentSchema = Data.Object({
+  asset: Data.Bytes(),
+  snapshot: EpochToScaleToSumSchema,
+});
+
+export type SnapshotEpochToScaleToSumContent = Data.Static<
+  typeof SnapshotEpochToScaleToSumContentSchema
+>;
+export const SnapshotEpochToScaleToSumContent =
+  SnapshotEpochToScaleToSumContentSchema as unknown as SnapshotEpochToScaleToSumContent;
+
+export const StabilityPoolDatumSchema = Data.Enum([
+  Data.Object({
+    StabilityPool: Data.Object({ content: StabilityPoolContentSchema }),
+  }),
+  Data.Object({ Account: Data.Object({ content: AccountContentSchema }) }),
+  Data.Object({
+    SnapshotEpochToScaleToSum: Data.Object({
+      content: SnapshotEpochToScaleToSumContentSchema,
+    }),
+  }),
+]);
+
+export type StabilityPoolDatum = Data.Static<typeof StabilityPoolDatumSchema>;
+export const StabilityPoolDatum =
+  StabilityPoolDatumSchema as unknown as StabilityPoolDatum;
+
+export const ActionReturnDatumSchema = Data.Enum([
+  Data.Object({
+    IndigoStabilityPoolAccountAdjustment: Data.Object({
+      spent_account: OutputReferenceSchema,
+    }),
+  }),
+  Data.Object({
+    IndigoStabilityPoolAccountClosure: Data.Object({
+      closed_account: OutputReferenceSchema,
+    }),
+  }),
+]);
+
+export type ActionReturnDatum = Data.Static<typeof ActionReturnDatumSchema>;
+export const ActionReturnDatum =
+  ActionReturnDatumSchema as unknown as ActionReturnDatum;
+
+export const StabilityPoolRedeemerSchema = Data.Enum([
+  Data.Object({ RequestAction: Data.Object({ action: AccountActionSchema }) }),
+  Data.Object({
+    ProcessRequest: Data.Object({ requestRef: OutputReferenceSchema }),
+  }),
+  Data.Object({ AnnulRequest: Data.Object({}) }),
+  Data.Object({ LiquidateCDP: Data.Object({}) }),
+  Data.Object({ RecordEpochToScaleToSum: Data.Object({}) }),
+  Data.Object({ UpgradeVersion: Data.Object({}) }),
+]);
+
+export type StabilityPoolRedeemer = Data.Static<
+  typeof StabilityPoolRedeemerSchema
+>;
+export const StabilityPoolRedeemer =
+  StabilityPoolRedeemerSchema as unknown as StabilityPoolRedeemer;
+
+export function parseStabilityPoolDatum(datum: Datum): StabilityPoolContent {
+  return match(Data.from<StabilityPoolDatum>(datum, StabilityPoolDatum))
+    .with({ StabilityPool: { content: P.select() } }, (res) => res)
+    .otherwise(() => {
+      throw new Error('Expected a Stability Pool datum.');
+    });
+}
+
+export function parseAccountDatum(datum: Datum): AccountContent {
+  return match(Data.from<StabilityPoolDatum>(datum, StabilityPoolDatum))
+    .with({ Account: { content: P.select() } }, (res) => res)
+    .otherwise(() => {
+      throw new Error('Expected a StakingPosition datum.');
+    });
+}
+
+export function parseSnapshotEpochToScaleToSumDatum(
+  datum: Datum,
+): SnapshotEpochToScaleToSumContent {
+  return match(Data.from<StabilityPoolDatum>(datum, StabilityPoolDatum))
+    .with({ SnapshotEpochToScaleToSum: { content: P.select() } }, (res) => res)
+    .otherwise(() => {
+      throw new Error('Expected a SnapshotEpochToScaleToSum datum.');
+    });
+}
+
+export function serialiseStabilityPoolDatum(d: StabilityPoolDatum): Datum {
+  let cbor = Data.to<StabilityPoolDatum>(d, StabilityPoolDatum);
+  if ('StabilityPool' in d) {
+    if (cbor.includes('bf')) {
+      if (d.StabilityPool.content.epochToScaleToSum.size > 0) {
+        cbor = cbor.replace(
+          'bf',
+          'a' + d.StabilityPool.content.epochToScaleToSum.size,
+        );
+        cbor = cbor.replace('ffffff', 'ffff');
+      }
+    }
+  }
+  return cbor;
+}
+
+export function serialiseStabilityPoolRedeemer(
+  params: StabilityPoolRedeemer,
+): string {
+  return Data.to<StabilityPoolRedeemer>(params, StabilityPoolRedeemer);
+}
+
+/** SP Parameters */
+const StabilityPoolParamsSchema = Data.Object({
+  assetSymbol: Data.Bytes(),
+  stabilityPoolToken: AssetClassSchema,
+  snapshotEpochToScaleToSumToken: AssetClassSchema,
+  accountToken: AssetClassSchema,
+  cdpToken: AssetClassSchema,
+  iAssetAuthToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  collectorValHash: Data.Bytes(),
+  govNFT: AssetClassSchema,
+  accountCreateFeeLovelaces: Data.Integer(),
+  accountAdjustmentFeeLovelaces: Data.Integer(),
+  requestCollateralLovelaces: Data.Integer(),
+});
+export type StabilityPoolParams = Data.Static<typeof StabilityPoolParamsSchema>;
+export const StabilityPoolParams =
+  StabilityPoolParamsSchema as unknown as StabilityPoolParams;
+
+export function castStabilityPoolParams(params: StabilityPoolParams): Data {
+  return Data.castTo(params, StabilityPoolParams);
+}
+
+/** SP Integer */
+const spPrecision: bigint = 1000000000000000000n;
+
+export function mkSPInteger(value: bigint): SPInteger {
+  return { value: value * spPrecision };
+}
+
+export function fromSPInteger(value: SPInteger): bigint {
+  return value.value / spPrecision;
+}
+
+export function spAdd(a: SPInteger, b: SPInteger): SPInteger {
+  return { value: a.value + b.value };
+}
+
+export function spSub(a: SPInteger, b: SPInteger): SPInteger {
+  return { value: a.value - b.value };
+}
+
+export function spMul(a: SPInteger, b: SPInteger): SPInteger {
+  return { value: (a.value * b.value) / spPrecision };
+}
+
+export function spDiv(a: SPInteger, b: SPInteger): SPInteger {
+  return { value: (a.value * spPrecision) / b.value };
+}

package/src/types/indigo/staking.ts

@@ -0,0 +1,99 @@
+import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../generic';
+import { match, P } from 'ts-pattern';
+
+const StakingParamsSchema = Data.Object({
+  stakingManagerNft: AssetClassSchema,
+  stakingToken: AssetClassSchema,
+  indyToken: AssetClassSchema,
+  pollToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  collectorValHash: Data.Bytes(),
+});
+type StakingParams = Data.Static<typeof StakingParamsSchema>;
+const StakingParams = StakingParamsSchema as unknown as StakingParams;
+
+const StakingRedeemerSchema = Data.Enum([
+  Data.Object({
+    CreateStakingPosition: Data.Object({
+      creatorPkh: Data.Bytes(),
+    }),
+  }),
+  Data.Literal('UpdateTotalStake'),
+  Data.Literal('Distribute'),
+  Data.Object({
+    AdjustStakedAmount: Data.Object({
+      adjustAmount: Data.Integer(),
+    }),
+  }),
+  Data.Literal('Unstake'),
+  Data.Literal('Lock'),
+  Data.Literal('UpgradeVersion'),
+]);
+export type StakingRedeemer = Data.Static<typeof StakingRedeemerSchema>;
+const StakingRedeemer = StakingRedeemerSchema as unknown as StakingRedeemer;
+
+const RewardSnapshotSchema = Data.Object({ snapshotAda: Data.Integer() });
+
+const StakingManagerContentSchema = Data.Object({
+  totalStake: Data.Integer(),
+  managerSnapshot: RewardSnapshotSchema,
+});
+export type StakingManagerContent = Data.Static<
+  typeof StakingManagerContentSchema
+>;
+
+const StakingPositionContentSchema = Data.Object({
+  owner: Data.Bytes(),
+  lockedAmount: Data.Map(
+    Data.Integer(),
+    Data.Tuple([Data.Integer(), Data.Integer()], {
+      hasConstr: true,
+    }),
+  ),
+  positionSnapshot: RewardSnapshotSchema,
+});
+export type StakingPositionContent = Data.Static<
+  typeof StakingPositionContentSchema
+>;
+
+const StakingDatumSchema = Data.Enum([
+  Data.Object({
+    StakingManager: Data.Object({ content: StakingManagerContentSchema }),
+  }),
+  Data.Object({
+    StakingPosition: Data.Object({ content: StakingPositionContentSchema }),
+  }),
+]);
+export type StakingDatum = Data.Static<typeof StakingDatumSchema>;
+const StakingDatum = StakingDatumSchema as unknown as StakingDatum;
+
+export function parseStakingPositionDatum(
+  datum: Datum,
+): StakingPositionContent {
+  return match(Data.from<StakingDatum>(datum, StakingDatum))
+    .with({ StakingPosition: { content: P.select() } }, (res) => res)
+    .otherwise(() => {
+      throw new Error('Expected a StakingPosition datum.');
+    });
+}
+
+export function parseStakingManagerDatum(datum: Datum): StakingManagerContent {
+  return match(Data.from<StakingDatum>(datum, StakingDatum))
+    .with({ StakingManager: { content: P.select() } }, (res) => res)
+    .otherwise(() => {
+      throw new Error('Expected a StakingPosition datum.');
+    });
+}
+
+export function serialiseStakingRedeemer(redeemer: StakingRedeemer): Redeemer {
+  return Data.to<StakingRedeemer>(redeemer, StakingRedeemer);
+}
+
+export function serialiseStakingDatum(d: StakingDatum): Datum {
+  return Data.to<StakingDatum>(d, StakingDatum);
+}
+
+export function castStakingParams(params: StakingParams): Data {
+  return Data.castTo(params, StakingParams);
+}

package/src/types/indigo/version-record.ts

@@ -0,0 +1,17 @@
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../generic';
+
+const VersionRecordTokenParamsSchema = Data.Object({
+  upgradeToken: AssetClassSchema,
+});
+export type VersionRecordTokenParams = Data.Static<
+  typeof VersionRecordTokenParamsSchema
+>;
+export const VersionRecordTokenParams =
+  VersionRecordTokenParamsSchema as unknown as VersionRecordTokenParams;
+
+export function castVersionRecordTokenParams(
+  params: VersionRecordTokenParams,
+): Data {
+  return Data.castTo(params, VersionRecordTokenParams);
+}

package/src/types/on-chain-decimal.ts

@@ -0,0 +1,23 @@
+import { Data } from '@lucid-evolution/lucid';
+
+export const OCD_DECIMAL_UNIT: bigint = 1_000_000n;
+
+export const OnChainDecimalSchema = Data.Object({
+  getOnChainInt: Data.Integer(),
+});
+export type OnChainDecimal = Data.Static<typeof OnChainDecimalSchema>;
+
+export function ocdMul(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
+  return {
+    getOnChainInt: (a.getOnChainInt * b.getOnChainInt) / OCD_DECIMAL_UNIT,
+  };
+}
+
+export function ocdDiv(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
+  return {
+    getOnChainInt: (a.getOnChainInt * OCD_DECIMAL_UNIT) / b.getOnChainInt,
+  };
+}
+
+export const OCD_ONE: OnChainDecimal = { getOnChainInt: 1_000_000n };
+export const OCD_ZERO: OnChainDecimal = { getOnChainInt: 0n };

package/src/types/one-shot.ts

@@ -0,0 +1,22 @@
+import { Data } from '@lucid-evolution/lucid';
+
+export const OneShotParamsSchema = Data.Object({
+  referenceOutRef: Data.Object({
+    txHash: Data.Bytes(),
+    outputIdx: Data.Integer(),
+  }),
+  mintAmounts: Data.Array(
+    Data.Object({
+      /// Use hex encoded string
+      tokenName: Data.Bytes(),
+      amount: Data.Integer(),
+    }),
+  ),
+});
+
+export type OneShotParams = Data.Static<typeof OneShotParamsSchema>;
+const OneShotParams = OneShotParamsSchema as unknown as OneShotParams;
+
+export function castOneShotParams(params: OneShotParams): Data {
+  return Data.castTo(params, OneShotParams);
+}