@indigo-labs/indigo-sdk 0.1.21 → 0.1.22

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/{contracts/version-registry/types.ts → types/indigo/version-record.ts}

@@ -1,5 +1,5 @@
 import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
+import { AssetClassSchema } from '../generic';
 
 const VersionRecordTokenParamsSchema = Data.Object({
   upgradeToken: AssetClassSchema,

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

@@ -7,16 +7,6 @@ export const OnChainDecimalSchema = Data.Object({
 });
 export type OnChainDecimal = Data.Static<typeof OnChainDecimalSchema>;
 
-export function ocdCeil(a: OnChainDecimal): bigint {
-  const whole = a.getOnChainInt / OCD_DECIMAL_UNIT;
-
-  return a.getOnChainInt > whole * OCD_DECIMAL_UNIT ? whole + 1n : whole;
-}
-
-export function ocdNegate(a: OnChainDecimal): OnChainDecimal {
-  return { getOnChainInt: -a.getOnChainInt };
-}
-
 export function ocdMul(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
   return {
     getOnChainInt: (a.getOnChainInt * b.getOnChainInt) / OCD_DECIMAL_UNIT,
@@ -29,17 +19,5 @@ export function ocdDiv(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
   };
 }
 
-export function ocdAdd(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
-  return {
-    getOnChainInt: a.getOnChainInt + b.getOnChainInt,
-  };
-}
-
-export function ocdSub(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
-  return {
-    getOnChainInt: a.getOnChainInt - b.getOnChainInt,
-  };
-}
-
 export const OCD_ONE: OnChainDecimal = { getOnChainInt: 1_000_000n };
 export const OCD_ZERO: OnChainDecimal = { getOnChainInt: 0n };

package/src/types/system-params.ts

@@ -1,4 +1,4 @@
-import { Credential, fromText, OutRef, toText } from '@lucid-evolution/lucid';
+import { fromText, toText } from '@lucid-evolution/lucid';
 import { AssetClass, CurrencySymbol, TokenName } from './generic';
 
 /**
@@ -9,9 +9,9 @@ export type AssetClassSP = [CurrencySymbol, TokenName];
 export interface SystemParams {
   versionRecordParams: VersionRecordParams;
   validatorHashes: ValidatorHashes;
-  treasuryParams: TreasuryParamsSP;
+  treasuryParams: TreasuryParams;
   startTime: StartTime;
-  stakingParams: StakingParamsSP;
+  stakingParams: StakingParams;
   stabilityPoolParams: StabilityPoolParamsSP;
   scriptReferences: ScriptReferences;
   pollShardParams: PollShardParamsSP;
@@ -21,8 +21,8 @@ export interface SystemParams {
   govParams: GovParamsSP;
   executeParams: ExecuteParamsSP;
   distributionParams: DistributionParams;
-  collectorParams: CollectorParamsSP;
-  cdpParams: CdpParamsSP;
+  collectorParams: CollectorParams;
+  cdpParams: CdpParams;
   cdpCreatorParams: CDPCreatorParamsSP;
 }
 export type ValidatorHashes = {
@@ -57,7 +57,7 @@ export interface PubKeyHash {
 export interface VersionRecordParams {
   upgradeToken: AssetClassSP;
 }
-export interface TreasuryParamsSP {
+export interface TreasuryParams {
   upgradeToken: AssetClassSP;
   versionRecordToken: AssetClassSP;
   treasuryUtxosStakeCredential?: ScriptCredential;
@@ -66,7 +66,7 @@ export interface StartTime {
   slot: number;
   blockHeader: string;
 }
-export interface StakingParamsSP {
+export interface StakingParams {
   versionRecordToken: AssetClassSP;
   stakingToken: AssetClassSP;
   stakingManagerNFT: AssetClassSP;
@@ -90,6 +90,7 @@ export interface StabilityPoolParamsSP {
 }
 
 export interface ScriptReferences {
+  vestingValidatorRef: ScriptReference;
   versionRegistryValidatorRef: ScriptReference;
   versionRecordTokenPolicyRef: ScriptReference;
   treasuryValidatorRef: ScriptReference;
@@ -98,6 +99,7 @@ export interface ScriptReferences {
   pollShardValidatorRef: ScriptReference;
   pollManagerValidatorRef: ScriptReference;
   lrpValidatorRef: ScriptReference;
+  liquidityValidatorRef: ScriptReference;
   iAssetTokenPolicyRef: ScriptReference;
   governanceValidatorRef: ScriptReference;
   executeValidatorRef: ScriptReference;
@@ -145,10 +147,8 @@ export interface AuthTokenPolicies {
   upgradeTokenRef: ScriptReference;
   stakingTokenRef: ScriptReference;
   stabilityPoolTokenRef: ScriptReference;
-  stabilityPoolAuthTokenRef: ScriptReference;
   snapshotEpochToScaleToSumTokenRef: ScriptReference;
   pollManagerTokenRef: ScriptReference;
-  iAssetAuthTokenRef: ScriptReference;
   iAssetTokenRef: ScriptReference;
   cdpAuthTokenRef: ScriptReference;
   accountTokenRef: ScriptReference;
@@ -191,7 +191,6 @@ export interface GovParamsSP {
   gBiasTime: bigint;
   daoIdentityToken: AssetClassSP;
 }
-
 export interface ExecuteParamsSP {
   govNFT: AssetClassSP;
   upgradeToken: AssetClassSP;
@@ -209,12 +208,12 @@ export interface DistributionParams {
   totalINDYSupply: number;
   initialIndyDistribution: number;
 }
-export interface CollectorParamsSP {
+export interface CollectorParams {
   versionRecordToken: AssetClassSP;
   stakingToken: AssetClassSP;
   stakingManagerNFT: AssetClassSP;
 }
-export interface CdpParamsSP {
+export interface CdpParams {
   versionRecordToken: AssetClassSP;
   upgradeToken: AssetClassSP;
   treasuryValHash: string;
@@ -255,13 +254,3 @@ export function fromSystemParamsAsset(asset: AssetClassSP): AssetClass {
     tokenName: fromText(asset[1].unTokenName),
   };
 }
-
-export function fromSystemParamsScriptRef(ref: ScriptReference): OutRef {
-  return { outputIndex: ref.input.index, txHash: ref.input.transactionId };
-}
-
-export function fromSysParamsScriptCredential(
-  cred: ScriptCredential,
-): Credential {
-  return { type: 'Script', hash: cred.contents.contents };
-}