@fleet-sdk/common 0.1.0-alpha.29 → 0.1.0-alpha.31

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;
   });
@@ -99,7 +101,7 @@ export function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean
 export function areEqualBy<T>(
   array1: ArrayLike<T>,
   array2: ArrayLike<T>,
-  selector: (item: T) => T[keyof T]
+  selector: ObjectSelector<T>
 ): boolean {
   if (array1 === array2) {
     return true;
@@ -155,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,20 +32,31 @@ 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 {
+export function utxoDiff(
+  minuend: BoxSummary | Box<Amount>[],
+  subtrahend: BoxSummary | Box<Amount>[]
+): BoxSummary {
+  if (Array.isArray(minuend)) {
+    minuend = utxoSum(minuend);
+  }
+
+  if (Array.isArray(subtrahend)) {
+    subtrahend = utxoSum(subtrahend);
+  }
+
   const tokens: TokenAmount<bigint>[] = [];
-  const nanoErgs = amountsA.nanoErgs - amountsB.nanoErgs;
+  const nanoErgs = minuend.nanoErgs - subtrahend.nanoErgs;
 
-  for (const token of amountsA.tokens) {
+  for (const token of minuend.tokens) {
     const balance =
-      token.amount - (amountsB.tokens.find((t) => t.tokenId === token.tokenId)?.amount || _0n);
+      token.amount - (subtrahend.tokens.find((t) => t.tokenId === token.tokenId)?.amount || _0n);
 
     if (balance !== _0n) {
       tokens.push({ tokenId: token.tokenId, amount: balance });
@@ -54,40 +66,96 @@ export function utxoSumResultDiff(amountsA: BoxAmounts, amountsB: BoxAmounts): B
   return { nanoErgs, tokens };
 }
 
-const MIN_REGISTER_NUMBER = 4;
-const MAX_REGISTER_NUMBER = 9;
+const MIN_NON_MANDATORY_REGISTER_INDEX = 4;
+const MAX_NON_MANDATORY_REGISTER_INDEX = 9;
 
 export function areRegistersDenselyPacked(registers: NonMandatoryRegisters): boolean {
-  let lastValueIndex = 0;
-  for (let i = MIN_REGISTER_NUMBER; i <= MAX_REGISTER_NUMBER; i++) {
-    if (registers[`R${i}` as keyof NonMandatoryRegisters]) {
-      if (i === MIN_REGISTER_NUMBER) {
-        lastValueIndex = i;
+  let lastIndex = 0;
+  for (let i = MIN_NON_MANDATORY_REGISTER_INDEX; i <= MAX_NON_MANDATORY_REGISTER_INDEX; i++) {
+    const key = `R${i}` as keyof NonMandatoryRegisters;
+    if (registers[key]) {
+      if (i === MIN_NON_MANDATORY_REGISTER_INDEX) {
+        lastIndex = i;
         continue;
       }
 
-      if (i - lastValueIndex > 1) {
+      if (i - lastIndex > 1) {
         return false;
       }
 
-      lastValueIndex = i;
+      lastIndex = i;
     }
   }
 
   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>[];
 }[];