@indigo-labs/indigo-sdk 0.2.1 → 0.2.4

package/src/contracts/lrp/transactions.ts

@@ -1,11 +1,8 @@
 import {
   LucidEvolution,
-  Network,
-  ScriptHash,
   TxBuilder,
   Credential,
   OutRef,
-  UTxO,
   addAssets,
   unixTimeToSlot,
   slotToUnixTime,
@@ -15,39 +12,39 @@ import {
   createScriptAddress,
   getInlineDatumOrThrow,
 } from '../../utils/lucid-utils';
-import { match, P } from 'ts-pattern';
 import { unzip, zip } from 'fp-ts/lib/Array';
-import { reduceWithIndex } from 'fp-ts/lib/Array';
 import {
   LRPDatum,
-  LRPParams,
-  parseLrpDatum,
+  parseLrpDatumOrThrow,
   serialiseLrpDatum,
   serialiseLrpRedeemer,
 } from './types';
 import { parsePriceOracleDatum } from '../price-oracle/types';
-import { ocdMul, OnChainDecimal } from '../../types/on-chain-decimal';
+import { OnChainDecimal } from '../../types/on-chain-decimal';
 import { parseIAssetDatumOrThrow } from '../cdp/types';
 import {
   assetClassValueOf,
   mkAssetsOf,
   mkLovelacesOf,
 } from '../../utils/value-helpers';
-import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
 import { matchSingle } from '../../utils/utils';
 import { AssetClass } from '../../types/generic';
-
-const MIN_UTXO_COLLATERAL_AMT = 2_000_000n;
+import {
+  fromSystemParamsScriptRef,
+  SystemParams,
+} from '../../types/system-params';
+import { buildRedemptionsTx, MIN_LRP_COLLATERAL_AMT } from './helpers';
 
 export async function openLrp(
   assetTokenName: string,
   lovelacesAmt: bigint,
   maxPrice: OnChainDecimal,
   lucid: LucidEvolution,
-  lrpScriptHash: ScriptHash,
-  network: Network,
+  sysParams: SystemParams,
   lrpStakeCredential?: Credential,
 ): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+
   const [ownPkh, _] = await addrDetails(lucid);
 
   const newDatum: LRPDatum = {
@@ -58,22 +55,28 @@ export async function openLrp(
   };
 
   return lucid.newTx().pay.ToContract(
-    createScriptAddress(network, lrpScriptHash, lrpStakeCredential),
+    createScriptAddress(
+      network,
+      sysParams.validatorHashes.lrpHash,
+      lrpStakeCredential,
+    ),
     {
       kind: 'inline',
       value: serialiseLrpDatum(newDatum),
     },
-    { lovelace: lovelacesAmt + MIN_UTXO_COLLATERAL_AMT },
+    { lovelace: lovelacesAmt + MIN_LRP_COLLATERAL_AMT },
   );
 }
 
 export async function cancelLrp(
   lrpOutRef: OutRef,
-  lrpRefScriptOutRef: OutRef,
+  sysParams: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
   const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef),
+    ]),
     (_) => new Error('Expected a single LRP Ref Script UTXO'),
   );
 
@@ -82,7 +85,7 @@ export async function cancelLrp(
     (_) => new Error('Expected a single LRP UTXO.'),
   );
 
-  const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
+  const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
 
   return lucid
     .newTx()
@@ -94,15 +97,17 @@ export async function cancelLrp(
 export async function redeemLrp(
   /** The tuple represents the LRP outref and the amount of iAssets to redeem against it. */
   redemptionLrpsData: [OutRef, bigint][],
-  lrpRefScriptOutRef: OutRef,
   priceOracleOutRef: OutRef,
   iassetOutRef: OutRef,
   lucid: LucidEvolution,
-  lrpParams: LRPParams,
-  network: Network,
+  sysParams: SystemParams,
 ): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+
   const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef),
+    ]),
     (_) => new Error('Expected a single LRP Ref Script UTXO'),
   );
 
@@ -131,81 +136,14 @@ export async function redeemLrp(
     .utxosByOutRef(lrpsToRedeemOutRefs)
     .then((val) => zip(val, lrpRedemptionIAssetAmt));
 
-  const [[mainLrpUtxo, _], __] = match(redemptionLrps)
-    .with(
-      [P._, ...P.array()],
-      ([[firstLrp, _], ...rest]): [[UTxO, bigint], [UTxO, bigint][]] => [
-        [firstLrp, _],
-        rest,
-      ],
-    )
-    .otherwise(() => {
-      throw new Error('Expects at least 1 UTXO to redeem.');
-    });
-
-  const mainLrpDatum = parseLrpDatum(getInlineDatumOrThrow(mainLrpUtxo));
-
-  const tx = reduceWithIndex<[UTxO, bigint], TxBuilder>(
+  const tx = buildRedemptionsTx(
+    redemptionLrps,
+    priceOracleDatum.price,
+    iassetDatum.redemptionReimbursementPercentage,
+    sysParams,
     lucid.newTx(),
-    (idx, acc, [lrpUtxo, redeemIAssetAmt]) => {
-      const lovelacesForRedemption = ocdMul(
-        {
-          getOnChainInt: redeemIAssetAmt,
-        },
-        priceOracleDatum.price,
-      ).getOnChainInt;
-      const reimburstmentLovelaces = calculateFeeFromPercentage(
-        iassetDatum.redemptionReimbursementPercentage,
-        lovelacesForRedemption,
-      );
-
-      const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
-
-      return acc
-        .collectFrom(
-          [lrpUtxo],
-          serialiseLrpRedeemer(
-            idx === 0
-              ? { Redeem: { continuingOutputIdx: 0n } }
-              : {
-                  RedeemAuxiliary: {
-                    continuingOutputIdx: BigInt(idx),
-                    mainRedeemOutRef: {
-                      txHash: { hash: mainLrpUtxo.txHash },
-                      outputIndex: BigInt(mainLrpUtxo.outputIndex),
-                    },
-                    asset: mainLrpDatum.iasset,
-                    assetPrice: priceOracleDatum.price,
-                    redemptionReimbursementPercentage:
-                      iassetDatum.redemptionReimbursementPercentage,
-                  },
-                },
-          ),
-        )
-        .pay.ToContract(
-          lrpUtxo.address,
-          {
-            kind: 'inline',
-            value: serialiseLrpDatum({
-              ...lrpDatum,
-              lovelacesToSpend:
-                lrpDatum.lovelacesToSpend - lovelacesForRedemption,
-            }),
-          },
-          addAssets(
-            lrpUtxo.assets,
-            mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
-            mkAssetsOf(
-              {
-                currencySymbol: lrpParams.iassetPolicyId,
-                tokenName: mainLrpDatum.iasset,
-              },
-              redeemIAssetAmt,
-            ),
-          ),
-        );
-    },
-  )(redemptionLrps);
+    0n,
+  );
 
   return (
     lucid
@@ -235,11 +173,12 @@ export async function adjustLrp(
    * and a negative amount takes lovelaces from the LRP.
    */
   lovelacesAdjustAmt: bigint,
-  lrpRefScriptOutRef: OutRef,
-  lrpParams: LRPParams,
+  sysParams: SystemParams,
 ): Promise<TxBuilder> {
   const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef),
+    ]),
     (_) => new Error('Expected a single LRP Ref Script UTXO'),
   );
 
@@ -248,10 +187,10 @@ export async function adjustLrp(
     (_) => new Error('Expected a single LRP UTXO.'),
   );
 
-  const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
+  const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
 
   const rewardAssetClass: AssetClass = {
-    currencySymbol: lrpParams.iassetPolicyId,
+    currencySymbol: sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
     tokenName: lrpDatum.iasset,
   };
   const rewardAssetsAmt = assetClassValueOf(lrpUtxo.assets, rewardAssetClass);
@@ -301,8 +240,7 @@ export async function adjustLrp(
 export async function claimLrp(
   lucid: LucidEvolution,
   lrpOutRef: OutRef,
-  lrpRefScriptOutRef: OutRef,
-  lrpParams: LRPParams,
+  sysParams: SystemParams,
 ): Promise<TxBuilder> {
-  return adjustLrp(lucid, lrpOutRef, 0n, lrpRefScriptOutRef, lrpParams);
+  return adjustLrp(lucid, lrpOutRef, 0n, sysParams);
 }

package/src/contracts/lrp/types.ts

@@ -1,6 +1,7 @@
-import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import { Data, Datum, Redeemer, UTxO } from '@lucid-evolution/lucid';
 import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
 import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
+import { option as O, function as F } from 'fp-ts';
 
 export const LRPParamsSchema = Data.Object({
   versionRecordToken: AssetClassSchema,
@@ -42,8 +43,21 @@ export const LRPRedeemerSchema = Data.Enum([
 export type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
 const LRPRedeemer = LRPRedeemerSchema as unknown as LRPRedeemer;
 
-export function parseLrpDatum(datum: Datum): LRPDatum {
-  return Data.from<LRPDatum>(datum, LRPDatum);
+export function parseLrpDatum(datum: Datum): O.Option<LRPDatum> {
+  try {
+    return O.some(Data.from<LRPDatum>(datum, LRPDatum));
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseLrpDatumOrThrow(datum: Datum): LRPDatum {
+  return F.pipe(
+    parseLrpDatum(datum),
+    O.match(() => {
+      throw new Error('Expected an LRP datum.');
+    }, F.identity),
+  );
 }
 
 export function serialiseLrpDatum(datum: LRPDatum): Datum {
@@ -57,3 +71,5 @@ export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {
 export function castLrpParams(params: LRPParams): Data {
   return Data.castTo(params, LRPParams);
 }
+
+export type LrpOutput = { datum: LRPDatum; utxo: UTxO };

package/src/contracts/stability-pool/transactions.ts

@@ -461,10 +461,6 @@ export async function processSpRequest(
       newPoolSum,
     );
 
-    console.log('balanceChange', balanceChange);
-    console.log('withdrawalFee', withdrawalFee);
-    console.log('rewardLovelacesFee', rewardLovelacesFee);
-    console.log('reward', reward);
     if (rewardLovelacesFee > 0n) {
       await collectorFeeTx(
         rewardLovelacesFee,

package/src/contracts/staking/helpers.ts

@@ -15,6 +15,7 @@ import {
 } from './types-new';
 import { createScriptAddress } from '../../utils/lucid-utils';
 import { mkStakingValidatorFromSP } from './scripts';
+import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
 
 export type StakingPositionOutput = {
   utxo: UTxO;
@@ -114,3 +115,13 @@ export function findStakingPositionByOutRef(
       return result;
     });
 }
+
+export const rewardSnapshotPrecision = OCD_DECIMAL_UNIT * OCD_DECIMAL_UNIT;
+
+export function distributeReward(
+  snapshotAda: bigint,
+  adaReward: bigint,
+  totalStake: bigint,
+): bigint {
+  return snapshotAda + (adaReward * rewardSnapshotPrecision) / totalStake;
+}

package/src/contracts/staking/transactions.ts

@@ -1,4 +1,5 @@
 import {
+  addAssets,
   Constr,
   Data,
   fromHex,
@@ -12,19 +13,25 @@ import {
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
-import { addrDetails } from '../../utils/lucid-utils';
+import { addrDetails, getInlineDatumOrThrow } from '../../utils/lucid-utils';
 import {
+  distributeReward,
   findStakingManager,
   findStakingManagerByOutRef,
   findStakingPositionByOutRef,
+  rewardSnapshotPrecision,
   updateStakingLockedAmount,
 } from './helpers';
 import {
+  parseStakingManagerDatum,
   serialiseStakingDatum,
   StakingManager,
   StakingPosition,
 } from './types-new';
 import { matchSingle } from '../../utils/utils';
+import { serialiseStakingRedeemer } from './types';
+import { serialiseCollectorRedeemer } from '../collector/types';
+import { mkLovelacesOf } from '../../utils/value-helpers';
 
 export async function openStakingPosition(
   amount: bigint,
@@ -147,7 +154,7 @@ export async function adjustStakingPosition(
   const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
   const adaReward =
     ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
-    (1000000n * 1000000n);
+    rewardSnapshotPrecision;
 
   const newLockedAmount = updateStakingLockedAmount(
     stakingPositionOut.datum.lockedAmount,
@@ -158,8 +165,16 @@ export async function adjustStakingPosition(
     .newTx()
     .validFrom(Date.now())
     .readFrom([stakingRefScriptUtxo])
-    .collectFrom([stakingPositionOut.utxo], Data.to(new Constr(3, [amount])))
-    .collectFrom([stakingManagerOut.utxo], Data.to(new Constr(1, [])))
+    .collectFrom(
+      [stakingPositionOut.utxo],
+      serialiseStakingRedeemer({
+        AdjustStakedAmount: { adjustAmount: amount },
+      }),
+    )
+    .collectFrom(
+      [stakingManagerOut.utxo],
+      serialiseStakingRedeemer('UpdateTotalStake'),
+    )
     .pay.ToContract(
       stakingManagerOut.utxo.address,
       {
@@ -266,3 +281,78 @@ export async function closeStakingPosition(
     )
     .addSignerKey(toHex(stakingPositionOut.datum.owner));
 }
+
+const MIN_UTXO_AMOUNT = 2_000_000n;
+
+export async function distributeAda(
+  stakingManagerRef: OutRef,
+  collectorRefs: OutRef[],
+  params: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const [stakingManagerUtxo] = await lucid.utxosByOutRef([stakingManagerRef]);
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo),
+  );
+  const collectorUtxos = (await lucid.utxosByOutRef(collectorRefs))
+    .filter((utxo) => utxo.datum && utxo.datum === Data.void())
+    .filter((utxo) => utxo.assets.lovelace > MIN_UTXO_AMOUNT);
+
+  if (collectorUtxos.length === 0) {
+    throw new Error('No available collectors found');
+  }
+
+  const adaRewardCollected = collectorUtxos.reduce(
+    (acc, utxo) => acc + utxo.assets.lovelace - MIN_UTXO_AMOUNT,
+    0n,
+  );
+  const newSnapshot = distributeReward(
+    stakingManagerDatum.managerSnapshot.snapshotAda,
+    adaRewardCollected,
+    stakingManagerDatum.totalStake,
+  );
+
+  const stakingRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef),
+    ]),
+    (_) => new Error('Expected a single staking Ref Script UTXO'),
+  );
+
+  const collectorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.collectorValidatorRef),
+    ]),
+    (_) => new Error('Expected a single staking Ref Script UTXO'),
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([stakingRefScriptUtxo, collectorRefScriptUtxo])
+    .collectFrom([stakingManagerUtxo], serialiseStakingRedeemer('Distribute'))
+    .collectFrom(
+      collectorUtxos,
+      serialiseCollectorRedeemer('DistributeToStakers'),
+    )
+    .pay.ToContract(
+      stakingManagerUtxo.address,
+      {
+        kind: 'inline',
+        value: serialiseStakingDatum({
+          ...stakingManagerDatum,
+          managerSnapshot: { snapshotAda: newSnapshot },
+        }),
+      },
+      addAssets(stakingManagerUtxo.assets, mkLovelacesOf(adaRewardCollected)),
+    );
+
+  for (const collectorUtxo of collectorUtxos) {
+    tx.pay.ToContract(
+      collectorUtxo.address,
+      { kind: 'inline', value: Data.void() },
+      mkLovelacesOf(MIN_UTXO_AMOUNT),
+    );
+  }
+
+  return tx;
+}

package/src/index.ts

@@ -11,13 +11,14 @@ export * from './contracts/gov/types';
 export * from './contracts/stability-pool/transactions';
 export * from './contracts/stability-pool/types-new';
 export * from './contracts/staking/transactions';
+export * from './contracts/staking/types';
+export * from './contracts/staking/types-new';
 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';
@@ -28,14 +29,18 @@ 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/helpers';
 export * from './contracts/lrp/transactions';
 export * from './contracts/lrp/scripts';
+export * from './contracts/lrp/types';
 export * from './utils/helper-txs';
 export * from './contracts/one-shot/transactions';
 export * from './utils/utils';
+export * from './utils/array-utils';
 export * from './utils/value-helpers';
+export * from './contracts/leverage/transactions';
+export * from './contracts/leverage/helpers';

package/src/types/on-chain-decimal.ts

@@ -13,6 +13,10 @@ export function ocdCeil(a: OnChainDecimal): bigint {
   return a.getOnChainInt > whole * OCD_DECIMAL_UNIT ? whole + 1n : whole;
 }
 
+export function ocdFloor(a: OnChainDecimal): bigint {
+  return a.getOnChainInt / OCD_DECIMAL_UNIT;
+}
+
 export function ocdNegate(a: OnChainDecimal): OnChainDecimal {
   return { getOnChainInt: -a.getOnChainInt };
 }

package/src/utils/array-utils.ts

@@ -0,0 +1,39 @@
+import { array as A, ord as Ord } from 'fp-ts';
+
+export function shuffle<T>(arr: T[]): T[] {
+  const source = [...arr];
+  for (let i = source.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [source[i], source[j]] = [source[j], source[i]];
+  }
+
+  return source;
+}
+
+/**
+ * The parameter `arr` should be sorted for correct results.
+ */
+export function insertSorted<T>(arr: T[], item: T, ord: Ord.Ord<T>): T[] {
+  if (arr.length === 0) {
+    return [item];
+  }
+
+  const arrOrd = ord.compare(arr[0], arr[arr.length - 1]);
+  // Array containing the same items
+  if (arrOrd === 0) {
+    if (ord.compare(arr[0], item) === -1) {
+      return [...arr, item];
+    } else {
+      return [item, ...arr];
+    }
+  }
+
+  // TODO: could be improved with binary search
+  for (let i = 0; i < arr.length; i++) {
+    if (ord.compare(arr[i], item) !== arrOrd) {
+      return [...A.takeLeft(i)(arr), item, ...A.takeRight(arr.length - i)(arr)];
+    }
+  }
+
+  return [...arr, item];
+}

package/src/utils/bigint-utils.ts

@@ -1,3 +1,6 @@
+import Decimal from 'decimal.js';
+import { array as A, ord as Ord } from 'fp-ts';
+
 export function bigintMax(a: bigint, b: bigint): bigint {
   return a > b ? a : b;
 }
@@ -5,3 +8,16 @@ export function bigintMax(a: bigint, b: bigint): bigint {
 export function bigintMin(a: bigint, b: bigint): bigint {
   return a < b ? a : b;
 }
+
+export function sum(arr: bigint[]): bigint {
+  return A.reduce<bigint, bigint>(0n, (acc, val) => acc + val)(arr);
+}
+
+export function fromDecimal(val: Decimal): bigint {
+  return BigInt(val.toString());
+}
+
+export const BigIntOrd: Ord.Ord<bigint> = {
+  equals: (x, y) => x === y,
+  compare: (first, second) => (first < second ? -1 : first > second ? 1 : 0),
+};

package/tests/array-utils.test.ts

@@ -0,0 +1,92 @@
+import { expect, test } from 'vitest';
+import { insertSorted, shuffle } from '../src/utils/array-utils';
+import { BigIntOrd } from '../src/utils/bigint-utils';
+import { ord as Ord, number as Num, array as A } from 'fp-ts';
+
+test('Shuffle', () => {
+  const arr = [1, 2, 34, 45, -1, 20, 35];
+  const shuffled = shuffle(arr);
+
+  expect(shuffled.length).toBe(arr.length);
+  expect(A.sort(Num.Ord)(shuffled)).toEqual(A.sort(Num.Ord)(arr));
+});
+
+test('insert sorted 1', () => {
+  const arr = [0n, 2n, 3n];
+  expect(insertSorted(arr, 1n, BigIntOrd)).toEqual([0n, 1n, 2n, 3n]);
+});
+test('insert sorted 2', () => {
+  const arr = [0n, 2n, 4n];
+  expect(insertSorted(arr, 3n, BigIntOrd)).toEqual([0n, 2n, 3n, 4n]);
+});
+test('insert sorted at start', () => {
+  const arr = [0n, 2n, 3n];
+  expect(insertSorted(arr, -1n, BigIntOrd)).toEqual([-1n, 0n, 2n, 3n]);
+});
+test('insert sorted at end', () => {
+  const arr = [0n, 2n, 3n];
+  expect(insertSorted(arr, 5n, BigIntOrd)).toEqual([0n, 2n, 3n, 5n]);
+});
+test('insert sorted at start when array all equal', () => {
+  const arr = [0n, 0n, 0n];
+  expect(insertSorted(arr, -1n, BigIntOrd)).toEqual([-1n, 0n, 0n, 0n]);
+});
+test('insert sorted at end when array all equal', () => {
+  const arr = [0n, 0n, 0n];
+  expect(insertSorted(arr, 1n, BigIntOrd)).toEqual([0n, 0n, 0n, 1n]);
+});
+
+test('insert sorted reversed 1', () => {
+  const arr = [3n, 2n, 0n];
+  expect(insertSorted(arr, 1n, Ord.reverse(BigIntOrd))).toEqual([
+    3n,
+    2n,
+    1n,
+    0n,
+  ]);
+});
+test('insert sorted reversed 2', () => {
+  const arr = [4n, 2n, 0n];
+  expect(insertSorted(arr, 3n, Ord.reverse(BigIntOrd))).toEqual([
+    4n,
+    3n,
+    2n,
+    0n,
+  ]);
+});
+test('insert sorted eversed at start', () => {
+  const arr = [3n, 2n, 0n];
+  expect(insertSorted(arr, 4n, Ord.reverse(BigIntOrd))).toEqual([
+    4n,
+    3n,
+    2n,
+    0n,
+  ]);
+});
+test('insert sorted reversed at end', () => {
+  const arr = [3n, 2n, 0n];
+  expect(insertSorted(arr, -1n, Ord.reverse(BigIntOrd))).toEqual([
+    3n,
+    2n,
+    0n,
+    -1n,
+  ]);
+});
+test('insert sorted reversed at end when array all equal', () => {
+  const arr = [0n, 0n, 0n];
+  expect(insertSorted(arr, -1n, Ord.reverse(BigIntOrd))).toEqual([
+    0n,
+    0n,
+    0n,
+    -1n,
+  ]);
+});
+test('insert sorted reversed at start when array all equal', () => {
+  const arr = [0n, 0n, 0n];
+  expect(insertSorted(arr, 1n, Ord.reverse(BigIntOrd))).toEqual([
+    1n,
+    0n,
+    0n,
+    0n,
+  ]);
+});