@indigo-labs/indigo-sdk 0.1.21 → 0.1.23

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

@@ -1,115 +0,0 @@
-import { Core as EvoCore } from '@evolution-sdk/evolution';
-import { Data } from '@lucid-evolution/lucid';
-import { OracleAssetNftSchema } from '../price-oracle/types';
-import { AssetClassSchema } from '../../types/generic';
-import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
-import { IAssetPriceInfoSchema } from '../cdp/types';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-export const ProtocolParamsSchema = Data.Object({
-  proposalDeposit: Data.Integer(),
-  votingPeriod: Data.Integer(),
-  effectiveDelay: Data.Integer(),
-  expirationPeriod: Data.Integer(),
-  collateralFeePercentage: OnChainDecimalSchema,
-  proposingPeriod: Data.Integer(),
-  /// Total numer of shards used for voting.
-  totalShards: Data.Integer(),
-  /// The minimum number of votes (yes + no votes) for a proposal to be possible to pass.
-  minimumQuorum: Data.Integer(),
-  /// Maximum amount of lovelaces that can be spent at once from the treasury.
-  maxTreasuryLovelaceSpend: Data.Integer(),
-  /// Maximum amount of INDY that can be spent at once from the treasury.
-  maxTreasuryIndySpend: Data.Integer(),
-});
-
-export type ProtocolParams = Data.Static<typeof ProtocolParamsSchema>;
-export const ProtocolParams = ProtocolParamsSchema as unknown as ProtocolParams;
-
-const ProposeAssetContentSchema = Data.Object({
-  asset: Data.Bytes(),
-  priceOracleNft: OracleAssetNftSchema,
-  interestOracleNft: AssetClassSchema,
-  redemptionRatioPercentage: OnChainDecimalSchema,
-  maintenanceRatioPercentage: OnChainDecimalSchema,
-  liquidationRatioPercentage: OnChainDecimalSchema,
-  debtMintingFeePercentage: OnChainDecimalSchema,
-  liquidationProcessingFeePercentage: OnChainDecimalSchema,
-  stabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
-  redemptionReimbursementPercentage: OnChainDecimalSchema,
-  redemptionProcessingFeePercentage: OnChainDecimalSchema,
-  interestCollectorPortionPercentage: OnChainDecimalSchema,
-});
-export type ProposeAssetContent = Data.Static<typeof ProposeAssetContentSchema>;
-
-export const ProposalContentSchema = Data.Enum([
-  Data.Object({
-    ProposeAsset: ProposeAssetContentSchema,
-  }),
-  Data.Object({
-    ModifyAsset: Data.Object({
-      asset: Data.Bytes(),
-      newAssetPriceInfo: IAssetPriceInfoSchema,
-      newInterestOracleNft: AssetClassSchema,
-      newRedemptionRatioPercentage: OnChainDecimalSchema,
-      newMaintenanceRatioPercentage: OnChainDecimalSchema,
-      newLiquidationRatioPercentage: OnChainDecimalSchema,
-      newDebtMintingFeePercentage: OnChainDecimalSchema,
-      newLiquidationProcessingFeePercentage: OnChainDecimalSchema,
-      newStabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
-      newRedemptionReimbursementPercentage: OnChainDecimalSchema,
-      newRedemptionProcessingFeePercentage: OnChainDecimalSchema,
-      newInterestCollectorPortionPercentage: OnChainDecimalSchema,
-    }),
-  }),
-  Data.Object({
-    ModifyProtocolParams: Data.Object({
-      newParams: ProtocolParamsSchema,
-    }),
-  }),
-  Data.Object({
-    UpgradeProtocol: Data.Object({
-      content:
-        // NOTICE: This is replaced by evolution-sdk encoding of `UpgradePathsSchema` defined in this file.
-        Data.Any(),
-    }),
-  }),
-  Data.Object({
-    TextProposal: Data.Object({
-      bytes: Data.Bytes(),
-    }),
-  }),
-]);
-export type ProposalContent = Data.Static<typeof ProposalContentSchema>;
-export const ProposalContent =
-  ProposalContentSchema as unknown as ProposalContent;
-
-const UpgradePathSchema = EvoCore.TSchema.Struct({
-  upgradeSymbol: EvoCore.TSchema.ByteArray,
-});
-
-const UpgradePathsSchema = EvoCore.TSchema.Struct({
-  upgradeId: EvoCore.TSchema.Integer,
-  /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: EvoCore.TSchema.Map(
-    EvoCore.TSchema.ByteArray,
-    UpgradePathSchema,
-  ),
-});
-export type UpgradePaths = typeof UpgradePathsSchema.Type;
-
-export function serialiseUpgradePaths(d: UpgradePaths): Data {
-  return Data.from(
-    EvoCore.Data.withSchema(
-      UpgradePathsSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).toCBORHex(d),
-  );
-}
-
-export function parseUpgradePaths(d: Data): UpgradePaths {
-  return EvoCore.Data.withSchema(
-    UpgradePathsSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).fromCBORHex(Data.to(d));
-}

package/src/contracts/gov/types.ts

@@ -1,89 +0,0 @@
-import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
-import { AddressSchema, AssetClassSchema } from '../../types/generic';
-import { option as O, function as F } from 'fp-ts';
-import { ProposalContentSchema, ProtocolParamsSchema } from './types-new';
-
-const GovDatumSchema = Data.Object({
-  currentProposal: Data.Integer(),
-  protocolParams: ProtocolParamsSchema,
-  currentVersion: Data.Integer(),
-  iassetsCount: Data.Integer(),
-  activeProposals: Data.Integer(),
-  treasuryIndyWithdrawnAmt: Data.Integer(),
-});
-export type GovDatum = Data.Static<typeof GovDatumSchema>;
-const GovDatum = GovDatumSchema as unknown as GovDatum;
-
-const GovParamsSchema = Data.Object({
-  govNFT: AssetClassSchema,
-  pollToken: AssetClassSchema,
-  upgradeToken: AssetClassSchema,
-  indyAsset: AssetClassSchema,
-  versionRecordToken: AssetClassSchema,
-  pollManagerValHash: Data.Bytes(),
-  gBiasTime: Data.Integer(),
-  daoIdentityToken: AssetClassSchema,
-  iAssetAuthToken: AssetClassSchema,
-});
-export type GovParams = Data.Static<typeof GovParamsSchema>;
-export const GovParams = GovParamsSchema as unknown as GovParams;
-
-const ValueWithdrawalItemSchema = Data.Tuple(
-  [Data.Bytes(), Data.Bytes(), Data.Integer()],
-  { hasConstr: true },
-);
-export type TreasuryWithdrawalItem = Data.Static<
-  typeof ValueWithdrawalItemSchema
->;
-
-export const TreasuryWithdrawalSchema = Data.Object({
-  destination: AddressSchema,
-  value: Data.Array(ValueWithdrawalItemSchema),
-});
-export type TreasuryWithdrawal = Data.Static<typeof TreasuryWithdrawalSchema>;
-
-const GovRedeemerSchema = Data.Enum([
-  Data.Object({
-    CreatePoll: Data.Object({
-      currentTime: Data.Integer(),
-      proposalOwner: Data.Bytes(),
-      content: ProposalContentSchema,
-      treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
-    }),
-  }),
-  Data.Object({ WitnessEndPoll: Data.Object({ currentTime: Data.Integer() }) }),
-  Data.Literal('UpgradeGov'),
-  Data.Literal('UpgradeVersion'),
-]);
-
-export type GovRedeemer = Data.Static<typeof GovRedeemerSchema>;
-export const GovRedeemer = GovRedeemerSchema as unknown as GovRedeemer;
-
-export function parseGovDatum(datum: Datum): O.Option<GovDatum> {
-  try {
-    return O.some(Data.from<GovDatum>(datum, GovDatum));
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseGovDatumOrThrow(datum: Datum): GovDatum {
-  return F.pipe(
-    parseGovDatum(datum),
-    O.match(() => {
-      throw new Error('Expected a Gov datum.');
-    }, F.identity),
-  );
-}
-
-export function serialiseGovDatum(d: GovDatum): Datum {
-  return Data.to<GovDatum>(d, GovDatum);
-}
-
-export function serialiseGovRedeemer(redeemer: GovRedeemer): Redeemer {
-  return Data.to<GovRedeemer>(redeemer, GovRedeemer);
-}
-
-export function castGovParams(params: GovParams): Data {
-  return Data.castTo(params, GovParams);
-}

package/src/contracts/interest-oracle/scripts.ts

@@ -1,18 +0,0 @@
-import { applyParamsToScript } from '@lucid-evolution/lucid';
-import { SpendingValidator } from '@lucid-evolution/lucid';
-import {
-  castInterestOracleParams,
-  InterestOracleParams,
-} from '../interest-oracle/types';
-import { _interestOracleValidator } from '../../validators/interest-oracle-validator';
-
-export function mkInterestOracleValidator(
-  params: InterestOracleParams,
-): SpendingValidator {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_interestOracleValidator.cborHex, [
-      castInterestOracleParams(params),
-    ]),
-  };
-}

package/src/contracts/interest-oracle/transactions.ts

@@ -1,149 +0,0 @@
-import {
-  fromText,
-  LucidEvolution,
-  OutRef,
-  toUnit,
-  TxBuilder,
-  UTxO,
-  validatorToAddress,
-} from '@lucid-evolution/lucid';
-import { AssetClass } from '../../types/generic';
-import {
-  InterestOracleParams,
-  parseInterestOracleDatum,
-  serialiseFeedInterestOracleRedeemer,
-  serialiseInterestOracleDatum,
-} from './types';
-import { oneShotMintTx } from '../one-shot/transactions';
-import { mkInterestOracleValidator } from './scripts';
-import { findInterestOracle } from '../../../tests/queries/interest-oracle-queries';
-import { ONE_SECOND } from '../../utils/time-helpers';
-import { calculateUnitaryInterestSinceOracleLastUpdated } from '../interest-oracle/helpers';
-import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
-
-export async function startInterestOracle(
-  initialUnitaryInterest: bigint,
-  initialInterestRate: bigint,
-  initialLastInterestUpdate: bigint,
-  oracleParams: InterestOracleParams,
-  lucid: LucidEvolution,
-  interestTokenName?: string,
-  withScriptRef: boolean = false,
-  refOutRef?: OutRef,
-): Promise<[TxBuilder, AssetClass]> {
-  const network = lucid.config().network!;
-
-  const tokenName = interestTokenName ?? 'INTEREST_ORACLE';
-  if (!refOutRef) {
-    refOutRef = (await lucid.wallet().getUtxos())[0];
-  }
-
-  const [tx, policyId] = await oneShotMintTx(lucid, {
-    referenceOutRef: {
-      txHash: refOutRef.txHash,
-      outputIdx: BigInt(refOutRef.outputIndex),
-    },
-    mintAmounts: [
-      {
-        tokenName: fromText(tokenName),
-        amount: 1n,
-      },
-    ],
-  });
-
-  const validator = mkInterestOracleValidator(oracleParams);
-
-  tx.pay.ToContract(
-    validatorToAddress(network, validator),
-    {
-      kind: 'inline',
-      value: serialiseInterestOracleDatum({
-        unitaryInterest: initialUnitaryInterest,
-        interestRate: {
-          getOnChainInt: initialInterestRate,
-        },
-        lastUpdated: initialLastInterestUpdate,
-      }),
-    },
-    {
-      lovelace: 2_500_000n,
-      [toUnit(policyId, fromText(tokenName))]: 1n,
-    },
-  );
-
-  if (withScriptRef) {
-    tx.pay.ToAddressWithData(
-      validatorToAddress(network, validator),
-      undefined,
-      undefined,
-      validator,
-    );
-  }
-
-  return [
-    tx,
-    {
-      currencySymbol: policyId,
-      tokenName: fromText(tokenName),
-    },
-  ];
-}
-
-export async function feedInterestOracle(
-  params: InterestOracleParams,
-  newInterestRate: bigint,
-  lucid: LucidEvolution,
-  assetClass?: AssetClass,
-  utxo?: UTxO,
-  scriptRef?: UTxO,
-): Promise<TxBuilder> {
-  if (!assetClass && !utxo)
-    throw new Error('Either interest oracle nft or utxo must be provided');
-  if (assetClass && !utxo) {
-    utxo = await findInterestOracle(lucid, assetClass);
-  }
-
-  const now = BigInt(Date.now());
-  const tx = lucid.newTx();
-  const datum = parseInterestOracleDatum(getInlineDatumOrThrow(utxo!));
-
-  if (scriptRef) {
-    tx.readFrom([scriptRef]);
-  } else {
-    tx.attach.Script(mkInterestOracleValidator(params));
-  }
-
-  tx.collectFrom(
-    [utxo!],
-    serialiseFeedInterestOracleRedeemer({
-      newInterestRate: {
-        getOnChainInt: newInterestRate,
-      },
-      currentTime: now,
-    }),
-  );
-
-  tx.pay.ToContract(
-    utxo!.address,
-    {
-      kind: 'inline',
-      value: serialiseInterestOracleDatum({
-        unitaryInterest:
-          datum.unitaryInterest +
-          calculateUnitaryInterestSinceOracleLastUpdated(now, datum),
-        interestRate: {
-          getOnChainInt: newInterestRate,
-        },
-        lastUpdated: now,
-      }),
-    },
-    utxo!.assets,
-  );
-
-  tx.validFrom(Number(now) - ONE_SECOND);
-  tx.validTo(Number(now + params.biasTime) - ONE_SECOND);
-
-  tx.addSignerKey(params.owner);
-
-  return tx;
-}

package/src/contracts/lrp/scripts.ts

@@ -1,27 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import { castLrpParams, LRPParams } from './types';
-import { fromSystemParamsAsset, LrpParamsSP } from '../../types/system-params';
-import { _lrpValidator } from '../../validators/lrp-validator';
-
-export const mkLrpValidator = (params: LRPParams): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_lrpValidator.cborHex, [castLrpParams(params)]),
-  };
-};
-
-export const mkLrpValidatorFromSP = (
-  params: LrpParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_lrpValidator.cborHex, [
-      castLrpParams({
-        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
-        iassetNft: fromSystemParamsAsset(params.iassetNft),
-        minRedemptionLovelacesAmt: BigInt(params.minRedemptionLovelacesAmt),
-        iassetPolicyId: params.iassetPolicyId.unCurrencySymbol,
-      }),
-    ]),
-  };
-};

package/src/contracts/poll/helpers.ts

@@ -1,55 +0,0 @@
-import {
-  calculateTotalVestedRewards,
-  calculateTotalVestedTeam,
-} from '../vesting/helpers';
-import { PollStatus } from './types-poll';
-import { ocdDiv, OnChainDecimal } from '../../types/on-chain-decimal';
-
-function q(
-  initialIndyDist: bigint,
-  pollStatus: PollStatus,
-  currentTime: bigint,
-  treasuryIndyWithdrawnAmt: bigint,
-): OnChainDecimal {
-  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
-    return { getOnChainInt: 0n };
-  else {
-    const e =
-      treasuryIndyWithdrawnAmt +
-      calculateTotalVestedRewards(currentTime) +
-      calculateTotalVestedTeam(currentTime) +
-      initialIndyDist;
-
-    const q =
-      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(q) };
-  }
-}
-
-export function pollPassQuorum(
-  initialIndyDist: bigint,
-  pollStatus: PollStatus,
-  currentTime: bigint,
-  minQuorum: bigint,
-  treasuryIndyWithdrawnAmt: bigint,
-): boolean {
-  return (
-    pollStatus.yesVotes + pollStatus.noVotes >= minQuorum &&
-    q(initialIndyDist, pollStatus, currentTime, treasuryIndyWithdrawnAmt)
-      .getOnChainInt > 50_000n
-  );
-}

package/src/contracts/poll/scripts.ts

@@ -1,72 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import {
-  castPollManagerParams,
-  PollManagerParams,
-} from '../poll/types-poll-manager';
-import {
-  PollManagerParamsSP,
-  PollShardParamsSP,
-  fromSystemParamsAsset,
-} from '../../types/system-params';
-import { castPollShardParams, PollShardParams } from './types-poll-shard';
-import { _pollManagerValidator } from '../../validators/poll-manager-validator';
-import { _pollShardValidator } from '../../validators/poll-shard-validator';
-
-export const mkPollManagerValidator = (
-  params: PollManagerParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_pollManagerValidator.cborHex, [
-      castPollManagerParams(params),
-    ]),
-  };
-};
-
-export const mkPollManagerValidatorFromSP = (
-  params: PollManagerParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_pollManagerValidator.cborHex, [
-      castPollManagerParams({
-        govNFT: fromSystemParamsAsset(params.govNFT),
-        pollToken: fromSystemParamsAsset(params.pollToken),
-        upgradeToken: fromSystemParamsAsset(params.upgradeToken),
-        indyAsset: fromSystemParamsAsset(params.indyAsset),
-        govExecuteValHash: params.govExecuteValHash,
-        pBiasTime: BigInt(params.pBiasTime),
-        shardValHash: params.shardsValHash,
-        treasuryValHash: params.treasuryValHash,
-        initialIndyDistribution: BigInt(params.initialIndyDistribution),
-      }),
-    ]),
-  };
-};
-
-export const mkPollShardValidator = (
-  params: PollShardParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_pollShardValidator.cborHex, [
-      castPollShardParams(params),
-    ]),
-  };
-};
-
-export const mkPollShardValidatorFromSP = (
-  params: PollShardParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_pollShardValidator.cborHex, [
-      castPollShardParams({
-        pollToken: fromSystemParamsAsset(params.pollToken),
-        stakingToken: fromSystemParamsAsset(params.stakingToken),
-        indyAsset: fromSystemParamsAsset(params.indyAsset),
-        stakingValHash: params.stakingValHash,
-      }),
-    ]),
-  };
-};

package/src/contracts/poll/types-poll-manager.ts

@@ -1,38 +0,0 @@
-import { Data, Redeemer } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const PollManagerParamsSchema = Data.Object({
-  govNFT: AssetClassSchema,
-  pollToken: AssetClassSchema,
-  upgradeToken: AssetClassSchema,
-  indyAsset: AssetClassSchema,
-  govExecuteValHash: Data.Bytes(),
-  pBiasTime: Data.Integer(),
-  shardValHash: Data.Bytes(),
-  treasuryValHash: Data.Bytes(),
-  initialIndyDistribution: Data.Integer(),
-});
-export type PollManagerParams = Data.Static<typeof PollManagerParamsSchema>;
-export const PollManagerParams =
-  PollManagerParamsSchema as unknown as PollManagerParams;
-
-const PollManagerRedeemerSchema = Data.Enum([
-  Data.Object({
-    EndPoll: Data.Object({ currentTime: Data.Integer() }),
-  }),
-  Data.Object({ CreateShards: Data.Object({ currentTime: Data.Integer() }) }),
-  Data.Object({
-    MergeShardsManager: Data.Object({ currentTime: Data.Integer() }),
-  }),
-]);
-export type PollManagerRedeemer = Data.Static<typeof PollManagerRedeemerSchema>;
-export const PollManagerRedeemer =
-  PollManagerRedeemerSchema as unknown as PollManagerRedeemer;
-
-export function serialisePollManagerRedeemer(r: PollManagerRedeemer): Redeemer {
-  return Data.to<PollManagerRedeemer>(r, PollManagerRedeemer);
-}
-
-export function castPollManagerParams(params: PollManagerParams): Data {
-  return Data.castTo(params, PollManagerParams);
-}

package/src/contracts/poll/types-poll-shard.ts

@@ -1,38 +0,0 @@
-import { Data, Redeemer } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
-
-const PollShardParamsSchema = Data.Object({
-  pollToken: AssetClassSchema,
-  stakingToken: AssetClassSchema,
-  indyAsset: AssetClassSchema,
-  stakingValHash: Data.Bytes(),
-});
-export type PollShardParams = Data.Static<typeof PollShardParamsSchema>;
-export const PollShardParams =
-  PollShardParamsSchema as unknown as PollShardParams;
-
-const VoteOptionSchema = Data.Enum([Data.Literal('Yes'), Data.Literal('No')]);
-export type VoteOption = Data.Static<typeof VoteOptionSchema>;
-
-const PollShardRedeemerSchema = Data.Enum([
-  Data.Object({ Vote: Data.Object({ content: VoteOptionSchema }) }),
-  Data.Object({
-    MergeShards: Data.Object({
-      currentTime: Data.Integer(),
-      pollManagerRef: OutputReferenceSchema,
-    }),
-  }),
-]);
-export type PollShardRedeemer = Data.Static<typeof PollShardRedeemerSchema>;
-export const PollShardRedeemer =
-  PollShardRedeemerSchema as unknown as PollShardRedeemer;
-
-export function serialisePollShardRedeemer(
-  redeemer: PollShardRedeemer,
-): Redeemer {
-  return Data.to<PollShardRedeemer>(redeemer, PollShardRedeemer);
-}
-
-export function castPollShardParams(params: PollShardParams): Data {
-  return Data.castTo(params, PollShardParams);
-}

package/src/contracts/poll/types-poll.ts

@@ -1,88 +0,0 @@
-import { Data, Datum } from '@lucid-evolution/lucid';
-import { TreasuryWithdrawalSchema } from '../gov/types';
-import { AddressSchema } from '../../types/generic';
-import { option as O, function as F } from 'fp-ts';
-import { match, P } from 'ts-pattern';
-import { ProposalContentSchema } from '../gov/types-new';
-
-const PollStatusSchema = Data.Object({
-  yesVotes: Data.Integer(),
-  noVotes: Data.Integer(),
-});
-export type PollStatus = Data.Static<typeof PollStatusSchema>;
-
-const PollManagerContentSchema = Data.Object({
-  pollId: Data.Integer(),
-  pollOwner: Data.Bytes(),
-  content: ProposalContentSchema,
-  treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: Data.Integer(),
-  createdShardsCount: Data.Integer(),
-  talliedShardsCount: Data.Integer(),
-  totalShardsCount: Data.Integer(),
-  proposingEndTime: Data.Integer(),
-  expirationTime: Data.Integer(),
-  protocolVersion: Data.Integer(),
-  minimumQuorum: Data.Integer(),
-});
-export type PollManagerContent = Data.Static<typeof PollManagerContentSchema>;
-
-const PollShardContentSchema = Data.Object({
-  pollId: Data.Integer(),
-  status: PollStatusSchema,
-  votingEndTime: Data.Integer(),
-  managerAddress: AddressSchema,
-});
-export type PollShardContent = Data.Static<typeof PollShardContentSchema>;
-
-const PollDatumSchema = Data.Enum([
-  Data.Object({
-    PollManager: Data.Object({ content: PollManagerContentSchema }),
-  }),
-  Data.Object({ PollShard: Data.Object({ content: PollShardContentSchema }) }),
-]);
-export type PollDatum = Data.Static<typeof PollDatumSchema>;
-export const PollDatum = PollDatumSchema as unknown as PollDatum;
-
-export function parsePollManager(datum: Datum): O.Option<PollManagerContent> {
-  try {
-    return match(Data.from<PollDatum>(datum, PollDatum))
-      .with({ PollManager: P.select() }, (res) => O.some(res.content))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollManagerOrThrow(datum: Datum): PollManagerContent {
-  return F.pipe(
-    parsePollManager(datum),
-    O.match(() => {
-      throw new Error('Expected a Poll manager datum.');
-    }, F.identity),
-  );
-}
-
-export function parsePollShard(datum: Datum): O.Option<PollShardContent> {
-  try {
-    return match(Data.from<PollDatum>(datum, PollDatum))
-      .with({ PollShard: P.select() }, (res) => O.some(res.content))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollShardOrThrow(datum: Datum): PollShardContent {
-  return F.pipe(
-    parsePollShard(datum),
-    O.match(() => {
-      throw new Error('Expected a Poll shard datum.');
-    }, F.identity),
-  );
-}
-
-export function serialisePollDatum(datum: PollDatum): Datum {
-  return Data.to<PollDatum>(datum, PollDatum);
-}