@indigo-labs/indigo-sdk 0.1.19 → 0.1.20

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

@@ -0,0 +1,81 @@
+import { Core as EvoCore } from '@evolution-sdk/evolution';
+import { option as O, function as F } from 'fp-ts';
+import { match, P } from 'ts-pattern';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+
+const StakingPosLockedAmtSchema = EvoCore.TSchema.Map(
+  EvoCore.TSchema.Integer,
+  EvoCore.TSchema.Struct({
+    voteAmt: EvoCore.TSchema.Integer,
+    votingEnd: EvoCore.TSchema.Integer,
+  }),
+);
+
+export type StakingPosLockedAmt = typeof StakingPosLockedAmtSchema.Type;
+
+const RewardSnapshotSchema = EvoCore.TSchema.Struct({
+  snapshotAda: EvoCore.TSchema.Integer,
+});
+
+const StakingPositionSchema = EvoCore.TSchema.Struct({
+  owner: EvoCore.TSchema.ByteArray,
+  lockedAmount: StakingPosLockedAmtSchema,
+  positionSnapshot: RewardSnapshotSchema,
+});
+export type StakingPosition = typeof StakingPositionSchema.Type;
+
+const StakingManagerSchema = EvoCore.TSchema.Struct({
+  totalStake: EvoCore.TSchema.Integer,
+  managerSnapshot: RewardSnapshotSchema,
+});
+export type StakingManager = typeof StakingManagerSchema.Type;
+
+const StakingDatumSchema = EvoCore.TSchema.Union(
+  StakingManagerSchema,
+  StakingPositionSchema,
+);
+type StakingDatum = typeof StakingDatumSchema.Type;
+
+export function parseStakingPosition(datum: string): O.Option<StakingPosition> {
+  try {
+    return match(
+      EvoCore.Data.withSchema(
+        StakingDatumSchema,
+        DEFAULT_SCHEMA_OPTIONS,
+      ).fromCBORHex(datum),
+    )
+      .with({ owner: P.any }, (res) => O.some(res))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseStakingPositionOrThrow(datum: string): StakingPosition {
+  return F.pipe(
+    parseStakingPosition(datum),
+    O.match(() => {
+      throw new Error('Expected a StakingPosition datum.');
+    }, F.identity),
+  );
+}
+
+export function parseStakingManagerDatum(datum: string): StakingManager {
+  return match(
+    EvoCore.Data.withSchema(
+      StakingDatumSchema,
+      DEFAULT_SCHEMA_OPTIONS,
+    ).fromCBORHex(datum),
+  )
+    .with({ totalStake: P.any }, (res) => res)
+    .otherwise(() => {
+      throw new Error('Expected a StakingPosition datum.');
+    });
+}
+
+export function serialiseStakingDatum(d: StakingDatum): string {
+  return EvoCore.Data.withSchema(
+    StakingDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(d);
+}

package/src/contracts/staking/types.ts

@@ -0,0 +1,41 @@
+import { Data, Redeemer } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
+
+const StakingParamsSchema = Data.Object({
+  stakingManagerNft: AssetClassSchema,
+  stakingToken: AssetClassSchema,
+  indyToken: AssetClassSchema,
+  pollToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  collectorValHash: Data.Bytes(),
+});
+type StakingParams = Data.Static<typeof StakingParamsSchema>;
+const StakingParams = StakingParamsSchema as unknown as StakingParams;
+
+const StakingRedeemerSchema = Data.Enum([
+  Data.Object({
+    CreateStakingPosition: Data.Object({
+      creatorPkh: Data.Bytes(),
+    }),
+  }),
+  Data.Literal('UpdateTotalStake'),
+  Data.Literal('Distribute'),
+  Data.Object({
+    AdjustStakedAmount: Data.Object({
+      adjustAmount: Data.Integer(),
+    }),
+  }),
+  Data.Literal('Unstake'),
+  Data.Literal('Lock'),
+  Data.Literal('UpgradeVersion'),
+]);
+export type StakingRedeemer = Data.Static<typeof StakingRedeemerSchema>;
+const StakingRedeemer = StakingRedeemerSchema as unknown as StakingRedeemer;
+
+export function serialiseStakingRedeemer(redeemer: StakingRedeemer): Redeemer {
+  return Data.to<StakingRedeemer>(redeemer, StakingRedeemer);
+}
+
+export function castStakingParams(params: StakingParams): Data {
+  return Data.castTo(params, StakingParams);
+}

package/src/contracts/treasury/scripts.ts

@@ -0,0 +1,37 @@
+import {
+  applyParamsToScript,
+  Constr,
+  fromText,
+  SpendingValidator,
+} from '@lucid-evolution/lucid';
+import { TreasuryParamsSP } from '../../types/system-params';
+import { _treasuryValidator } from '../../validators/treasury-validator';
+
+export const mkTreasuryValidatorFromSP = (
+  params: TreasuryParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_treasuryValidator.cborHex, [
+      new Constr(0, [
+        new Constr(0, [
+          params.upgradeToken[0].unCurrencySymbol,
+          fromText(params.upgradeToken[1].unTokenName),
+        ]),
+        new Constr(0, [
+          params.versionRecordToken[0].unCurrencySymbol,
+          fromText(params.versionRecordToken[1].unTokenName),
+        ]),
+        params.treasuryUtxosStakeCredential
+          ? new Constr(0, [
+              new Constr(0, [
+                new Constr(1, [
+                  params.treasuryUtxosStakeCredential.contents.contents,
+                ]),
+              ]),
+            ])
+          : new Constr(1, []),
+      ]),
+    ]),
+  };
+};

package/src/contracts/treasury/transactions.ts

@@ -0,0 +1,44 @@
+import {
+  addAssets,
+  Data,
+  LucidEvolution,
+  OutRef,
+  TxBuilder,
+} from '@lucid-evolution/lucid';
+import {
+  fromSystemParamsScriptRef,
+  SystemParams,
+} from '../../types/system-params';
+import { matchSingle } from '../../utils/utils';
+import { mkLovelacesOf } from '../../utils/value-helpers';
+import { serialiseTreasuryRedeemer } from './types';
+
+export async function treasuryFeeTx(
+  fee: bigint,
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  tx: TxBuilder,
+  treasuryOref: OutRef,
+): Promise<void> {
+  const treasuryUtxo = matchSingle(
+    await lucid.utxosByOutRef([treasuryOref]),
+    (_) => new Error('Expected a single treasury UTXO'),
+  );
+
+  const treasuryRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.treasuryValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single treasury Ref Script UTXO'),
+  );
+
+  tx.readFrom([treasuryRefScriptUtxo])
+    .collectFrom([treasuryUtxo], serialiseTreasuryRedeemer('CollectAda'))
+    .pay.ToContract(
+      treasuryUtxo.address,
+      { kind: 'inline', value: Data.void() },
+      addAssets(treasuryUtxo.assets, mkLovelacesOf(fee)),
+    );
+}

package/src/contracts/treasury/types.ts

@@ -0,0 +1,55 @@
+import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import {
+  AssetClassSchema,
+  OutputReferenceSchema,
+  StakeCredentialSchema,
+} from '../../types/generic';
+
+export const TreasuryParamsSchema = Data.Object({
+  upgradeToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  treasuryUtxosStakeCredential: Data.Nullable(StakeCredentialSchema),
+});
+export type TreasuryParams = Data.Static<typeof TreasuryParamsSchema>;
+export const TreasuryParams = TreasuryParamsSchema as unknown as TreasuryParams;
+
+const TreasuryRedeemerSchema = Data.Enum([
+  Data.Literal('Withdraw'),
+  Data.Literal('PrepareWithdraw'),
+  Data.Literal('Split'),
+  Data.Literal('Merge'),
+  Data.Literal('CollectAda'),
+  Data.Literal('UpgradeVersion'),
+]);
+export type TreasuryRedeemer = Data.Static<typeof TreasuryRedeemerSchema>;
+const TreasuryRedeemer = TreasuryRedeemerSchema as unknown as TreasuryRedeemer;
+
+const WithdrawalOutputDatumSchema = Data.Tuple([
+  Data.Bytes(),
+  OutputReferenceSchema,
+]);
+export type WithdrawalOutputDatum = Data.Static<
+  typeof WithdrawalOutputDatumSchema
+>;
+const WithdrawalOutputDatum =
+  WithdrawalOutputDatumSchema as unknown as WithdrawalOutputDatum;
+
+export function serialiseWithdrawalOutputDatum(
+  d: WithdrawalOutputDatum,
+): Datum {
+  return Data.to<WithdrawalOutputDatum>(d, WithdrawalOutputDatum);
+}
+
+export function serialiseTreasuryRedeemer(
+  redeemer: TreasuryRedeemer,
+): Redeemer {
+  return Data.to<TreasuryRedeemer>(redeemer, TreasuryRedeemer);
+}
+
+export function serialiseTreasuryDatum(): Datum {
+  return Data.void();
+}
+
+export function castTreasuryParams(params: TreasuryParams): Data {
+  return Data.castTo(params, TreasuryParams);
+}

package/src/contracts/version-registry/scripts.ts

@@ -0,0 +1,29 @@
+import {
+  applyParamsToScript,
+  MintingPolicy,
+  SpendingValidator,
+} from '@lucid-evolution/lucid';
+import {
+  castVersionRecordTokenParams,
+  VersionRecordTokenParams,
+} from './types';
+import { _versionRecordTokenPolicy } from '../../validators/version-record-policy';
+import { _versionRegistryValidator } from '../../validators/version-registry-validator';
+
+export function mkVersionRecordTokenPolicy(
+  params: VersionRecordTokenParams,
+): MintingPolicy {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_versionRecordTokenPolicy.cborHex, [
+      castVersionRecordTokenParams(params),
+    ]),
+  };
+}
+
+export const mkVersionRegistryValidator = (): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: _versionRegistryValidator.cborHex,
+  };
+};

package/src/contracts/version-registry/types-new.ts

@@ -0,0 +1,19 @@
+import { Core as EvoCore } from '@evolution-sdk/evolution';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+
+const VersionRecordDatumSchema = EvoCore.TSchema.Struct({
+  upgradeId: EvoCore.TSchema.Integer,
+  /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
+  upgradePaths: EvoCore.TSchema.Map(
+    EvoCore.TSchema.ByteArray,
+    EvoCore.TSchema.ByteArray,
+  ),
+});
+export type VersionRecordDatum = typeof VersionRecordDatumSchema.Type;
+
+export function serialiseVersionRecordDatum(d: VersionRecordDatum): string {
+  return EvoCore.Data.withSchema(
+    VersionRecordDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(d);
+}

package/src/{types/indigo/version-record.ts → contracts/version-registry/types.ts}

@@ -1,5 +1,5 @@
 import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../generic';
+import { AssetClassSchema } from '../../types/generic';
 
 const VersionRecordTokenParamsSchema = Data.Object({
   upgradeToken: AssetClassSchema,

package/src/contracts/vesting/helpers.ts

@@ -0,0 +1,267 @@
+import { match, P } from 'ts-pattern';
+import { ONE_DAY } from '../../utils/time-helpers';
+import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
+import { array as A } from 'fp-ts';
+import { bigintMax, bigintMin } from '../../utils/bigint-utils';
+
+type Schedule = {
+  vestedAtTime: bigint;
+  unlockAmt: bigint;
+};
+
+type VestingSchedule = {
+  maxUnlockable: bigint;
+  schedule: Schedule[];
+};
+
+const teamVestingSchedule: Schedule[] = [
+  {
+    vestedAtTime: 1669067100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1672523100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1675201500000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1677620700000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1680299100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1682891100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1685569500000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1688161500000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1690839900000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1693518300000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1696110300000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1698788700000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1701380700000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1704059100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1706737500000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1709243100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1711921500000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1714513500000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1717191900000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1719783900000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1722462300000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1725140700000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1727732700000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+  {
+    vestedAtTime: 1730411100000n,
+    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
+  },
+];
+
+const spDistributionSchedule: VestingSchedule = {
+  maxUnlockable: 14_000_000n * 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,
+  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,
+    },
+    {
+      vestedAtTime: 1797803100000n,
+      unlockAmt: 23_972n * OCD_DECIMAL_UNIT,
+    },
+  ],
+};
+
+const govDistributionSchedule: VestingSchedule = {
+  maxUnlockable: 1_750_000n * 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,
+    },
+  ],
+};
+
+export function calculateTotalVestedTeam(currentTime: bigint): bigint {
+  return A.reduce<Schedule, bigint>(0n, (acc, schedule) => {
+    if (currentTime >= schedule.vestedAtTime) {
+      return acc + schedule.unlockAmt;
+    } else {
+      return acc;
+    }
+  })(teamVestingSchedule);
+}
+
+function calculateVestedPerEpoch(
+  schedule: VestingSchedule,
+  currentTime: bigint,
+): bigint {
+  const vestingFreq = 5n * ONE_DAY;
+
+  function go(sched: Schedule[]): bigint {
+    return (
+      match(sched)
+        .returnType<bigint>()
+        .with([], () => 0n)
+        // If the current time is earlier than the first vesting period,
+        // the vested INDY is zero.
+        // Otherwise, the vested INDY increases by the given amount every epoch
+        // after the given date.
+        // The + 1 indicates that the first vest happens from the given date
+        // (as opposed to having to wait for an epoch to complete)
+        .with([P.select()], (sched) =>
+          bigintMax(
+            0n,
+            ((currentTime - sched.vestedAtTime) / vestingFreq + 1n) *
+              sched.unlockAmt,
+          ),
+        )
+        // If the current time is past the first period in the schedule,
+        // at least all INDY from the first period is vested, and can proceed
+        // to compute the vested amount for remaining periods.
+        .with([P._, P._, ...P.array()], ([sched1, sched2, ...rest]) =>
+          currentTime >= sched2.vestedAtTime
+            ? ((sched2.vestedAtTime - sched1.vestedAtTime) / vestingFreq) *
+                sched1.unlockAmt +
+              go([sched2, ...rest])
+            : bigintMax(
+                0n,
+                ((currentTime - sched1.vestedAtTime) / vestingFreq + 1n) *
+                  sched1.unlockAmt,
+              ),
+        )
+        .run()
+    );
+  }
+
+  return bigintMin(schedule.maxUnlockable, go(schedule.schedule));
+}
+
+export function calculateTotalVestedRewards(currentTime: bigint): bigint {
+  return (
+    calculateVestedPerEpoch(spDistributionSchedule, currentTime) +
+    calculateVestedPerEpoch(govDistributionSchedule, currentTime) +
+    calculateVestedPerEpoch(liqDistributionSchedule, currentTime)
+  );
+}

package/src/index.ts

@@ -1,35 +1,39 @@
-export * from './contracts/cdp';
-export * from './contracts/collector';
-export * from './contracts/gov';
-export * from './contracts/stability-pool';
-export * from './contracts/staking';
-export * from './contracts/interest-oracle';
-export * from './contracts/treasury';
-export * from './helpers/asset-helpers';
-export * from './helpers/helpers';
-export * from './helpers/lucid-utils';
-export * from './helpers/stability-pool-helpers';
-export * from './helpers/time-helpers';
-export * from './scripts/cdp-creator-validator';
-export * from './scripts/cdp-validator';
-export * from './scripts/collector-validator';
-export * from './scripts/interest-oracle-validator';
-export * from './scripts/poll-shard-validator';
-export * from './scripts/poll-manager-validator';
-export * from './scripts/treasury-validator';
-export * from './types/indigo/cdp';
-export * from './types/indigo/execute';
-export * from './types/indigo/gov';
-export * from './types/indigo/interest-oracle';
-export * from './types/indigo/price-oracle';
-export * from './types/indigo/stability-pool';
-export * from './types/indigo/lrp';
-export * from './types/indigo/poll-shard';
-export * from './types/indigo/poll-manager';
+export * from './contracts/cdp/transactions';
+export * from './contracts/cdp/helpers';
+export * from './contracts/cdp/types';
+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/collector/transactions';
+export * from './contracts/gov/transactions';
+export * from './contracts/gov/types';
+export * from './contracts/stability-pool/transactions';
+export * from './contracts/staking/transactions';
+export * from './contracts/interest-oracle/transactions';
+export * from './contracts/interest-oracle/types';
+export * from './contracts/interest-oracle/scripts';
+export * from './contracts/version-registry/types';
+export * from './contracts/version-registry/scripts';
+export * from './contracts/treasury/transactions';
+export * from './utils/utils';
+export * from './utils/lucid-utils';
+export * from './contracts/stability-pool/helpers';
+export * from './utils/time-helpers';
+export * from './contracts/cdp/scripts';
+export * from './contracts/collector/scripts';
+export * from './contracts/treasury/scripts';
+export * from './contracts/execute/types';
+export * from './contracts/execute/scripts';
+export * from './contracts/price-oracle/types';
+export * from './contracts/stability-pool/types';
+export * from './contracts/lrp/types';
+export * from './contracts/poll/types-poll-shard';
+export * from './contracts/poll/types-poll-manager';
 export * from './types/generic';
 export * from './types/system-params';
-export * from './contracts/lrp';
-export * from './scripts/lrp-validator';
-export * from './helpers/helper-txs';
-export * from './contracts/one-shot';
-export * from './helpers/helpers';
+export * from './contracts/lrp/transactions';
+export * from './contracts/lrp/scripts';
+export * from './utils/helper-txs';
+export * from './contracts/one-shot/transactions';
+export * from './utils/utils';

package/src/types/evolution-schema-options.ts

@@ -0,0 +1,16 @@
+import { CodecOptions } from '@evolution-sdk/evolution/core/CBOR';
+
+/**
+ * This is related to our on-chain codebase for aiken v1.0.26-alpha
+ */
+export const DEFAULT_SCHEMA_OPTIONS = {
+  mode: 'custom',
+  useIndefiniteArrays: true,
+  // This is important to match aiken's Map encoding.
+  useIndefiniteMaps: false,
+  useDefiniteForEmpty: true,
+  sortMapKeys: false,
+  useMinimalEncoding: true,
+  mapsAsObjects: false,
+  encodeMapAsPairs: false,
+} as const satisfies CodecOptions;