@indigo-labs/indigo-sdk 0.1.21 → 0.1.22

package/src/contracts/stability-pool/types-new.ts

@@ -1,208 +0,0 @@
-import { Core as EvoCore } from '@evolution-sdk/evolution';
-import { match, P } from 'ts-pattern';
-import { EvoCommon } from '@3rd-eye-labs/cardano-offchain-common';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-export const SPIntegerSchema = EvoCore.TSchema.Struct({
-  value: EvoCore.TSchema.Integer,
-});
-
-export type SPInteger = typeof SPIntegerSchema.Type;
-
-const AccountActionSchema = EvoCore.TSchema.Union(
-  EvoCore.TSchema.Literal('Create', { flatInUnion: true }),
-  EvoCore.TSchema.Struct(
-    {
-      Adjust: EvoCore.TSchema.Struct(
-        {
-          amount: EvoCore.TSchema.Integer,
-          outputAddress: EvoCommon.AddressSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  EvoCore.TSchema.Struct(
-    {
-      Close: EvoCore.TSchema.Struct(
-        { outputAddress: EvoCommon.AddressSchema },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-);
-
-export type AccountAction = typeof AccountActionSchema.Type;
-
-export const EpochToScaleToSumSchema = EvoCore.TSchema.Map(
-  EvoCore.TSchema.Struct({
-    epoch: EvoCore.TSchema.Integer,
-    scale: EvoCore.TSchema.Integer,
-  }),
-  SPIntegerSchema,
-);
-
-export type EpochToScaleToSum = typeof EpochToScaleToSumSchema.Type;
-
-const StabilityPoolSnapshotSchema = EvoCore.TSchema.Struct({
-  productVal: SPIntegerSchema,
-  depositVal: SPIntegerSchema,
-  sumVal: SPIntegerSchema,
-  epoch: EvoCore.TSchema.Integer,
-  scale: EvoCore.TSchema.Integer,
-});
-
-export type StabilityPoolSnapshot = typeof StabilityPoolSnapshotSchema.Type;
-
-export const StabilityPoolContentSchema = EvoCore.TSchema.Struct({
-  asset: EvoCore.TSchema.ByteArray,
-  poolSnapshot: StabilityPoolSnapshotSchema,
-  epochToScaleToSum: EpochToScaleToSumSchema,
-});
-
-export type StabilityPoolContent = typeof StabilityPoolContentSchema.Type;
-
-export const AccountContentSchema = EvoCore.TSchema.Struct({
-  owner: EvoCore.TSchema.ByteArray,
-  asset: EvoCore.TSchema.ByteArray,
-  accountSnapshot: StabilityPoolSnapshotSchema,
-  request: EvoCore.TSchema.NullOr(AccountActionSchema),
-});
-
-export type AccountContent = typeof AccountContentSchema.Type;
-
-export const SnapshotEpochToScaleToSumContentSchema = EvoCore.TSchema.Struct({
-  snapshot: EpochToScaleToSumSchema,
-  asset: EvoCore.TSchema.ByteArray,
-});
-
-export type SnapshotEpochToScaleToSumContent =
-  typeof SnapshotEpochToScaleToSumContentSchema.Type;
-
-export const StabilityPoolDatumSchema = EvoCore.TSchema.Union(
-  EvoCore.TSchema.Struct(
-    { StabilityPool: StabilityPoolContentSchema },
-    { flatInUnion: true },
-  ),
-  EvoCore.TSchema.Struct(
-    { Account: AccountContentSchema },
-    { flatInUnion: true },
-  ),
-  EvoCore.TSchema.Struct(
-    { SnapshotEpochToScaleToSum: SnapshotEpochToScaleToSumContentSchema },
-    { flatInUnion: true },
-  ),
-);
-
-export const StabilityPoolRedeemerSchema = EvoCore.TSchema.Union(
-  EvoCore.TSchema.Struct(
-    { RequestAction: AccountActionSchema },
-    { flatInUnion: true },
-  ),
-  EvoCore.TSchema.Struct(
-    {
-      ProcessRequest: EvoCore.TSchema.Struct({
-        txHash: EvoCore.TSchema.Struct({ hash: EvoCore.TSchema.ByteArray }),
-        outputIndex: EvoCore.TSchema.Integer,
-      }),
-    },
-    { flatInUnion: true },
-  ),
-  EvoCore.TSchema.Literal('AnnulRequest', { flatInUnion: true }),
-  EvoCore.TSchema.Literal('LiquidateCDP', { flatInUnion: true }),
-  EvoCore.TSchema.Literal('RecordEpochToScaleToSum', { flatInUnion: true }),
-  EvoCore.TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-
-export type StabilityPoolRedeemer = typeof StabilityPoolRedeemerSchema.Type;
-
-export function serialiseStabilityPoolRedeemer(
-  r: StabilityPoolRedeemer,
-): string {
-  return EvoCore.Data.withSchema(
-    StabilityPoolRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}
-
-export function serialiseStabilityPoolDatum(
-  d: typeof StabilityPoolDatumSchema.Type,
-  /**
-   * This is necessary to change only in case of execute propose asset.
-   */
-  useIndefiniteMaps: boolean = false,
-): string {
-  return EvoCore.Data.withSchema(StabilityPoolDatumSchema, {
-    ...DEFAULT_SCHEMA_OPTIONS,
-    useIndefiniteMaps: useIndefiniteMaps,
-  }).toCBORHex(d);
-}
-
-export function parseStabilityPoolDatum(datum: string): StabilityPoolContent {
-  return match(
-    EvoCore.Data.withSchema(
-      StabilityPoolDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
-  )
-    .with({ StabilityPool: P.select() }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a Stability Pool datum.');
-    });
-}
-
-export function parseAccountDatum(datum: string): AccountContent {
-  return match(
-    EvoCore.Data.withSchema(
-      StabilityPoolDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
-  )
-    .with({ Account: P.select() }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a Stability Pool datum.');
-    });
-}
-export function parseSnapshotEpochToScaleToSumDatum(
-  datum: string,
-): SnapshotEpochToScaleToSumContent {
-  return match(
-    EvoCore.Data.withSchema(
-      StabilityPoolDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
-  )
-    .with({ SnapshotEpochToScaleToSum: P.select() }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a Stability Pool datum.');
-    });
-}
-
-/** 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/contracts/stability-pool/types.ts

@@ -1,42 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
-
-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;
-
-/** 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);
-}

package/src/contracts/staking/helpers.ts

@@ -1,116 +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';
-
-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 new Map(
-    stakingPosLockedAmt
-      .entries()
-      .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;
-    });
-}

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: 'PlutusV2',
-    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,268 +0,0 @@
-import {
-  Constr,
-  Data,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  OutRef,
-  toHex,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../types/system-params';
-import { addrDetails } from '../../utils/lucid-utils';
-import {
-  findStakingManager,
-  findStakingManagerByOutRef,
-  findStakingPositionByOutRef,
-  updateStakingLockedAmount,
-} from './helpers';
-import {
-  serialiseStakingDatum,
-  StakingManager,
-  StakingPosition,
-} from './types-new';
-import { matchSingle } from '../../utils/utils';
-
-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: new Map([]),
-    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], Data.to(new Constr(0, [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 = Date.now();
-
-  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 stakingToken =
-    params.stakingParams.stakingToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.stakingToken[1].unTokenName);
-  const stakingManagerToken =
-    params.stakingParams.stakingManagerNFT[0].unCurrencySymbol +
-    fromText(params.stakingParams.stakingManagerNFT[1].unTokenName);
-  const indyToken =
-    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 adaReward =
-    ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
-    (1000000n * 1000000n);
-
-  const newLockedAmount = updateStakingLockedAmount(
-    stakingPositionOut.datum.lockedAmount,
-    BigInt(now),
-  );
-
-  return lucid
-    .newTx()
-    .validFrom(Date.now())
-    .readFrom([stakingRefScriptUtxo])
-    .collectFrom([stakingPositionOut.utxo], Data.to(new Constr(3, [amount])))
-    .collectFrom([stakingManagerOut.utxo], Data.to(new Constr(1, [])))
-    .pay.ToContract(
-      stakingManagerOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingManagerOut.datum,
-          totalStake: stakingManagerOut.datum.totalStake + amount,
-        }),
-      },
-      {
-        lovelace: stakingManagerOut.utxo.assets.lovelace - adaReward,
-        [stakingManagerToken]: 1n,
-      },
-    )
-    .pay.ToContract(
-      stakingPositionOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingPositionOut.datum,
-          lockedAmount: newLockedAmount,
-        }),
-      },
-      {
-        [stakingToken]: 1n,
-        [indyToken]: stakingPositionOut.utxo.assets[indyToken] + amount,
-      },
-    )
-    .addSignerKey(toHex(stakingPositionOut.datum.owner));
-}
-
-export async function closeStakingPosition(
-  stakingPositionRef: OutRef,
-  params: SystemParams,
-  lucid: LucidEvolution,
-  stakingManagerRef?: OutRef,
-): Promise<TxBuilder> {
-  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 stakingToken =
-    params.stakingParams.stakingToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.stakingToken[1].unTokenName);
-  const stakingManagerToken =
-    params.stakingParams.stakingManagerNFT[0].unCurrencySymbol +
-    fromText(params.stakingParams.stakingManagerNFT[1].unTokenName);
-  const indyToken =
-    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 adaReward =
-    ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
-    (1000000n * 1000000n);
-
-  return lucid
-    .newTx()
-    .validFrom(Date.now())
-    .readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo])
-    .collectFrom([stakingPositionOut.utxo], Data.to(new Constr(4, [])))
-    .collectFrom([stakingManagerOut.utxo], Data.to(new Constr(1, [])))
-    .pay.ToContract(
-      stakingManagerOut.utxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingManagerOut.datum,
-          totalStake: stakingManagerOut.datum.totalStake - existingIndyAmount,
-        }),
-      },
-      {
-        lovelace: stakingManagerOut.utxo.assets.lovelace - adaReward,
-        [stakingManagerToken]: 1n,
-      },
-    )
-    .mintAssets(
-      {
-        [stakingToken]: -1n,
-      },
-      Data.void(),
-    )
-    .addSignerKey(toHex(stakingPositionOut.datum.owner));
-}