@indigo-labs/indigo-sdk 0.3.8 → 0.3.9

package/dist/index.mjs

@@ -5120,21 +5120,184 @@ var mkPollShardValidatorFromSP = (params) => {
   };
 };
 
+// src/contracts/poll/types-poll-new.ts
+import { TSchema as TSchema15, Data as Data25 } from "@evolution-sdk/evolution";
+import {
+  AddressSchema as AddressSchema3,
+  OutputReferenceSchema as OutputReferenceSchema5
+} from "@3rd-eye-labs/cardano-offchain-common";
+import { option as O10, function as F12 } from "fp-ts";
+import { match as match14, P as P14 } from "ts-pattern";
+var PollStatusSchema = TSchema15.Struct({
+  yesVotes: TSchema15.Integer,
+  noVotes: TSchema15.Integer
+});
+var PollManagerContentSchema = TSchema15.Struct({
+  pollId: TSchema15.Integer,
+  pollOwner: TSchema15.ByteArray,
+  content: ProposalContentSchema,
+  treasuryWithdrawal: TSchema15.NullOr(TreasuryWithdrawalSchema),
+  status: PollStatusSchema,
+  votingEndTime: TSchema15.Integer,
+  createdShardsCount: TSchema15.Integer,
+  talliedShardsCount: TSchema15.Integer,
+  totalShardsCount: TSchema15.Integer,
+  proposingEndTime: TSchema15.Integer,
+  expirationTime: TSchema15.Integer,
+  protocolVersion: TSchema15.Integer,
+  minimumQuorum: TSchema15.Integer
+});
+var PollShardContentSchema = TSchema15.Struct({
+  pollId: TSchema15.Integer,
+  status: PollStatusSchema,
+  votingEndTime: TSchema15.Integer,
+  managerAddress: AddressSchema3
+});
+var PollDatumSchema = TSchema15.Union(
+  TSchema15.Struct(
+    {
+      PollManager: PollManagerContentSchema
+    },
+    { flatInUnion: true }
+  ),
+  TSchema15.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
+);
+var VoteOptionSchema = TSchema15.Union(
+  TSchema15.Literal("Yes", { flatInUnion: true }),
+  TSchema15.Literal("No", { flatInUnion: true })
+);
+var PollShardRedeemerSchema = TSchema15.Union(
+  TSchema15.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
+  TSchema15.Struct(
+    {
+      MergeShards: TSchema15.Struct(
+        {
+          currentTime: TSchema15.Integer,
+          pollManagerRef: OutputReferenceSchema5
+        },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+var PollManagerRedeemerSchema = TSchema15.Union(
+  TSchema15.Struct(
+    {
+      EndPoll: TSchema15.Struct(
+        { currentTime: TSchema15.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  TSchema15.Struct(
+    {
+      CreateShards: TSchema15.Struct(
+        { currentTime: TSchema15.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  TSchema15.Struct(
+    {
+      MergeShardsManager: TSchema15.Struct(
+        { currentTime: TSchema15.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+function serialisePollManagerRedeemer(r) {
+  return Data25.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
+}
+function serialisePollShardRedeemer(r) {
+  return Data25.withSchema(PollShardRedeemerSchema).toCBORHex(r);
+}
+function parsePollManager(datum) {
+  try {
+    return match14(
+      Data25.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollManager: P14.select() }, (res) => O10.some(res)).otherwise(() => O10.none);
+  } catch (_) {
+    return O10.none;
+  }
+}
+function parsePollManagerOrThrow(datum) {
+  return F12.pipe(
+    parsePollManager(datum),
+    O10.match(() => {
+      throw new Error("Expected a poll manager datum.");
+    }, F12.identity)
+  );
+}
+function parsePollShard(datum) {
+  try {
+    return match14(
+      Data25.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollShard: P14.select() }, (res) => O10.some(res)).otherwise(() => O10.none);
+  } catch (_) {
+    return O10.none;
+  }
+}
+function parsePollShardOrThrow(datum) {
+  return F12.pipe(
+    parsePollShard(datum),
+    O10.match(() => {
+      throw new Error("Expected a poll shard datum.");
+    }, F12.identity)
+  );
+}
+function serialisePollDatum(d) {
+  return Data25.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
 import {
   addAssets as addAssets7,
-  Data as Data26
+  Data as Data27
 } from "@lucid-evolution/lucid";
 
 // src/contracts/collector/types-new.ts
-import { TSchema as TSchema15, Data as Data25 } from "@evolution-sdk/evolution";
-var CollectorRedeemerSchema = TSchema15.Union(
-  TSchema15.Literal("Collect", { flatInUnion: true }),
-  TSchema15.Literal("DistributeToStakers", { flatInUnion: true }),
-  TSchema15.Literal("UpgradeVersion", { flatInUnion: true })
+import { TSchema as TSchema16, Data as Data26 } from "@evolution-sdk/evolution";
+var CollectorRedeemerSchema = TSchema16.Union(
+  TSchema16.Literal("Collect", { flatInUnion: true }),
+  TSchema16.Literal("DistributeToStakers", { flatInUnion: true }),
+  TSchema16.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseCollectorRedeemer(r) {
-  return Data25.withSchema(
+  return Data26.withSchema(
     CollectorRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
@@ -5155,7 +5318,7 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   );
   tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer("Collect")).pay.ToContract(
     collectorUtxo.address,
-    { kind: "inline", value: Data26.void() },
+    { kind: "inline", value: Data27.void() },
     addAssets7(collectorUtxo.assets, mkLovelacesOf2(fee))
   ).readFrom([collectorRefScriptUtxo]);
   return collectorRefScriptUtxo;
@@ -5185,95 +5348,95 @@ import { array as A8, option as O12, function as F14 } from "fp-ts";
 import { match as match16, P as P16 } from "ts-pattern";
 
 // src/contracts/staking/types-new.ts
-import { TSchema as TSchema16, Data as Data27 } from "@evolution-sdk/evolution";
-import { option as O10, function as F12 } from "fp-ts";
-import { match as match14, P as P14 } from "ts-pattern";
-var StakingPosLockedAmtSchema = TSchema16.Array(
-  TSchema16.Tuple([
-    TSchema16.Integer,
-    TSchema16.Struct({
-      voteAmt: TSchema16.Integer,
-      votingEnd: TSchema16.Integer
+import { TSchema as TSchema17, Data as Data28 } from "@evolution-sdk/evolution";
+import { option as O11, function as F13 } from "fp-ts";
+import { match as match15, P as P15 } from "ts-pattern";
+var StakingPosLockedAmtSchema = TSchema17.Array(
+  TSchema17.Tuple([
+    TSchema17.Integer,
+    TSchema17.Struct({
+      voteAmt: TSchema17.Integer,
+      votingEnd: TSchema17.Integer
     })
   ])
 );
-var RewardSnapshotSchema = TSchema16.Struct({
-  snapshotAda: TSchema16.Integer
+var RewardSnapshotSchema = TSchema17.Struct({
+  snapshotAda: TSchema17.Integer
 });
-var StakingPositionSchema = TSchema16.Struct({
-  owner: TSchema16.ByteArray,
+var StakingPositionSchema = TSchema17.Struct({
+  owner: TSchema17.ByteArray,
   lockedAmount: StakingPosLockedAmtSchema,
   positionSnapshot: RewardSnapshotSchema
 });
-var StakingManagerSchema = TSchema16.Struct({
-  totalStake: TSchema16.Integer,
+var StakingManagerSchema = TSchema17.Struct({
+  totalStake: TSchema17.Integer,
   managerSnapshot: RewardSnapshotSchema
 });
-var StakingDatumSchema = TSchema16.Union(
+var StakingDatumSchema = TSchema17.Union(
   StakingManagerSchema,
   StakingPositionSchema
 );
-var StakingRedeemerSchema = TSchema16.Union(
-  TSchema16.Struct(
+var StakingRedeemerSchema = TSchema17.Union(
+  TSchema17.Struct(
     {
-      CreateStakingPosition: TSchema16.Struct(
-        { creatorPkh: TSchema16.ByteArray },
+      CreateStakingPosition: TSchema17.Struct(
+        { creatorPkh: TSchema17.ByteArray },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  TSchema16.Literal("UpdateTotalStake", { flatInUnion: true }),
-  TSchema16.Literal("Distribute", { flatInUnion: true }),
-  TSchema16.Struct(
+  TSchema17.Literal("UpdateTotalStake", { flatInUnion: true }),
+  TSchema17.Literal("Distribute", { flatInUnion: true }),
+  TSchema17.Struct(
     {
-      AdjustStakedAmount: TSchema16.Struct(
-        { adjustAmount: TSchema16.Integer },
+      AdjustStakedAmount: TSchema17.Struct(
+        { adjustAmount: TSchema17.Integer },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  TSchema16.Literal("Unstake", { flatInUnion: true }),
-  TSchema16.Literal("Lock", { flatInUnion: true }),
-  TSchema16.Literal("UpgradeVersion", { flatInUnion: true })
+  TSchema17.Literal("Unstake", { flatInUnion: true }),
+  TSchema17.Literal("Lock", { flatInUnion: true }),
+  TSchema17.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseStakingRedeemer(r) {
-  return Data27.withSchema(
+  return Data28.withSchema(
     StakingRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
 }
 function parseStakingPosition(datum) {
   try {
-    return match14(
-      Data27.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+    return match15(
+      Data28.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
         datum
       )
-    ).with({ owner: P14.any }, (res) => O10.some(res)).otherwise(() => O10.none);
+    ).with({ owner: P15.any }, (res) => O11.some(res)).otherwise(() => O11.none);
   } catch (_) {
-    return O10.none;
+    return O11.none;
   }
 }
 function parseStakingPositionOrThrow(datum) {
-  return F12.pipe(
+  return F13.pipe(
     parseStakingPosition(datum),
-    O10.match(() => {
+    O11.match(() => {
       throw new Error("Expected a StakingPosition datum.");
-    }, F12.identity)
+    }, F13.identity)
   );
 }
 function parseStakingManagerDatum(datum) {
-  return match14(
-    Data27.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+  return match15(
+    Data28.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
       datum
     )
-  ).with({ totalStake: P14.any }, (res) => res).otherwise(() => {
+  ).with({ totalStake: P15.any }, (res) => res).otherwise(() => {
     throw new Error("Expected a StakingPosition datum.");
   });
 }
 function serialiseStakingDatum(d) {
-  return Data27.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
+  return Data28.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
     d
   );
 }
@@ -5395,185 +5558,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
-import { TSchema as TSchema17, Data as Data28 } from "@evolution-sdk/evolution";
-var VersionRecordDatumSchema = TSchema17.Struct({
-  upgradeId: TSchema17.Integer,
+import { TSchema as TSchema18, Data as Data29 } from "@evolution-sdk/evolution";
+var VersionRecordDatumSchema = TSchema18.Struct({
+  upgradeId: TSchema18.Integer,
   /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: TSchema17.Array(
-    TSchema17.Tuple([TSchema17.ByteArray, TSchema17.ByteArray])
+  upgradePaths: TSchema18.Array(
+    TSchema18.Tuple([TSchema18.ByteArray, TSchema18.ByteArray])
   )
 });
 function serialiseVersionRecordDatum(d) {
-  return Data28.withSchema(
+  return Data29.withSchema(
     VersionRecordDatumSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(d);
 }
 
-// src/contracts/poll/types-poll-new.ts
-import { TSchema as TSchema18, Data as Data29 } from "@evolution-sdk/evolution";
-import {
-  AddressSchema as AddressSchema3,
-  OutputReferenceSchema as OutputReferenceSchema5
-} from "@3rd-eye-labs/cardano-offchain-common";
-import { option as O11, function as F13 } from "fp-ts";
-import { match as match15, P as P15 } from "ts-pattern";
-var PollStatusSchema = TSchema18.Struct({
-  yesVotes: TSchema18.Integer,
-  noVotes: TSchema18.Integer
-});
-var PollManagerContentSchema = TSchema18.Struct({
-  pollId: TSchema18.Integer,
-  pollOwner: TSchema18.ByteArray,
-  content: ProposalContentSchema,
-  treasuryWithdrawal: TSchema18.NullOr(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: TSchema18.Integer,
-  createdShardsCount: TSchema18.Integer,
-  talliedShardsCount: TSchema18.Integer,
-  totalShardsCount: TSchema18.Integer,
-  proposingEndTime: TSchema18.Integer,
-  expirationTime: TSchema18.Integer,
-  protocolVersion: TSchema18.Integer,
-  minimumQuorum: TSchema18.Integer
-});
-var PollShardContentSchema = TSchema18.Struct({
-  pollId: TSchema18.Integer,
-  status: PollStatusSchema,
-  votingEndTime: TSchema18.Integer,
-  managerAddress: AddressSchema3
-});
-var PollDatumSchema = TSchema18.Union(
-  TSchema18.Struct(
-    {
-      PollManager: PollManagerContentSchema
-    },
-    { flatInUnion: true }
-  ),
-  TSchema18.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
-);
-var VoteOptionSchema = TSchema18.Union(
-  TSchema18.Literal("Yes", { flatInUnion: true }),
-  TSchema18.Literal("No", { flatInUnion: true })
-);
-var PollShardRedeemerSchema = TSchema18.Union(
-  TSchema18.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
-  TSchema18.Struct(
-    {
-      MergeShards: TSchema18.Struct(
-        {
-          currentTime: TSchema18.Integer,
-          pollManagerRef: OutputReferenceSchema5
-        },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-var PollManagerRedeemerSchema = TSchema18.Union(
-  TSchema18.Struct(
-    {
-      EndPoll: TSchema18.Struct(
-        { currentTime: TSchema18.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  TSchema18.Struct(
-    {
-      CreateShards: TSchema18.Struct(
-        { currentTime: TSchema18.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  TSchema18.Struct(
-    {
-      MergeShardsManager: TSchema18.Struct(
-        { currentTime: TSchema18.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-function serialisePollManagerRedeemer(r) {
-  return Data29.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
-}
-function serialisePollShardRedeemer(r) {
-  return Data29.withSchema(PollShardRedeemerSchema).toCBORHex(r);
-}
-function parsePollManager(datum) {
-  try {
-    return match15(
-      Data29.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollManager: P15.select() }, (res) => O11.some(res)).otherwise(() => O11.none);
-  } catch (_) {
-    return O11.none;
-  }
-}
-function parsePollManagerOrThrow(datum) {
-  return F13.pipe(
-    parsePollManager(datum),
-    O11.match(() => {
-      throw new Error("Expected a poll manager datum.");
-    }, F13.identity)
-  );
-}
-function parsePollShard(datum) {
-  try {
-    return match15(
-      Data29.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollShard: P15.select() }, (res) => O11.some(res)).otherwise(() => O11.none);
-  } catch (_) {
-    return O11.none;
-  }
-}
-function parsePollShardOrThrow(datum) {
-  return F13.pipe(
-    parsePollShard(datum),
-    O11.match(() => {
-      throw new Error("Expected a poll shard datum.");
-    }, F13.identity)
-  );
-}
-function serialisePollDatum(d) {
-  return Data29.withSchema(PollDatumSchema).toCBORHex(d);
-}
-
 // src/contracts/gov/transactions.ts
 import {
   addressFromBech32,
@@ -5694,7 +5694,9 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
           )
         )
       )
-    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND).addSigner(ownAddr),
+    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(
+      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+    ).addSigner(ownAddr),
     newPollId
   ];
 }
@@ -6703,7 +6705,9 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
     );
   }).otherwise(() => {
   });
-  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], Data30.void()).mintAssets(
+  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(
+    Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+  ).collectFrom([executeUtxo], Data30.void()).mintAssets(
     mkAssetsOf6(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
     Data30.void()
   ).addSigner(ownAddr).setMinFee(922932n);
@@ -10882,6 +10886,10 @@ export {
   parseIAssetDatumOrThrow,
   parseInterestCollectionDatum,
   parseInterestOracleDatum,
+  parsePollManager,
+  parsePollManagerOrThrow,
+  parsePollShard,
+  parsePollShardOrThrow,
   parsePriceOracleDatum,
   parsePythStateDatum,
   parseRobDatum,
@@ -10902,6 +10910,7 @@ export {
   parseStakingPosition,
   parseStakingPositionOrThrow,
   partitionEpochToScaleToSums,
+  pollPassQuorum,
   processSpRequest,
   rationalAdd,
   rationalCeil,
@@ -10938,6 +10947,9 @@ export {
   serialiseInterestCollectionDatum,
   serialiseInterestCollectionRedeemer,
   serialiseInterestOracleDatum,
+  serialisePollDatum,
+  serialisePollManagerRedeemer,
+  serialisePollShardRedeemer,
   serialisePriceOracleDatum,
   serialisePriceOracleRedeemer,
   serialisePythFeedParams,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/contracts/gov/transactions.ts

@@ -252,7 +252,11 @@ export async function createProposal(
         ),
       )
       .validFrom(Number(currentTime) - ONE_SECOND)
-      .validTo(Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND)
+      .validTo(
+        Number(currentTime) +
+          Number(sysParams.govParams.gBiasTime) -
+          ONE_SECOND,
+      )
       .addSigner(ownAddr),
     newPollId,
   ];
@@ -321,7 +325,9 @@ export async function createShardsChunks(
     .newTx()
     .validFrom(Number(currentTime) - ONE_SECOND)
     .validTo(
-      Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
+      Number(currentTime) +
+        Number(sysParams.pollManagerParams.pBiasTime) -
+        ONE_SECOND,
     )
     .mintAssets(mkAssetsOf(pollNft, shardsCount), Data.void())
     // Ref scripts
@@ -574,7 +580,9 @@ export async function mergeShards(
     .newTx()
     .validFrom(Number(currentTime) - ONE_SECOND)
     .validTo(
-      Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
+      Number(currentTime) +
+        Number(sysParams.pollManagerParams.pBiasTime) -
+        ONE_SECOND,
     )
     .readFrom([
       pollShardRefScriptUtxo,
@@ -1553,7 +1561,9 @@ export async function executeProposal(
 
   tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo])
     .validFrom(Number(currentTime) - ONE_SECOND)
-    .validTo(Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND)
+    .validTo(
+      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND,
+    )
     .collectFrom([executeUtxo], Data.void())
     .mintAssets(
       mkAssetsOf(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),

package/src/index.ts

@@ -6,6 +6,8 @@ export * from './contracts/cdp/scripts';
 export * from './contracts/cdp-creator/types';
 export * from './contracts/cdp-creator/scripts';
 export * from './contracts/poll/scripts';
+export * from './contracts/poll/types-poll-new';
+export * from './contracts/poll/helpers';
 export * from './contracts/collector/transactions';
 export * from './contracts/collector/types-new';
 export * from './contracts/gov/transactions';