@fleet-sdk/common 0.1.0-alpha.28 → 0.1.0-alpha.30

package/src/utils/arrayUtils.ts

@@ -1,5 +1,7 @@
 import { SortingDirection, SortingSelector } from "../types";
 
+type ObjectSelector<T> = (item: T) => T[keyof T];
+
 export function isEmpty<T extends object>(obj?: T): obj is undefined;
 export function isEmpty<T>(array?: T[]): array is undefined;
 export function isEmpty<T>(obj?: T[] | object): obj is undefined {
@@ -43,7 +45,7 @@ export function hasDuplicates<T>(array: T[]): boolean {
 /**
  * Check for duplicate keys in complex elements
  */
-export function hasDuplicatesBy<T>(array: T[], selector: (value: T) => unknown): boolean {
+export function hasDuplicatesBy<T>(array: T[], selector: ObjectSelector<T>): boolean {
   return array.some((item, index) => {
     return array.findIndex((x) => selector(x) === selector(item)) !== index;
   });
@@ -96,6 +98,28 @@ export function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean
   return true;
 }
 
+export function areEqualBy<T>(
+  array1: ArrayLike<T>,
+  array2: ArrayLike<T>,
+  selector: ObjectSelector<T>
+): boolean {
+  if (array1 === array2) {
+    return true;
+  }
+
+  if (array1.length != array2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < array1.length; i++) {
+    if (selector(array1[i]) !== selector(array2[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 export function startsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
   if (array === target) {
     return true;
@@ -133,3 +157,35 @@ export function endsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean
 
   return true;
 }
+
+export function uniq<T>(array: Array<T>): Array<T> {
+  if (isEmpty(array)) {
+    return array;
+  }
+
+  return Array.from(new Set(array));
+}
+
+export function uniqBy<T>(
+  array: Array<T>,
+  selector: ObjectSelector<T>,
+  selection: "keep-first" | "keep-last" = "keep-first"
+): Array<T> {
+  if (isEmpty(array)) {
+    return array;
+  }
+
+  return Array.from(
+    array
+      .reduce((map, e) => {
+        const key = selector(e);
+
+        if (selection === "keep-first" && map.has(key)) {
+          return map;
+        }
+
+        return map.set(key, e);
+      }, new Map())
+      .values()
+  );
+}

package/src/utils/boxUtils.ts

@@ -1,13 +1,14 @@
-import { Amount, NonMandatoryRegisters, TokenId } from "../types";
+import { Amount, AmountType, Box, NonMandatoryRegisters, TokenAmount, TokenId } from "../types";
+import { isEmpty } from "./arrayUtils";
 import { _0n } from "./bigIntLiterals";
 import { ensureBigInt } from "./bigIntUtils";
 import { isDefined, isUndefined } from "./objectUtils";
 
 const NANOERGS_TOKEN_ID = "nanoErgs";
 
-export function utxoSum(boxes: MinimalBoxAmounts): BoxAmounts;
+export function utxoSum(boxes: MinimalBoxAmounts): BoxSummary;
 export function utxoSum(boxes: MinimalBoxAmounts, tokenId: TokenId): bigint;
-export function utxoSum(boxes: MinimalBoxAmounts, tokenId?: TokenId): BoxAmounts | bigint {
+export function utxoSum(boxes: MinimalBoxAmounts, tokenId?: TokenId): BoxSummary | bigint {
   const balances: { [tokenId: string]: bigint } = {};
 
   for (const box of boxes) {
@@ -31,14 +32,15 @@ export function utxoSum(boxes: MinimalBoxAmounts, tokenId?: TokenId): BoxAmounts
   }
 
   return {
-    nanoErgs: balances[NANOERGS_TOKEN_ID],
+    nanoErgs: balances[NANOERGS_TOKEN_ID] || _0n,
     tokens: Object.keys(balances)
       .filter((x) => x !== NANOERGS_TOKEN_ID)
       .map((tokenId) => ({ tokenId, amount: balances[tokenId] }))
   };
 }
 
-export function utxoSumResultDiff(amountsA: BoxAmounts, amountsB: BoxAmounts): BoxAmounts {
+// todo: make it accept arrays of utxos as params
+export function utxoDiff(amountsA: BoxSummary, amountsB: BoxSummary): BoxSummary {
   const tokens: TokenAmount<bigint>[] = [];
   const nanoErgs = amountsA.nanoErgs - amountsB.nanoErgs;
 
@@ -54,14 +56,14 @@ export function utxoSumResultDiff(amountsA: BoxAmounts, amountsB: BoxAmounts): B
   return { nanoErgs, tokens };
 }
 
-const MIN_REGISTER_NUMBER = 4;
-const MAX_REGISTER_NUMBER = 9;
+const MIN_REGISTERS = 4;
+const MAX_REGISTERS = 9;
 
 export function areRegistersDenselyPacked(registers: NonMandatoryRegisters): boolean {
   let lastValueIndex = 0;
-  for (let i = MIN_REGISTER_NUMBER; i <= MAX_REGISTER_NUMBER; i++) {
+  for (let i = MIN_REGISTERS; i <= MAX_REGISTERS; i++) {
     if (registers[`R${i}` as keyof NonMandatoryRegisters]) {
-      if (i === MIN_REGISTER_NUMBER) {
+      if (i === MIN_REGISTERS) {
         lastValueIndex = i;
         continue;
       }
@@ -77,17 +79,72 @@ export function areRegistersDenselyPacked(registers: NonMandatoryRegisters): boo
   return true;
 }
 
-type TokenAmount<AmountType> = {
-  tokenId: TokenId;
-  amount: AmountType;
+export function utxoFilter<T extends AmountType>(
+  utxos: Box<T>[],
+  filterParams: UTxOFilterParams<T>
+) {
+  if (isEmpty(filterParams) || isEmpty(utxos)) {
+    return utxos;
+  }
+
+  const { by, max } = filterParams;
+  let filtered = utxos;
+
+  if (by) {
+    filtered = utxos.filter(by);
+    if (isEmpty(filtered)) {
+      return filtered;
+    }
+  }
+
+  if (!max) {
+    return filtered;
+  }
+
+  if (isDefined(max.aggregatedDistinctTokens)) {
+    const tokenIds = _getDistinctTokenIds(filtered, max.aggregatedDistinctTokens);
+    filtered = filtered.filter(
+      (utxo) => isEmpty(utxo.assets) || utxo.assets.every((token) => tokenIds.has(token.tokenId))
+    );
+  }
+
+  if (isDefined(max.count) && filtered.length > max.count) {
+    filtered = filtered.slice(0, max.count);
+  }
+
+  return filtered;
+}
+
+function _getDistinctTokenIds(utxos: Box<AmountType>[], max: number): Set<string> {
+  const tokenIds = new Set<string>();
+
+  for (let i = 0; i < utxos.length && tokenIds.size < max; i++) {
+    if (isEmpty(utxos[i].assets) || utxos[i].assets.length > max) {
+      continue;
+    }
+
+    for (const token of utxos[i].assets) {
+      tokenIds.add(token.tokenId);
+    }
+  }
+
+  return tokenIds;
+}
+
+export type UTxOFilterParams<T extends AmountType> = {
+  by?: (utxo: Box<T>) => boolean;
+  max?: {
+    count?: number;
+    aggregatedDistinctTokens?: number;
+  };
 };
 
-export type BoxAmounts = {
+export type BoxSummary = {
   nanoErgs: bigint;
   tokens: TokenAmount<bigint>[];
 };
 
-type MinimalBoxAmounts = readonly {
+export type MinimalBoxAmounts = readonly {
   value: Amount;
   assets: TokenAmount<Amount>[];
 }[];