@indigo-labs/indigo-sdk 0.2.34 → 0.2.36

package/src/contracts/staking/helpers.ts

@@ -1,9 +1,4 @@
-import {
-  fromText,
-  OutRef,
-  UTxO,
-  validatorToScriptHash,
-} from '@lucid-evolution/lucid';
+import { fromText, UTxO, validatorToScriptHash } from '@lucid-evolution/lucid';
 import { LucidEvolution } from '@lucid-evolution/lucid';
 import { SystemParams } from '../../types/system-params';
 import {
@@ -13,7 +8,11 @@ import {
   StakingPosition,
   StakingPosLockedAmt,
 } from './types-new';
-import { createScriptAddress } from '../../utils/lucid-utils';
+import {
+  createScriptAddress,
+  resolveUtxo,
+  UtxoOrOutRef,
+} from '../../utils/lucid-utils';
 import { mkStakingValidatorFromSP } from './scripts';
 import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
 
@@ -37,28 +36,20 @@ export function updateStakingLockedAmount(
   );
 }
 
-export function findStakingManagerByOutRef(
-  stakingManagerRef: OutRef,
+export async function findStakingManagerByOutRef(
+  stakingManager: UtxoOrOutRef,
   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;
-    });
+  const utxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    'Unable to locate Staking Manager by output reference.',
+  );
+  if (!utxo.datum) {
+    throw new Error('Staking Manager UTxO has no datum.');
+  }
+  const datum = parseStakingManagerDatum(utxo.datum);
+  return { utxo, datum };
 }
 
 export function findStakingManager(
@@ -92,28 +83,20 @@ export function findStakingManager(
     });
 }
 
-export function findStakingPositionByOutRef(
-  stakingPositionRef: OutRef,
+export async function findStakingPositionByOutRef(
+  stakingPosition: UtxoOrOutRef,
   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;
-    });
+  const utxo = await resolveUtxo(
+    stakingPosition,
+    lucid,
+    'Unable to locate Staking Position by output reference.',
+  );
+  if (!utxo.datum) {
+    throw new Error('Staking Position UTxO has no datum.');
+  }
+  const datum = parseStakingPositionOrThrow(utxo.datum);
+  return { utxo, datum };
 }
 
 export const rewardSnapshotPrecision = OCD_DECIMAL_UNIT * OCD_DECIMAL_UNIT;

package/src/contracts/staking/transactions.ts

@@ -13,17 +13,20 @@ import {
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
-import { addrDetails, getInlineDatumOrThrow } from '../../utils/lucid-utils';
+import {
+  addrDetails,
+  getInlineDatumOrThrow,
+  resolveUtxo,
+  UtxoOrOutRef,
+} from '../../utils/lucid-utils';
 import {
   distributeReward,
-  findStakingManager,
-  findStakingManagerByOutRef,
-  findStakingPositionByOutRef,
   rewardSnapshotPrecision,
   updateStakingLockedAmount,
 } from './helpers';
 import {
   parseStakingManagerDatum,
+  parseStakingPositionOrThrow,
   serialiseStakingDatum,
   StakingManager,
   StakingPosition,
@@ -38,13 +41,18 @@ export async function openStakingPosition(
   amount: bigint,
   params: SystemParams,
   lucid: LucidEvolution,
-  stakingManagerRef?: OutRef,
+  stakingManager: UtxoOrOutRef,
 ): Promise<TxBuilder> {
   const [pkh, _] = await addrDetails(lucid);
 
-  const stakingManagerOut = stakingManagerRef
-    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
-    : await findStakingManager(params, lucid);
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    'Expected a single staking manager UTXO',
+  );
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo),
+  );
 
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -62,9 +70,9 @@ export async function openStakingPosition(
   );
 
   const newStakingManagerDatum: StakingManager = {
-    totalStake: stakingManagerOut.datum.totalStake + amount,
+    totalStake: stakingManagerDatum.totalStake + amount,
     managerSnapshot: {
-      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
+      snapshotAda: stakingManagerDatum.managerSnapshot.snapshotAda,
     },
   };
 
@@ -72,7 +80,7 @@ export async function openStakingPosition(
     owner: fromHex(pkh.hash),
     lockedAmount: new Map([]),
     positionSnapshot: {
-      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
+      snapshotAda: stakingManagerDatum.managerSnapshot.snapshotAda,
     },
   };
 
@@ -85,19 +93,19 @@ export async function openStakingPosition(
   return lucid
     .newTx()
     .collectFrom(
-      [stakingManagerOut.utxo],
+      [stakingManagerUtxo],
       serialiseStakingRedeemer({
         CreateStakingPosition: { creatorPkh: pkh.hash },
       }),
     )
     .readFrom([stakingRefScriptUtxo])
     .pay.ToContract(
-      stakingManagerOut.utxo.address,
+      stakingManagerUtxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum(newStakingManagerDatum),
       },
-      stakingManagerOut.utxo.assets,
+      stakingManagerUtxo.assets,
     )
     .readFrom([stakingTokenPolicyRefScriptUtxo])
     .mintAssets(
@@ -107,7 +115,7 @@ export async function openStakingPosition(
       Data.void(),
     )
     .pay.ToContract(
-      stakingManagerOut.utxo.address,
+      stakingManagerUtxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum(stakingPositionDatum),
@@ -121,23 +129,33 @@ export async function openStakingPosition(
 }
 
 export async function adjustStakingPosition(
-  stakingPositionRef: OutRef,
+  stakingPosition: UtxoOrOutRef,
   amount: bigint,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
-  stakingManagerRef?: OutRef,
+  stakingManager: UtxoOrOutRef,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = slotToUnixTime(network, currentSlot) - 120 * ONE_SECOND;
 
-  const stakingPositionOut = await findStakingPositionByOutRef(
-    stakingPositionRef,
+  const stakingPositionUtxo = await resolveUtxo(
+    stakingPosition,
     lucid,
+    'Expected a single staking position UTXO',
+  );
+  const stakingPositionDatum = parseStakingPositionOrThrow(
+    getInlineDatumOrThrow(stakingPositionUtxo),
+  );
+
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    'Expected a single staking manager UTXO',
+  );
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo),
   );
-  const stakingManagerOut = stakingManagerRef
-    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
-    : await findStakingManager(params, lucid);
 
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -150,16 +168,15 @@ export async function adjustStakingPosition(
     params.stakingParams.indyToken[0].unCurrencySymbol +
     fromText(params.stakingParams.indyToken[1].unTokenName);
 
-  const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
-  const currentSnapshotAda =
-    stakingManagerOut.datum.managerSnapshot.snapshotAda;
-  const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
+  const existingIndyAmount = stakingPositionUtxo.assets[indyToken] ?? 0n;
+  const currentSnapshotAda = stakingManagerDatum.managerSnapshot.snapshotAda;
+  const oldSnapshotAda = stakingPositionDatum.positionSnapshot.snapshotAda;
   const adaReward =
     ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
     rewardSnapshotPrecision;
 
   const newLockedAmount = updateStakingLockedAmount(
-    stakingPositionOut.datum.lockedAmount,
+    stakingPositionDatum.lockedAmount,
     BigInt(currentTime),
   );
 
@@ -168,38 +185,38 @@ export async function adjustStakingPosition(
     .validFrom(currentTime)
     .readFrom([stakingRefScriptUtxo])
     .collectFrom(
-      [stakingPositionOut.utxo],
+      [stakingPositionUtxo],
       serialiseStakingRedeemer({
         AdjustStakedAmount: { adjustAmount: amount },
       }),
     )
     .collectFrom(
-      [stakingManagerOut.utxo],
+      [stakingManagerUtxo],
       serialiseStakingRedeemer('UpdateTotalStake'),
     )
     .pay.ToContract(
-      stakingManagerOut.utxo.address,
+      stakingManagerUtxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          ...stakingManagerOut.datum,
-          totalStake: stakingManagerOut.datum.totalStake + amount,
+          ...stakingManagerDatum,
+          totalStake: stakingManagerDatum.totalStake + amount,
         }),
       },
-      addAssets(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward)),
+      addAssets(stakingManagerUtxo.assets, mkLovelacesOf(-adaReward)),
     )
     .pay.ToContract(
-      stakingPositionOut.utxo.address,
+      stakingPositionUtxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          ...stakingPositionOut.datum,
+          ...stakingPositionDatum,
           lockedAmount: newLockedAmount,
-          positionSnapshot: stakingManagerOut.datum.managerSnapshot,
+          positionSnapshot: stakingManagerDatum.managerSnapshot,
         }),
       },
       addAssets(
-        stakingPositionOut.utxo.assets,
+        stakingPositionUtxo.assets,
         mkAssetsOf(
           {
             currencySymbol: params.stakingParams.indyToken[0].unCurrencySymbol,
@@ -209,26 +226,36 @@ export async function adjustStakingPosition(
         ),
       ),
     )
-    .addSignerKey(toHex(stakingPositionOut.datum.owner));
+    .addSignerKey(toHex(stakingPositionDatum.owner));
 }
 
 export async function closeStakingPosition(
-  stakingPositionRef: OutRef,
+  stakingPosition: UtxoOrOutRef,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
-  stakingManagerRef?: OutRef,
+  stakingManager: UtxoOrOutRef,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = slotToUnixTime(network, currentSlot) - ONE_SECOND;
 
-  const stakingPositionOut = await findStakingPositionByOutRef(
-    stakingPositionRef,
+  const stakingPositionUtxo = await resolveUtxo(
+    stakingPosition,
     lucid,
+    'Expected a single staking position UTXO',
+  );
+  const stakingPositionDatum = parseStakingPositionOrThrow(
+    getInlineDatumOrThrow(stakingPositionUtxo),
+  );
+
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    'Expected a single staking manager UTXO',
+  );
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo),
   );
-  const stakingManagerOut = stakingManagerRef
-    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
-    : await findStakingManager(params, lucid);
 
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -252,10 +279,9 @@ export async function closeStakingPosition(
     params.stakingParams.indyToken[0].unCurrencySymbol +
     fromText(params.stakingParams.indyToken[1].unTokenName);
 
-  const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
-  const currentSnapshotAda =
-    stakingManagerOut.datum.managerSnapshot.snapshotAda;
-  const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
+  const existingIndyAmount = stakingPositionUtxo.assets[indyToken] ?? 0n;
+  const currentSnapshotAda = stakingManagerDatum.managerSnapshot.snapshotAda;
+  const oldSnapshotAda = stakingPositionDatum.positionSnapshot.snapshotAda;
   const adaReward =
     ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
     (1000000n * 1000000n);
@@ -264,21 +290,21 @@ export async function closeStakingPosition(
     .newTx()
     .validFrom(currentTime)
     .readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo])
-    .collectFrom([stakingPositionOut.utxo], serialiseStakingRedeemer('Unstake'))
+    .collectFrom([stakingPositionUtxo], serialiseStakingRedeemer('Unstake'))
     .collectFrom(
-      [stakingManagerOut.utxo],
+      [stakingManagerUtxo],
       serialiseStakingRedeemer('UpdateTotalStake'),
     )
     .pay.ToContract(
-      stakingManagerOut.utxo.address,
+      stakingManagerUtxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          ...stakingManagerOut.datum,
-          totalStake: stakingManagerOut.datum.totalStake - existingIndyAmount,
+          ...stakingManagerDatum,
+          totalStake: stakingManagerDatum.totalStake - existingIndyAmount,
         }),
       },
-      addAssets(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward)),
+      addAssets(stakingManagerUtxo.assets, mkLovelacesOf(-adaReward)),
     )
     .mintAssets(
       {
@@ -286,21 +312,26 @@ export async function closeStakingPosition(
       },
       Data.void(),
     )
-    .addSignerKey(toHex(stakingPositionOut.datum.owner));
+    .addSignerKey(toHex(stakingPositionDatum.owner));
 }
 
 const MIN_UTXO_AMOUNT = 2_000_000n;
 
 export async function distributeAda(
-  stakingManagerRef: OutRef,
+  stakingManager: UtxoOrOutRef,
   collectorRefs: OutRef[],
   params: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
-  const [stakingManagerUtxo] = await lucid.utxosByOutRef([stakingManagerRef]);
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    'Expected a single staking manager UTXO',
+  );
   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);

package/src/contracts/treasury/transactions.ts

@@ -2,7 +2,6 @@ import {
   addAssets,
   Data,
   LucidEvolution,
-  OutRef,
   TxBuilder,
 } from '@lucid-evolution/lucid';
 import {
@@ -13,20 +12,25 @@ import {
 import { matchSingle } from '../../utils/utils';
 import { mkLovelacesOf } from '../../utils/value-helpers';
 import { serialiseTreasuryRedeemer } from './types';
-import { createScriptAddress } from '../../utils/lucid-utils';
+import {
+  createScriptAddress,
+  resolveUtxo,
+  UtxoOrOutRef,
+} from '../../utils/lucid-utils';
 
 export async function treasuryFeeTx(
   fee: bigint,
   lucid: LucidEvolution,
   sysParams: SystemParams,
   tx: TxBuilder,
-  treasuryOref: OutRef,
+  treasury: UtxoOrOutRef,
 ): Promise<void> {
   if (fee <= 0n) return;
 
-  const treasuryUtxo = matchSingle(
-    await lucid.utxosByOutRef([treasuryOref]),
-    (_) => new Error('Expected a single treasury UTXO'),
+  const treasuryUtxo = await resolveUtxo(
+    treasury,
+    lucid,
+    'Expected a single treasury UTXO',
   );
 
   const treasuryRefScriptUtxo = matchSingle(

package/src/contracts/vesting/helpers.ts

@@ -14,7 +14,7 @@ type VestingSchedule = {
   schedule: Schedule[];
 };
 
-const teamVestingSchedule: Schedule[] = [
+export const teamVestingSchedule: Schedule[] = [
   {
     vestedAtTime: 1669067100000n,
     unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
@@ -113,93 +113,43 @@ const teamVestingSchedule: Schedule[] = [
   },
 ];
 
-const spDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 14_000_000n * OCD_DECIMAL_UNIT,
+export const spDistributionSchedule: VestingSchedule = {
+  maxUnlockable: 2_013_760n * OCD_DECIMAL_UNIT,
   schedule: [
     {
       vestedAtTime: 1669931100000n,
       unlockAmt: 28_768n * OCD_DECIMAL_UNIT,
     },
-    {
-      vestedAtTime: 1701467100000n,
-      unlockAmt: 33_562n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1727387100000n,
-      unlockAmt: 33_561n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1733003100000n,
-      unlockAmt: 38_356n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1764539100000n,
-      unlockAmt: 43_150n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1796075100000n,
-      unlockAmt: 47_945n * OCD_DECIMAL_UNIT,
-    },
   ],
 };
 
-const liqDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 5_250_000n * OCD_DECIMAL_UNIT,
+export const liqDistributionSchedule: VestingSchedule = {
+  maxUnlockable: 316_470n * OCD_DECIMAL_UNIT,
   schedule: [
     {
       vestedAtTime: 1671659100000n,
       unlockAmt: 4_795n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1703195100000n,
-      unlockAmt: 9_590n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1728683100000n,
-      unlockAmt: 9_589n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1734731100000n,
-      unlockAmt: 14_383n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1766267100000n,
-      unlockAmt: 19_178n * OCD_DECIMAL_UNIT,
-    },
+    }
+  ],
+};
+
+export const spLpDistributionSchedule: VestingSchedule = {
+  maxUnlockable: 17_016_441n * OCD_DECIMAL_UNIT,
+  schedule: [
     {
-      vestedAtTime: 1797803100000n,
-      unlockAmt: 23_972n * OCD_DECIMAL_UNIT,
-    },
+      vestedAtTime: 1700171100000n,
+      unlockAmt: 33_563n * OCD_DECIMAL_UNIT,
+    }
   ],
 };
 
-const govDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 1_750_000n * OCD_DECIMAL_UNIT,
+export const govDistributionSchedule: VestingSchedule = {
+  maxUnlockable: 1_381_248n * OCD_DECIMAL_UNIT,
   schedule: [
     {
       vestedAtTime: 1670363100000n,
       unlockAmt: 2_398n * OCD_DECIMAL_UNIT,
     },
-    {
-      vestedAtTime: 1701899100000n,
-      unlockAmt: 3_596n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1733435100000n,
-      unlockAmt: 4_795n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1752443100000n,
-      unlockAmt: 4_794n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1764971100000n,
-      unlockAmt: 5_993n * OCD_DECIMAL_UNIT,
-    },
-    {
-      vestedAtTime: 1796507100000n,
-      unlockAmt: 7_191n * OCD_DECIMAL_UNIT,
-    },
   ],
 };
 
@@ -213,7 +163,7 @@ export function calculateTotalVestedTeam(currentTime: bigint): bigint {
   })(teamVestingSchedule);
 }
 
-function calculateVestedPerEpoch(
+export function calculateVestedPerEpoch(
   schedule: VestingSchedule,
   currentTime: bigint,
 ): bigint {
@@ -262,6 +212,7 @@ export function calculateTotalVestedRewards(currentTime: bigint): bigint {
   return (
     calculateVestedPerEpoch(spDistributionSchedule, currentTime) +
     calculateVestedPerEpoch(govDistributionSchedule, currentTime) +
-    calculateVestedPerEpoch(liqDistributionSchedule, currentTime)
+    calculateVestedPerEpoch(liqDistributionSchedule, currentTime) +
+    calculateVestedPerEpoch(spLpDistributionSchedule, currentTime)
   );
 }

package/src/utils/lucid-utils.ts

@@ -15,6 +15,39 @@ import {
   UTxO,
 } from '@lucid-evolution/lucid';
 import { ScriptReference } from '../types/system-params';
+import { matchSingle } from './utils';
+
+/**
+ * Union type accepting either a full UTxO or just an OutRef.
+ * When a full UTxO is provided, no network fetch is needed.
+ * When only an OutRef is provided, the UTxO will be fetched via utxosByOutRef.
+ */
+export type UtxoOrOutRef = UTxO | OutRef;
+
+/**
+ * Resolves a UTxOOrOutRef to a full UTxO.
+ * If the input is already a UTxO (has 'address' property), returns it directly.
+ * If the input is an OutRef, fetches the UTxO from the network.
+ *
+ * @param input - Either a full UTxO or an OutRef
+ * @param lucid - The LucidEvolution instance for network queries
+ * @param errorMsg - Custom error message if the UTxO cannot be found
+ * @returns The resolved UTxO
+ */
+export async function resolveUtxo(
+  input: UtxoOrOutRef,
+  lucid: LucidEvolution,
+  errorMsg: string = 'Expected a single UTXO',
+): Promise<UTxO> {
+  // UTxO has 'address' property, OutRef only has 'txHash' and 'outputIndex'
+  if ('address' in input) {
+    return input;
+  }
+  return matchSingle(
+    await lucid.utxosByOutRef([input]),
+    (_) => new Error(errorMsg),
+  );
+}
 
 /**
  * Returns the inline datum.