@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/src/contracts/staking/helpers.ts

@@ -1,136 +0,0 @@
-import {
-  fromText,
-  OutRef,
-  UTxO,
-  validatorToScriptHash,
-} from '@lucid-evolution/lucid';
-import { LucidEvolution } from '@lucid-evolution/lucid';
-import { SystemParams } from '../../types/system-params';
-import {
-  parseStakingManagerDatum,
-  parseStakingPositionOrThrow,
-  StakingManager,
-  StakingPosition,
-  StakingPosLockedAmt,
-} from './types-new';
-import { createScriptAddress } from '../../utils/lucid-utils';
-import { mkStakingValidatorFromSP } from './scripts';
-import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
-
-export type StakingPositionOutput = {
-  utxo: UTxO;
-  datum: StakingPosition;
-};
-export type StakingManagerOutput = { utxo: UTxO; datum: StakingManager };
-
-/**
- * Update the staking position locked amount. In case proposal's voting finished, unlock the amount.
- */
-export function updateStakingLockedAmount(
-  stakingPosLockedAmt: StakingPosLockedAmt,
-  currentTime: bigint,
-): StakingPosLockedAmt {
-  return stakingPosLockedAmt.filter(
-    ([_, { votingEnd }]) => votingEnd > currentTime,
-  );
-}
-
-export function findStakingManagerByOutRef(
-  stakingManagerRef: OutRef,
-  lucid: LucidEvolution,
-): Promise<StakingManagerOutput> {
-  return lucid
-    .utxosByOutRef([stakingManagerRef])
-    .then((utxos) =>
-      utxos
-        .map((utxo) => {
-          if (!utxo.datum) return undefined;
-          const datum = parseStakingManagerDatum(utxo.datum);
-          return { utxo, datum };
-        })
-        .find((utxo) => utxo !== undefined),
-    )
-    .then((result) => {
-      if (!result)
-        throw new Error(
-          'Unable to locate Staking Manager by output reference.',
-        );
-      return result;
-    });
-}
-
-export function findStakingManager(
-  params: SystemParams,
-  lucid: LucidEvolution,
-): Promise<StakingManagerOutput> {
-  return lucid
-    .utxosAtWithUnit(
-      createScriptAddress(
-        lucid.config().network!,
-        validatorToScriptHash(mkStakingValidatorFromSP(params.stakingParams)),
-      ),
-      params.stakingParams.stakingManagerNFT[0].unCurrencySymbol +
-        fromText(params.stakingParams.stakingManagerNFT[1].unTokenName),
-    )
-    .then((utxos) =>
-      utxos
-        .map((utxo) => {
-          if (!utxo.datum) return undefined;
-          const datum = parseStakingManagerDatum(utxo.datum);
-          return { utxo, datum };
-        })
-        .find((utxo) => utxo !== undefined),
-    )
-    .then((result) => {
-      if (!result)
-        throw new Error(
-          'Unable to locate Staking Manager by output reference.',
-        );
-      return result;
-    });
-}
-
-export function findStakingPositionByOutRef(
-  stakingPositionRef: OutRef,
-  lucid: LucidEvolution,
-): Promise<StakingPositionOutput> {
-  return lucid
-    .utxosByOutRef([stakingPositionRef])
-    .then((utxos) =>
-      utxos
-        .map((utxo) => {
-          if (!utxo.datum) return undefined;
-          const datum = parseStakingPositionOrThrow(utxo.datum);
-          return { utxo, datum };
-        })
-        .find((utxo) => utxo !== undefined),
-    )
-    .then((result) => {
-      if (!result)
-        throw new Error(
-          'Unable to locate Staking Position by output reference.',
-        );
-      return result;
-    });
-}
-
-export const rewardSnapshotPrecision = OCD_DECIMAL_UNIT * OCD_DECIMAL_UNIT;
-
-export function distributeReward(
-  snapshotAda: bigint,
-  adaReward: bigint,
-  totalStake: bigint,
-): bigint {
-  return snapshotAda + (adaReward * rewardSnapshotPrecision) / totalStake;
-}
-
-export function calculateAdaReward(
-  currentSnapshotAda: bigint,
-  oldSnapshotAda: bigint,
-  existingIndyAmount: bigint,
-): bigint {
-  return (
-    ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
-    rewardSnapshotPrecision
-  );
-}

package/src/contracts/staking/scripts.ts

@@ -1,41 +0,0 @@
-import {
-  applyParamsToScript,
-  Constr,
-  fromText,
-  SpendingValidator,
-} from '@lucid-evolution/lucid';
-import { StakingParamsSP } from '../../types/system-params';
-import { _stakingValidator } from '../../validators/staking-validator';
-
-export const mkStakingValidatorFromSP = (
-  params: StakingParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_stakingValidator.cborHex, [
-      new Constr(0, [
-        new Constr(0, [
-          params.stakingManagerNFT[0].unCurrencySymbol,
-          fromText(params.stakingManagerNFT[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.stakingToken[0].unCurrencySymbol,
-          fromText(params.stakingToken[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.indyToken[0].unCurrencySymbol,
-          fromText(params.indyToken[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.pollToken[0].unCurrencySymbol,
-          fromText(params.pollToken[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.versionRecordToken[0].unCurrencySymbol,
-          fromText(params.versionRecordToken[1].unTokenName),
-        ]),
-        params.collectorValHash,
-      ]),
-    ]),
-  };
-};

package/src/contracts/staking/transactions.ts

@@ -1,349 +0,0 @@
-import {
-  addAssets,
-  Data,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  OutRef,
-  toHex,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsAsset,
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../types/system-params';
-import { addrDetails } from '../../utils/lucid-utils';
-import {
-  calculateAdaReward,
-  distributeReward,
-  findStakingManager,
-  findStakingManagerByOutRef,
-  findStakingPositionByOutRef,
-  updateStakingLockedAmount,
-} from './helpers';
-import {
-  parseStakingManagerDatum,
-  serialiseStakingDatum,
-  serialiseStakingRedeemer,
-  StakingManager,
-  StakingPosition,
-} from './types-new';
-import { matchSingle } from '../../utils/utils';
-import { serialiseCollectorRedeemer } from '../collector/types-new';
-import {
-  assetClassValueOf,
-  getInlineDatumOrThrow,
-  mkAssetsOf,
-  mkLovelacesOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-
-export async function openStakingPosition(
-  amount: bigint,
-  params: SystemParams,
-  lucid: LucidEvolution,
-  stakingManagerRef?: OutRef,
-): Promise<TxBuilder> {
-  const [pkh, _] = await addrDetails(lucid);
-
-  const stakingManagerOut = stakingManagerRef
-    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
-    : await findStakingManager(params, lucid);
-
-  const stakingRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef),
-    ]),
-    (_) => new Error('Expected a single staking Ref Script UTXO'),
-  );
-  const stakingTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        params.scriptReferences.authTokenPolicies.stakingTokenRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single staking token policy Ref Script UTXO'),
-  );
-
-  const newStakingManagerDatum: StakingManager = {
-    totalStake: stakingManagerOut.datum.totalStake + amount,
-    managerSnapshot: {
-      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
-    },
-  };
-
-  const stakingPositionDatum: StakingPosition = {
-    owner: fromHex(pkh.hash),
-    lockedAmount: [],
-    positionSnapshot: {
-      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
-    },
-  };
-
-  const stakingToken =
-    params.stakingParams.stakingToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.stakingToken[1].unTokenName);
-  const indyToken =
-    params.stakingParams.indyToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.indyToken[1].unTokenName);
-  return lucid
-    .newTx()
-    .collectFrom(
-      [stakingManagerOut.utxo],
-      serialiseStakingRedeemer({
-        CreateStakingPosition: { creatorPkh: fromHex(pkh.hash) },
-      }),
-    )
-    .readFrom([stakingRefScriptUtxo])
-    .pay.ToContract(
-      stakingManagerOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum(newStakingManagerDatum),
-      },
-      stakingManagerOut.utxo.assets,
-    )
-    .readFrom([stakingTokenPolicyRefScriptUtxo])
-    .mintAssets(
-      {
-        [stakingToken]: 1n,
-      },
-      Data.void(),
-    )
-    .pay.ToContract(
-      stakingManagerOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum(stakingPositionDatum),
-      },
-      {
-        [stakingToken]: 1n,
-        [indyToken]: amount,
-      },
-    )
-    .addSignerKey(pkh.hash);
-}
-
-export async function adjustStakingPosition(
-  stakingPositionRef: OutRef,
-  amount: bigint,
-  params: SystemParams,
-  lucid: LucidEvolution,
-  stakingManagerRef?: OutRef,
-): Promise<TxBuilder> {
-  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const stakingPositionOut = await findStakingPositionByOutRef(
-    stakingPositionRef,
-    lucid,
-  );
-  const stakingManagerOut = stakingManagerRef
-    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
-    : await findStakingManager(params, lucid);
-
-  const stakingRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef),
-    ]),
-    (_) => new Error('Expected a single staking Ref Script UTXO'),
-  );
-
-  const indyToken = fromSystemParamsAsset(params.stakingParams.indyToken);
-
-  const adaReward = calculateAdaReward(
-    stakingManagerOut.datum.managerSnapshot.snapshotAda,
-    stakingPositionOut.datum.positionSnapshot.snapshotAda,
-    assetClassValueOf(stakingPositionOut.utxo.assets, indyToken),
-  );
-
-  const newLockedAmount = updateStakingLockedAmount(
-    stakingPositionOut.datum.lockedAmount,
-    BigInt(now),
-  );
-
-  return lucid
-    .newTx()
-    .validFrom(Number(now))
-    .readFrom([stakingRefScriptUtxo])
-    .collectFrom(
-      [stakingPositionOut.utxo],
-      serialiseStakingRedeemer({
-        AdjustStakedAmount: { adjustAmount: amount },
-      }),
-    )
-    .collectFrom(
-      [stakingManagerOut.utxo],
-      serialiseStakingRedeemer('UpdateTotalStake'),
-    )
-    .pay.ToContract(
-      stakingManagerOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingManagerOut.datum,
-          totalStake: stakingManagerOut.datum.totalStake + amount,
-        }),
-      },
-      addAssets(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward)),
-    )
-    .pay.ToContract(
-      stakingPositionOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingPositionOut.datum,
-          positionSnapshot: {
-            snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
-          },
-          lockedAmount: newLockedAmount,
-        }),
-      },
-      addAssets(stakingPositionOut.utxo.assets, mkAssetsOf(indyToken, amount)),
-    )
-    .addSignerKey(toHex(stakingPositionOut.datum.owner));
-}
-
-export async function closeStakingPosition(
-  stakingPositionRef: OutRef,
-  params: SystemParams,
-  lucid: LucidEvolution,
-  stakingManagerRef?: OutRef,
-): Promise<TxBuilder> {
-  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const stakingPositionOut = await findStakingPositionByOutRef(
-    stakingPositionRef,
-    lucid,
-  );
-  const stakingManagerOut = stakingManagerRef
-    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
-    : await findStakingManager(params, lucid);
-
-  const stakingRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef),
-    ]),
-    (_) => new Error('Expected a single staking Ref Script UTXO'),
-  );
-  const stakingTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        params.scriptReferences.authTokenPolicies.stakingTokenRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single staking token policy Ref Script UTXO'),
-  );
-
-  const indyToken = fromSystemParamsAsset(params.stakingParams.indyToken);
-
-  const existingIndyAmount = assetClassValueOf(
-    stakingPositionOut.utxo.assets,
-    indyToken,
-  );
-  const adaReward = calculateAdaReward(
-    stakingManagerOut.datum.managerSnapshot.snapshotAda,
-    stakingPositionOut.datum.positionSnapshot.snapshotAda,
-    assetClassValueOf(stakingPositionOut.utxo.assets, indyToken),
-  );
-
-  return lucid
-    .newTx()
-    .validFrom(Number(now))
-    .readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo])
-    .collectFrom([stakingPositionOut.utxo], serialiseStakingRedeemer('Unstake'))
-    .collectFrom(
-      [stakingManagerOut.utxo],
-      serialiseStakingRedeemer('UpdateTotalStake'),
-    )
-    .pay.ToContract(
-      stakingManagerOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingManagerOut.datum,
-          totalStake: stakingManagerOut.datum.totalStake - existingIndyAmount,
-        }),
-      },
-      addAssets(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward)),
-    )
-    .mintAssets(
-      mkAssetsOf(fromSystemParamsAsset(params.stakingParams.stakingToken), -1n),
-      Data.void(),
-    )
-    .addSignerKey(toHex(stakingPositionOut.datum.owner));
-}
-
-const MIN_UTXO_AMOUNT = 2_000_000n;
-
-export async function distributeAda(
-  stakingManagerRef: OutRef,
-  collectorRefs: OutRef[],
-  params: SystemParams,
-  lucid: LucidEvolution,
-): Promise<TxBuilder> {
-  const [stakingManagerUtxo] = await lucid.utxosByOutRef([stakingManagerRef]);
-  const stakingManagerDatum = parseStakingManagerDatum(
-    getInlineDatumOrThrow(stakingManagerUtxo),
-  );
-  const collectorUtxos = (await lucid.utxosByOutRef(collectorRefs))
-    .filter((utxo) => utxo.datum && utxo.datum === Data.void())
-    .filter((utxo) => utxo.assets['lovelace'] > MIN_UTXO_AMOUNT);
-
-  if (collectorUtxos.length === 0) {
-    throw new Error('No available collectors found');
-  }
-
-  const adaRewardCollected = collectorUtxos.reduce(
-    (acc, utxo) => acc + utxo.assets['lovelace'] - MIN_UTXO_AMOUNT,
-    0n,
-  );
-  const newSnapshot = distributeReward(
-    stakingManagerDatum.managerSnapshot.snapshotAda,
-    adaRewardCollected,
-    stakingManagerDatum.totalStake,
-  );
-
-  const stakingRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef),
-    ]),
-    (_) => new Error('Expected a single staking Ref Script UTXO'),
-  );
-
-  const collectorRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(params.scriptReferences.collectorValidatorRef),
-    ]),
-    (_) => new Error('Expected a single staking Ref Script UTXO'),
-  );
-
-  const tx = lucid
-    .newTx()
-    .readFrom([stakingRefScriptUtxo, collectorRefScriptUtxo])
-    .collectFrom([stakingManagerUtxo], serialiseStakingRedeemer('Distribute'))
-    .collectFrom(
-      collectorUtxos,
-      serialiseCollectorRedeemer('DistributeToStakers'),
-    )
-    .pay.ToContract(
-      stakingManagerUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingManagerDatum,
-          managerSnapshot: { snapshotAda: newSnapshot },
-        }),
-      },
-      addAssets(stakingManagerUtxo.assets, mkLovelacesOf(adaRewardCollected)),
-    );
-
-  for (const collectorUtxo of collectorUtxos) {
-    tx.pay.ToContract(
-      collectorUtxo.address,
-      { kind: 'inline', value: Data.void() },
-      mkLovelacesOf(MIN_UTXO_AMOUNT),
-    );
-  }
-
-  return tx;
-}

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

@@ -1,137 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-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 StakingPosLockedAmtSchema = TSchema.Array(
-  TSchema.Tuple([
-    TSchema.Integer,
-    TSchema.Struct({
-      voteAmt: TSchema.Integer,
-      votingEnd: TSchema.Integer,
-    }),
-  ]),
-);
-
-export type StakingPosLockedAmt = typeof StakingPosLockedAmtSchema.Type;
-
-const RewardSnapshotSchema = TSchema.Struct({
-  snapshotAda: TSchema.Integer,
-});
-
-const StakingPositionSchema = TSchema.Struct({
-  owner: TSchema.ByteArray,
-  lockedAmount: StakingPosLockedAmtSchema,
-  positionSnapshot: RewardSnapshotSchema,
-});
-export type StakingPosition = typeof StakingPositionSchema.Type;
-
-const StakingManagerSchema = TSchema.Struct({
-  totalStake: TSchema.Integer,
-  managerSnapshot: RewardSnapshotSchema,
-});
-export type StakingManager = typeof StakingManagerSchema.Type;
-
-const StakingDatumSchema = TSchema.Union(
-  StakingManagerSchema,
-  StakingPositionSchema,
-);
-type StakingDatum = typeof StakingDatumSchema.Type;
-
-const StakingRedeemerSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      CreateStakingPosition: TSchema.Struct(
-        { creatorPkh: TSchema.ByteArray },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('UpdateTotalStake', { flatInUnion: true }),
-  TSchema.Literal('Distribute', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      AdjustStakedAmount: TSchema.Struct(
-        { adjustAmount: TSchema.Integer },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('Unstake', { flatInUnion: true }),
-  TSchema.Literal('Lock', { flatInUnion: true }),
-  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-
-export type StakingRedeemer = typeof StakingRedeemerSchema.Type;
-
-export function serialiseStakingRedeemer(r: StakingRedeemer): string {
-  return Data.withSchema(
-    StakingRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}
-
-export function parseStakingRedeemer(datum: string): O.Option<StakingRedeemer> {
-  try {
-    return O.some(
-      Data.withSchema(
-        StakingRedeemerSchema,
-        DEFAULT_SCHEMA_OPTIONS,
-      ).fromCBORHex(datum),
-    );
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseStakingRedeemerOrThrow(datum: string): StakingRedeemer {
-  return F.pipe(
-    parseStakingRedeemer(datum),
-    O.match(() => {
-      throw new Error('Expected a StakingRedeemer datum.');
-    }, F.identity),
-  );
-}
-
-export function parseStakingPosition(datum: string): O.Option<StakingPosition> {
-  try {
-    return match(
-      Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    )
-      .with({ owner: P.any }, (res) => O.some(res))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseStakingPositionOrThrow(datum: string): StakingPosition {
-  return F.pipe(
-    parseStakingPosition(datum),
-    O.match(() => {
-      throw new Error('Expected a StakingPosition datum.');
-    }, F.identity),
-  );
-}
-
-export function parseStakingManagerDatum(datum: string): StakingManager {
-  return match(
-    Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-      datum,
-    ),
-  )
-    .with({ totalStake: P.any }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a StakingPosition datum.');
-    });
-}
-
-export function serialiseStakingDatum(d: StakingDatum): string {
-  return Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
-    d,
-  );
-}

package/src/contracts/staking/types.ts

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

package/src/contracts/treasury/helpers.ts

@@ -1,21 +0,0 @@
-import { Address, LucidEvolution } from '@lucid-evolution/lucid';
-import {
-  fromSysParamsCredential,
-  SystemParams,
-} from '../../types/system-params';
-import { createScriptAddress } from '../../utils/lucid-utils';
-
-export function mkTreasuryAddr(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Address {
-  return createScriptAddress(
-    lucid.config().network!,
-    sysParams.validatorHashes.treasuryHash,
-    sysParams.treasuryParams.treasuryUtxosStakeCredential != null
-      ? fromSysParamsCredential(
-          sysParams.treasuryParams.treasuryUtxosStakeCredential,
-        )
-      : undefined,
-  );
-}