@indigo-labs/indigo-sdk 0.3.7 → 0.3.9

package/dist/index.js

@@ -245,6 +245,10 @@ __export(index_exports, {
   parseIAssetDatumOrThrow: () => parseIAssetDatumOrThrow,
   parseInterestCollectionDatum: () => parseInterestCollectionDatum,
   parseInterestOracleDatum: () => parseInterestOracleDatum,
+  parsePollManager: () => parsePollManager,
+  parsePollManagerOrThrow: () => parsePollManagerOrThrow,
+  parsePollShard: () => parsePollShard,
+  parsePollShardOrThrow: () => parsePollShardOrThrow,
   parsePriceOracleDatum: () => parsePriceOracleDatum,
   parsePythStateDatum: () => parsePythStateDatum,
   parseRobDatum: () => parseRobDatum,
@@ -265,6 +269,7 @@ __export(index_exports, {
   parseStakingPosition: () => parseStakingPosition,
   parseStakingPositionOrThrow: () => parseStakingPositionOrThrow,
   partitionEpochToScaleToSums: () => partitionEpochToScaleToSums,
+  pollPassQuorum: () => pollPassQuorum,
   processSpRequest: () => processSpRequest,
   rationalAdd: () => rationalAdd,
   rationalCeil: () => rationalCeil,
@@ -301,6 +306,9 @@ __export(index_exports, {
   serialiseInterestCollectionDatum: () => serialiseInterestCollectionDatum,
   serialiseInterestCollectionRedeemer: () => serialiseInterestCollectionRedeemer,
   serialiseInterestOracleDatum: () => serialiseInterestOracleDatum,
+  serialisePollDatum: () => serialisePollDatum,
+  serialisePollManagerRedeemer: () => serialisePollManagerRedeemer,
+  serialisePollShardRedeemer: () => serialisePollShardRedeemer,
   serialisePriceOracleDatum: () => serialisePriceOracleDatum,
   serialisePriceOracleRedeemer: () => serialisePriceOracleRedeemer,
   serialisePythFeedParams: () => serialisePythFeedParams,
@@ -5363,25 +5371,185 @@ var mkPollShardValidatorFromSP = (params) => {
   };
 };
 
+// src/contracts/poll/types-poll-new.ts
+var import_evolution15 = require("@evolution-sdk/evolution");
+var import_cardano_offchain_common14 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_fp_ts13 = require("fp-ts");
+var import_ts_pattern15 = require("ts-pattern");
+var PollStatusSchema = import_evolution15.TSchema.Struct({
+  yesVotes: import_evolution15.TSchema.Integer,
+  noVotes: import_evolution15.TSchema.Integer
+});
+var PollManagerContentSchema = import_evolution15.TSchema.Struct({
+  pollId: import_evolution15.TSchema.Integer,
+  pollOwner: import_evolution15.TSchema.ByteArray,
+  content: ProposalContentSchema,
+  treasuryWithdrawal: import_evolution15.TSchema.NullOr(TreasuryWithdrawalSchema),
+  status: PollStatusSchema,
+  votingEndTime: import_evolution15.TSchema.Integer,
+  createdShardsCount: import_evolution15.TSchema.Integer,
+  talliedShardsCount: import_evolution15.TSchema.Integer,
+  totalShardsCount: import_evolution15.TSchema.Integer,
+  proposingEndTime: import_evolution15.TSchema.Integer,
+  expirationTime: import_evolution15.TSchema.Integer,
+  protocolVersion: import_evolution15.TSchema.Integer,
+  minimumQuorum: import_evolution15.TSchema.Integer
+});
+var PollShardContentSchema = import_evolution15.TSchema.Struct({
+  pollId: import_evolution15.TSchema.Integer,
+  status: PollStatusSchema,
+  votingEndTime: import_evolution15.TSchema.Integer,
+  managerAddress: import_cardano_offchain_common14.AddressSchema
+});
+var PollDatumSchema = import_evolution15.TSchema.Union(
+  import_evolution15.TSchema.Struct(
+    {
+      PollManager: PollManagerContentSchema
+    },
+    { flatInUnion: true }
+  ),
+  import_evolution15.TSchema.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
+);
+var VoteOptionSchema = import_evolution15.TSchema.Union(
+  import_evolution15.TSchema.Literal("Yes", { flatInUnion: true }),
+  import_evolution15.TSchema.Literal("No", { flatInUnion: true })
+);
+var PollShardRedeemerSchema = import_evolution15.TSchema.Union(
+  import_evolution15.TSchema.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
+  import_evolution15.TSchema.Struct(
+    {
+      MergeShards: import_evolution15.TSchema.Struct(
+        {
+          currentTime: import_evolution15.TSchema.Integer,
+          pollManagerRef: import_cardano_offchain_common14.OutputReferenceSchema
+        },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+var PollManagerRedeemerSchema = import_evolution15.TSchema.Union(
+  import_evolution15.TSchema.Struct(
+    {
+      EndPoll: import_evolution15.TSchema.Struct(
+        { currentTime: import_evolution15.TSchema.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  import_evolution15.TSchema.Struct(
+    {
+      CreateShards: import_evolution15.TSchema.Struct(
+        { currentTime: import_evolution15.TSchema.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  import_evolution15.TSchema.Struct(
+    {
+      MergeShardsManager: import_evolution15.TSchema.Struct(
+        { currentTime: import_evolution15.TSchema.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+function serialisePollManagerRedeemer(r) {
+  return import_evolution15.Data.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
+}
+function serialisePollShardRedeemer(r) {
+  return import_evolution15.Data.withSchema(PollShardRedeemerSchema).toCBORHex(r);
+}
+function parsePollManager(datum) {
+  try {
+    return (0, import_ts_pattern15.match)(
+      import_evolution15.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollManager: import_ts_pattern15.P.select() }, (res) => import_fp_ts13.option.some(res)).otherwise(() => import_fp_ts13.option.none);
+  } catch (_) {
+    return import_fp_ts13.option.none;
+  }
+}
+function parsePollManagerOrThrow(datum) {
+  return import_fp_ts13.function.pipe(
+    parsePollManager(datum),
+    import_fp_ts13.option.match(() => {
+      throw new Error("Expected a poll manager datum.");
+    }, import_fp_ts13.function.identity)
+  );
+}
+function parsePollShard(datum) {
+  try {
+    return (0, import_ts_pattern15.match)(
+      import_evolution15.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollShard: import_ts_pattern15.P.select() }, (res) => import_fp_ts13.option.some(res)).otherwise(() => import_fp_ts13.option.none);
+  } catch (_) {
+    return import_fp_ts13.option.none;
+  }
+}
+function parsePollShardOrThrow(datum) {
+  return import_fp_ts13.function.pipe(
+    parsePollShard(datum),
+    import_fp_ts13.option.match(() => {
+      throw new Error("Expected a poll shard datum.");
+    }, import_fp_ts13.function.identity)
+  );
+}
+function serialisePollDatum(d) {
+  return import_evolution15.Data.withSchema(PollDatumSchema).toCBORHex(d);
+}
+
+// src/contracts/poll/helpers.ts
+function q(pollStatus, e) {
+  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
+    return { getOnChainInt: 0n };
+  else {
+    const q2 = ocdDiv(
+      { getOnChainInt: pollStatus.yesVotes },
+      { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) }
+    ).getOnChainInt - ocdDiv(
+      { getOnChainInt: pollStatus.noVotes },
+      {
+        getOnChainInt: BigInt(
+          Math.floor(
+            Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes))
+          )
+        )
+      }
+    ).getOnChainInt;
+    return { getOnChainInt: BigInt(q2) };
+  }
+}
+function pollPassQuorum(pollStatus, electorate, minQuorum) {
+  return pollStatus.yesVotes + pollStatus.noVotes >= minQuorum && q(pollStatus, electorate).getOnChainInt > 50000n;
+}
+
 // src/contracts/collector/transactions.ts
 var import_lucid22 = require("@lucid-evolution/lucid");
 
 // src/contracts/collector/types-new.ts
-var import_evolution15 = require("@evolution-sdk/evolution");
-var CollectorRedeemerSchema = import_evolution15.TSchema.Union(
-  import_evolution15.TSchema.Literal("Collect", { flatInUnion: true }),
-  import_evolution15.TSchema.Literal("DistributeToStakers", { flatInUnion: true }),
-  import_evolution15.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
+var import_evolution16 = require("@evolution-sdk/evolution");
+var CollectorRedeemerSchema = import_evolution16.TSchema.Union(
+  import_evolution16.TSchema.Literal("Collect", { flatInUnion: true }),
+  import_evolution16.TSchema.Literal("DistributeToStakers", { flatInUnion: true }),
+  import_evolution16.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseCollectorRedeemer(r) {
-  return import_evolution15.Data.withSchema(
+  return import_evolution16.Data.withSchema(
     CollectorRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
 }
 
 // src/contracts/collector/transactions.ts
-var import_cardano_offchain_common14 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_cardano_offchain_common15 = require("@3rd-eye-labs/cardano-offchain-common");
 async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   const collectorUtxo = matchSingle(
     await lucid.utxosByOutRef([collectorOref]),
@@ -5396,7 +5564,7 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer("Collect")).pay.ToContract(
     collectorUtxo.address,
     { kind: "inline", value: import_lucid22.Data.void() },
-    (0, import_lucid22.addAssets)(collectorUtxo.assets, (0, import_cardano_offchain_common14.mkLovelacesOf)(fee))
+    (0, import_lucid22.addAssets)(collectorUtxo.assets, (0, import_cardano_offchain_common15.mkLovelacesOf)(fee))
   ).readFrom([collectorRefScriptUtxo]);
   return collectorRefScriptUtxo;
 }
@@ -5410,95 +5578,95 @@ var import_fp_ts15 = require("fp-ts");
 var import_ts_pattern17 = require("ts-pattern");
 
 // src/contracts/staking/types-new.ts
-var import_evolution16 = require("@evolution-sdk/evolution");
-var import_fp_ts13 = require("fp-ts");
-var import_ts_pattern15 = require("ts-pattern");
-var StakingPosLockedAmtSchema = import_evolution16.TSchema.Array(
-  import_evolution16.TSchema.Tuple([
-    import_evolution16.TSchema.Integer,
-    import_evolution16.TSchema.Struct({
-      voteAmt: import_evolution16.TSchema.Integer,
-      votingEnd: import_evolution16.TSchema.Integer
+var import_evolution17 = require("@evolution-sdk/evolution");
+var import_fp_ts14 = require("fp-ts");
+var import_ts_pattern16 = require("ts-pattern");
+var StakingPosLockedAmtSchema = import_evolution17.TSchema.Array(
+  import_evolution17.TSchema.Tuple([
+    import_evolution17.TSchema.Integer,
+    import_evolution17.TSchema.Struct({
+      voteAmt: import_evolution17.TSchema.Integer,
+      votingEnd: import_evolution17.TSchema.Integer
     })
   ])
 );
-var RewardSnapshotSchema = import_evolution16.TSchema.Struct({
-  snapshotAda: import_evolution16.TSchema.Integer
+var RewardSnapshotSchema = import_evolution17.TSchema.Struct({
+  snapshotAda: import_evolution17.TSchema.Integer
 });
-var StakingPositionSchema = import_evolution16.TSchema.Struct({
-  owner: import_evolution16.TSchema.ByteArray,
+var StakingPositionSchema = import_evolution17.TSchema.Struct({
+  owner: import_evolution17.TSchema.ByteArray,
   lockedAmount: StakingPosLockedAmtSchema,
   positionSnapshot: RewardSnapshotSchema
 });
-var StakingManagerSchema = import_evolution16.TSchema.Struct({
-  totalStake: import_evolution16.TSchema.Integer,
+var StakingManagerSchema = import_evolution17.TSchema.Struct({
+  totalStake: import_evolution17.TSchema.Integer,
   managerSnapshot: RewardSnapshotSchema
 });
-var StakingDatumSchema = import_evolution16.TSchema.Union(
+var StakingDatumSchema = import_evolution17.TSchema.Union(
   StakingManagerSchema,
   StakingPositionSchema
 );
-var StakingRedeemerSchema = import_evolution16.TSchema.Union(
-  import_evolution16.TSchema.Struct(
+var StakingRedeemerSchema = import_evolution17.TSchema.Union(
+  import_evolution17.TSchema.Struct(
     {
-      CreateStakingPosition: import_evolution16.TSchema.Struct(
-        { creatorPkh: import_evolution16.TSchema.ByteArray },
+      CreateStakingPosition: import_evolution17.TSchema.Struct(
+        { creatorPkh: import_evolution17.TSchema.ByteArray },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  import_evolution16.TSchema.Literal("UpdateTotalStake", { flatInUnion: true }),
-  import_evolution16.TSchema.Literal("Distribute", { flatInUnion: true }),
-  import_evolution16.TSchema.Struct(
+  import_evolution17.TSchema.Literal("UpdateTotalStake", { flatInUnion: true }),
+  import_evolution17.TSchema.Literal("Distribute", { flatInUnion: true }),
+  import_evolution17.TSchema.Struct(
     {
-      AdjustStakedAmount: import_evolution16.TSchema.Struct(
-        { adjustAmount: import_evolution16.TSchema.Integer },
+      AdjustStakedAmount: import_evolution17.TSchema.Struct(
+        { adjustAmount: import_evolution17.TSchema.Integer },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  import_evolution16.TSchema.Literal("Unstake", { flatInUnion: true }),
-  import_evolution16.TSchema.Literal("Lock", { flatInUnion: true }),
-  import_evolution16.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
+  import_evolution17.TSchema.Literal("Unstake", { flatInUnion: true }),
+  import_evolution17.TSchema.Literal("Lock", { flatInUnion: true }),
+  import_evolution17.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseStakingRedeemer(r) {
-  return import_evolution16.Data.withSchema(
+  return import_evolution17.Data.withSchema(
     StakingRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
 }
 function parseStakingPosition(datum) {
   try {
-    return (0, import_ts_pattern15.match)(
-      import_evolution16.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+    return (0, import_ts_pattern16.match)(
+      import_evolution17.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
         datum
       )
-    ).with({ owner: import_ts_pattern15.P.any }, (res) => import_fp_ts13.option.some(res)).otherwise(() => import_fp_ts13.option.none);
+    ).with({ owner: import_ts_pattern16.P.any }, (res) => import_fp_ts14.option.some(res)).otherwise(() => import_fp_ts14.option.none);
   } catch (_) {
-    return import_fp_ts13.option.none;
+    return import_fp_ts14.option.none;
   }
 }
 function parseStakingPositionOrThrow(datum) {
-  return import_fp_ts13.function.pipe(
+  return import_fp_ts14.function.pipe(
     parseStakingPosition(datum),
-    import_fp_ts13.option.match(() => {
+    import_fp_ts14.option.match(() => {
       throw new Error("Expected a StakingPosition datum.");
-    }, import_fp_ts13.function.identity)
+    }, import_fp_ts14.function.identity)
   );
 }
 function parseStakingManagerDatum(datum) {
-  return (0, import_ts_pattern15.match)(
-    import_evolution16.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+  return (0, import_ts_pattern16.match)(
+    import_evolution17.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
       datum
     )
-  ).with({ totalStake: import_ts_pattern15.P.any }, (res) => res).otherwise(() => {
+  ).with({ totalStake: import_ts_pattern16.P.any }, (res) => res).otherwise(() => {
     throw new Error("Expected a StakingPosition datum.");
   });
 }
 function serialiseStakingDatum(d) {
-  return import_evolution16.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
+  return import_evolution17.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
     d
   );
 }
@@ -5613,182 +5781,22 @@ function calculateAdaReward(currentSnapshotAda, oldSnapshotAda, existingIndyAmou
   return (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / rewardSnapshotPrecision;
 }
 
-// src/contracts/poll/helpers.ts
-function q(pollStatus, e) {
-  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
-    return { getOnChainInt: 0n };
-  else {
-    const q2 = ocdDiv(
-      { getOnChainInt: pollStatus.yesVotes },
-      { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) }
-    ).getOnChainInt - ocdDiv(
-      { getOnChainInt: pollStatus.noVotes },
-      {
-        getOnChainInt: BigInt(
-          Math.floor(
-            Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes))
-          )
-        )
-      }
-    ).getOnChainInt;
-    return { getOnChainInt: BigInt(q2) };
-  }
-}
-function pollPassQuorum(pollStatus, electorate, minQuorum) {
-  return pollStatus.yesVotes + pollStatus.noVotes >= minQuorum && q(pollStatus, electorate).getOnChainInt > 50000n;
-}
-
 // src/contracts/version-registry/types-new.ts
-var import_evolution17 = require("@evolution-sdk/evolution");
-var VersionRecordDatumSchema = import_evolution17.TSchema.Struct({
-  upgradeId: import_evolution17.TSchema.Integer,
+var import_evolution18 = require("@evolution-sdk/evolution");
+var VersionRecordDatumSchema = import_evolution18.TSchema.Struct({
+  upgradeId: import_evolution18.TSchema.Integer,
   /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: import_evolution17.TSchema.Array(
-    import_evolution17.TSchema.Tuple([import_evolution17.TSchema.ByteArray, import_evolution17.TSchema.ByteArray])
+  upgradePaths: import_evolution18.TSchema.Array(
+    import_evolution18.TSchema.Tuple([import_evolution18.TSchema.ByteArray, import_evolution18.TSchema.ByteArray])
   )
 });
 function serialiseVersionRecordDatum(d) {
-  return import_evolution17.Data.withSchema(
+  return import_evolution18.Data.withSchema(
     VersionRecordDatumSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(d);
 }
 
-// src/contracts/poll/types-poll-new.ts
-var import_evolution18 = require("@evolution-sdk/evolution");
-var import_cardano_offchain_common15 = require("@3rd-eye-labs/cardano-offchain-common");
-var import_fp_ts14 = require("fp-ts");
-var import_ts_pattern16 = require("ts-pattern");
-var PollStatusSchema = import_evolution18.TSchema.Struct({
-  yesVotes: import_evolution18.TSchema.Integer,
-  noVotes: import_evolution18.TSchema.Integer
-});
-var PollManagerContentSchema = import_evolution18.TSchema.Struct({
-  pollId: import_evolution18.TSchema.Integer,
-  pollOwner: import_evolution18.TSchema.ByteArray,
-  content: ProposalContentSchema,
-  treasuryWithdrawal: import_evolution18.TSchema.NullOr(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: import_evolution18.TSchema.Integer,
-  createdShardsCount: import_evolution18.TSchema.Integer,
-  talliedShardsCount: import_evolution18.TSchema.Integer,
-  totalShardsCount: import_evolution18.TSchema.Integer,
-  proposingEndTime: import_evolution18.TSchema.Integer,
-  expirationTime: import_evolution18.TSchema.Integer,
-  protocolVersion: import_evolution18.TSchema.Integer,
-  minimumQuorum: import_evolution18.TSchema.Integer
-});
-var PollShardContentSchema = import_evolution18.TSchema.Struct({
-  pollId: import_evolution18.TSchema.Integer,
-  status: PollStatusSchema,
-  votingEndTime: import_evolution18.TSchema.Integer,
-  managerAddress: import_cardano_offchain_common15.AddressSchema
-});
-var PollDatumSchema = import_evolution18.TSchema.Union(
-  import_evolution18.TSchema.Struct(
-    {
-      PollManager: PollManagerContentSchema
-    },
-    { flatInUnion: true }
-  ),
-  import_evolution18.TSchema.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
-);
-var VoteOptionSchema = import_evolution18.TSchema.Union(
-  import_evolution18.TSchema.Literal("Yes", { flatInUnion: true }),
-  import_evolution18.TSchema.Literal("No", { flatInUnion: true })
-);
-var PollShardRedeemerSchema = import_evolution18.TSchema.Union(
-  import_evolution18.TSchema.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
-  import_evolution18.TSchema.Struct(
-    {
-      MergeShards: import_evolution18.TSchema.Struct(
-        {
-          currentTime: import_evolution18.TSchema.Integer,
-          pollManagerRef: import_cardano_offchain_common15.OutputReferenceSchema
-        },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-var PollManagerRedeemerSchema = import_evolution18.TSchema.Union(
-  import_evolution18.TSchema.Struct(
-    {
-      EndPoll: import_evolution18.TSchema.Struct(
-        { currentTime: import_evolution18.TSchema.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  import_evolution18.TSchema.Struct(
-    {
-      CreateShards: import_evolution18.TSchema.Struct(
-        { currentTime: import_evolution18.TSchema.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  import_evolution18.TSchema.Struct(
-    {
-      MergeShardsManager: import_evolution18.TSchema.Struct(
-        { currentTime: import_evolution18.TSchema.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-function serialisePollManagerRedeemer(r) {
-  return import_evolution18.Data.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
-}
-function serialisePollShardRedeemer(r) {
-  return import_evolution18.Data.withSchema(PollShardRedeemerSchema).toCBORHex(r);
-}
-function parsePollManager(datum) {
-  try {
-    return (0, import_ts_pattern16.match)(
-      import_evolution18.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollManager: import_ts_pattern16.P.select() }, (res) => import_fp_ts14.option.some(res)).otherwise(() => import_fp_ts14.option.none);
-  } catch (_) {
-    return import_fp_ts14.option.none;
-  }
-}
-function parsePollManagerOrThrow(datum) {
-  return import_fp_ts14.function.pipe(
-    parsePollManager(datum),
-    import_fp_ts14.option.match(() => {
-      throw new Error("Expected a poll manager datum.");
-    }, import_fp_ts14.function.identity)
-  );
-}
-function parsePollShard(datum) {
-  try {
-    return (0, import_ts_pattern16.match)(
-      import_evolution18.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollShard: import_ts_pattern16.P.select() }, (res) => import_fp_ts14.option.some(res)).otherwise(() => import_fp_ts14.option.none);
-  } catch (_) {
-    return import_fp_ts14.option.none;
-  }
-}
-function parsePollShardOrThrow(datum) {
-  return import_fp_ts14.function.pipe(
-    parsePollShard(datum),
-    import_fp_ts14.option.match(() => {
-      throw new Error("Expected a poll shard datum.");
-    }, import_fp_ts14.function.identity)
-  );
-}
-function serialisePollDatum(d) {
-  return import_evolution18.Data.withSchema(PollDatumSchema).toCBORHex(d);
-}
-
 // src/contracts/gov/transactions.ts
 var import_cardano_offchain_common17 = require("@3rd-eye-labs/cardano-offchain-common");
 async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
@@ -5906,7 +5914,9 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
           )
         )
       )
-    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).addSigner(ownAddr),
+    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(
+      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+    ).addSigner(ownAddr),
     newPollId
   ];
 }
@@ -5948,7 +5958,7 @@ async function createShardsChunks(chunkSize, pollManagerOref, sysParams, current
   );
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   const tx = lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
   ).mintAssets((0, import_cardano_offchain_common16.mkAssetsOf)(pollNft, shardsCount), import_lucid26.Data.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({ CreateShards: { currentTime } })
@@ -6128,7 +6138,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
   )(shardUtxos);
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   return lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
   ).readFrom([
     pollShardRefScriptUtxo,
     pollManagerRefScriptUtxo,
@@ -6915,7 +6925,9 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
     );
   }).otherwise(() => {
   });
-  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], import_lucid26.Data.void()).mintAssets(
+  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(
+    Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+  ).collectFrom([executeUtxo], import_lucid26.Data.void()).mintAssets(
     (0, import_cardano_offchain_common16.mkAssetsOf)(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
     import_lucid26.Data.void()
   ).addSigner(ownAddr).setMinFee(922932n);
@@ -10928,6 +10940,10 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   parseIAssetDatumOrThrow,
   parseInterestCollectionDatum,
   parseInterestOracleDatum,
+  parsePollManager,
+  parsePollManagerOrThrow,
+  parsePollShard,
+  parsePollShardOrThrow,
   parsePriceOracleDatum,
   parsePythStateDatum,
   parseRobDatum,
@@ -10948,6 +10964,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   parseStakingPosition,
   parseStakingPositionOrThrow,
   partitionEpochToScaleToSums,
+  pollPassQuorum,
   processSpRequest,
   rationalAdd,
   rationalCeil,
@@ -10984,6 +11001,9 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   serialiseInterestCollectionDatum,
   serialiseInterestCollectionRedeemer,
   serialiseInterestOracleDatum,
+  serialisePollDatum,
+  serialisePollManagerRedeemer,
+  serialisePollShardRedeemer,
   serialisePriceOracleDatum,
   serialisePriceOracleRedeemer,
   serialisePythFeedParams,