@fleet-sdk/common 0.1.2 → 0.1.3

package/src/models/collection.ts

@@ -0,0 +1,107 @@
+import { OneOrMore } from "../types";
+import { isDefined } from "../utils";
+
+export type CollectionAddOptions = { index?: number };
+
+export abstract class Collection<InternalType, ExternalType> implements Iterable<InternalType> {
+  protected readonly _items: InternalType[];
+
+  constructor() {
+    this._items = [];
+  }
+
+  protected _isIndexOutOfBounds(index: number): boolean {
+    return index < 0 || index >= this._items.length;
+  }
+
+  [Symbol.iterator](): Iterator<InternalType> {
+    let counter = 0;
+
+    return {
+      next: () => {
+        return {
+          done: counter >= this.length,
+          value: this._items[counter++]
+        };
+      }
+    };
+  }
+
+  public get length(): number {
+    return this._items.length;
+  }
+
+  public get isEmpty(): boolean {
+    return this.length === 0;
+  }
+
+  public at(index: number): InternalType {
+    if (this._isIndexOutOfBounds(index)) {
+      throw new RangeError(`Index '${index}' is out of range.`);
+    }
+
+    return this._items[index];
+  }
+
+  public add(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number {
+    return this._addOneOrMore(items, options);
+  }
+
+  abstract remove(item: unknown): number;
+
+  protected abstract _map(item: ExternalType | InternalType): InternalType;
+
+  protected _addOne(item: InternalType | ExternalType, options?: CollectionAddOptions): number {
+    if (isDefined(options) && isDefined(options.index)) {
+      if (options.index === this.length) {
+        this._items.push(this._map(item));
+
+        return this.length;
+      }
+
+      if (this._isIndexOutOfBounds(options.index)) {
+        throw new RangeError(`Index '${options.index}' is out of range.`);
+      }
+
+      this._items.splice(options.index, 0, this._map(item));
+
+      return this.length;
+    }
+
+    this._items.push(this._map(item));
+
+    return this._items.length;
+  }
+
+  protected _addOneOrMore(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number {
+    if (Array.isArray(items)) {
+      if (isDefined(options) && isDefined(options.index)) {
+        items = items.reverse();
+      }
+
+      for (const item of items) {
+        this._addOne(item, options);
+      }
+    } else {
+      this._addOne(items, options);
+    }
+
+    return this.length;
+  }
+
+  public toArray(): InternalType[] {
+    return [...this._items];
+  }
+
+  public reduce<U>(
+    callbackFn: (
+      accumulator: U,
+      currentValue: InternalType,
+      currentIndex: number,
+      array: InternalType[]
+    ) => U,
+    initialValue: U
+  ): U {
+    return this._items.reduce(callbackFn, initialValue);
+  }
+}

package/src/models/index.ts

@@ -0,0 +1 @@
+export * from "./collection";

package/src/types/boxes.ts

@@ -1,4 +1,4 @@
-import { ErgoTree } from "./common";
+import { ErgoTreeHex } from "./common";
 import { NonMandatoryRegisters } from "./registers";
 import { TokenAmount } from "./token";
 import { TransactionId } from "./transactions";
@@ -7,7 +7,7 @@ export type BoxId = string;
 export type AmountType = string | bigint;
 
 type BoxBaseType<T extends AmountType, R extends NonMandatoryRegisters> = {
-  ergoTree: ErgoTree;
+  ergoTree: ErgoTreeHex;
   creationHeight: number;
   value: T;
   assets: TokenAmount<T>[];

package/src/types/common.ts

@@ -1,5 +1,5 @@
 export type HexString = string;
-export type ErgoTree = string;
+export type ErgoTreeHex = string;
 export type Base58String = string;
 export type Amount = string | bigint;
 
@@ -13,8 +13,8 @@ export type FilterPredicate<T> = (item: T) => boolean;
 export type BuildOutputType = "default" | "EIP-12";
 
 export enum Network {
-  Mainnet = 0 << 4,
-  Testnet = 1 << 4
+  Mainnet = 0x00,
+  Testnet = 0x10
 }
 
 export enum AddressType {
@@ -22,3 +22,10 @@ export enum AddressType {
   P2SH = 2,
   P2S = 3
 }
+
+export const ergoTreeHeaderFlags = {
+  sizeInclusion: 0x08,
+  constantSegregation: 0x10
+} as const;
+
+export type ErgoTreeHeaderFlag = (typeof ergoTreeHeaderFlags)[keyof typeof ergoTreeHeaderFlags];

package/src/types/inputs.ts

@@ -1,5 +1,5 @@
 import { BoxId } from "./boxes";
-import { ErgoTree } from "./common";
+import { ErgoTreeHex } from "./common";
 import { ContextExtension } from "./contextExtension";
 import { ProverResult } from "./proverResult";
 import { NonMandatoryRegisters } from "./registers";
@@ -19,7 +19,7 @@ export type UnsignedInput = {
 export type EIP12UnsignedInput = UnsignedInput & {
   transactionId: TransactionId;
   index: number;
-  ergoTree: ErgoTree;
+  ergoTree: ErgoTreeHex;
   creationHeight: number;
   value: string;
   assets: TokenAmount<string>[];
@@ -30,7 +30,7 @@ export type EIP12UnsignedDataInput = {
   boxId: BoxId;
   transactionId: TransactionId;
   index: number;
-  ergoTree: ErgoTree;
+  ergoTree: ErgoTreeHex;
   creationHeight: number;
   value: string;
   assets: TokenAmount<string>[];

package/src/utils/arrayUtils.ts

@@ -1,36 +1,37 @@
 import { SortingDirection, SortingSelector } from "../types";
+import { assert, isEmpty } from "./assertions";
 
 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 {
-  if (!obj) {
-    return true;
-  }
+export function first(array: undefined): undefined;
+export function first<T>(array: ArrayLike<T>): T;
+export function first<T>(array: ArrayLike<T> | undefined): T | number | undefined {
+  if (!array) return undefined;
+  assert(array.length > 0, "Empty array.");
 
-  return Array.isArray(obj) ? obj.length === 0 : Object.keys(obj).length === 0;
+  return array[0];
 }
 
-export function some<T extends object>(obj?: T): obj is T;
-export function some<T>(array?: T[]): array is T[];
-export function some<T>(obj?: T[] | object): boolean {
-  return !isEmpty(obj);
+export function last(array: undefined): undefined;
+export function last<T>(array: ArrayLike<T>): T;
+export function last<T>(array: ArrayLike<T> | undefined): T | undefined {
+  if (!array) return undefined;
+  assert(array.length > 0, "Empty array.");
+
+  return at(array, -1);
 }
 
-export function first(array: undefined): undefined;
-export function first(array: Uint8Array): number;
-export function first<T>(array: ArrayLike<T>): T;
-export function first<T>(array?: ArrayLike<T> | Uint8Array): T | number | undefined {
-  if (!array) {
-    return;
-  }
+export function at(array: undefined, index: number): undefined;
+export function at<T>(array: ArrayLike<T>, index: number): T;
+export function at<T>(array: ArrayLike<T> | undefined, index: number): T | undefined {
+  const len = array?.length;
+  if (!len) return undefined;
 
-  if (!array[0]) {
-    throw Error("Empty array.");
+  if (index < 0) {
+    index += len;
   }
 
-  return array[0];
+  return array[index];
 }
 
 /**

package/src/utils/assertions.ts

@@ -0,0 +1,44 @@
+export type AssertErrorMessageInput = string | Error | (() => string);
+
+export function assert(condition: boolean, errorMsg: AssertErrorMessageInput): asserts condition {
+  if (!condition) {
+    let error: Error | undefined = undefined;
+
+    switch (typeof errorMsg) {
+      case "string":
+        error = new Error(errorMsg);
+        break;
+      case "function":
+        error = new Error(errorMsg());
+        break;
+      default:
+        error = errorMsg;
+    }
+
+    throw error;
+  }
+}
+
+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 {
+  if (!obj) {
+    return true;
+  }
+
+  return Array.isArray(obj) ? obj.length === 0 : Object.keys(obj).length === 0;
+}
+
+export function some<T extends object>(obj?: T): obj is T;
+export function some<T>(array?: T[]): array is T[];
+export function some<T>(obj?: T[] | object): boolean {
+  return !isEmpty(obj);
+}
+
+export function isTruthy<T>(v?: T): v is NonNullable<T> {
+  return Boolean(v);
+}
+
+export function isFalsy<T>(v?: T): v is undefined {
+  return !isTruthy(v);
+}

package/src/utils/bigIntUtils.ts

@@ -1,5 +1,6 @@
 import { Amount } from "../types";
-import { first, isEmpty } from "./arrayUtils";
+import { first } from "./arrayUtils";
+import { isEmpty } from "./assertions";
 import { _0n, _10n } from "./bigIntLiterals";
 import { isUndefined } from "./objectUtils";
 
@@ -92,6 +93,10 @@ export function decimalize(value: Amount, options?: FormattingOptions | number):
   return _buildFormattedDecimal(integer.toString(10), decimal.toString(10), options);
 }
 
+export function percent(value: bigint, percentage: bigint, precision = 2n) {
+  return (value * percentage) / 10n ** precision;
+}
+
 function _buildFormattedDecimal(
   integer: string,
   decimal: string,
@@ -221,3 +226,27 @@ export function _bitNegate(value: bigint): bigint {
 
   return (~value & mask) + 1n; // invert bits, mask it, and add one
 }
+
+export function min<T extends bigint | number>(...numbers: T[]): T {
+  let min = first(numbers);
+
+  for (const num of numbers) {
+    if (num < min) {
+      min = num;
+    }
+  }
+
+  return min;
+}
+
+export function max<T extends bigint | number>(...numbers: T[]): T {
+  let max = first(numbers);
+
+  for (const num of numbers) {
+    if (num > max) {
+      max = num;
+    }
+  }
+
+  return max;
+}

package/src/utils/boxUtils.ts

@@ -1,5 +1,13 @@
-import { Amount, AmountType, Box, NonMandatoryRegisters, TokenAmount, TokenId } from "../types";
-import { isEmpty } from "./arrayUtils";
+import {
+  Amount,
+  AmountType,
+  Box,
+  BoxCandidate,
+  NonMandatoryRegisters,
+  TokenAmount,
+  TokenId
+} from "../types";
+import { isEmpty } from "./assertions";
 import { _0n } from "./bigIntLiterals";
 import { ensureBigInt } from "./bigIntUtils";
 import { isDefined, isUndefined } from "./objectUtils";
@@ -159,3 +167,18 @@ export type MinimalBoxAmounts = readonly {
   value: Amount;
   assets: TokenAmount<Amount>[];
 }[];
+
+export function ensureUTxOBigInt(box: Box<Amount>): Box<bigint>;
+export function ensureUTxOBigInt(candidate: BoxCandidate<Amount>): BoxCandidate<bigint>;
+export function ensureUTxOBigInt(
+  box: Box<Amount> | BoxCandidate<Amount>
+): BoxCandidate<bigint> | Box<bigint> {
+  return {
+    ...box,
+    value: ensureBigInt(box.value),
+    assets: box.assets.map((token) => ({
+      tokenId: token.tokenId,
+      amount: ensureBigInt(token.amount)
+    }))
+  };
+}

package/src/utils/index.ts

@@ -4,3 +4,4 @@ export * from "./bigIntUtils";
 export * from "./boxUtils";
 export * from "./objectUtils";
 export * from "./stringUtils";
+export * from "./assertions";

package/src/utils/objectUtils.ts

@@ -17,3 +17,7 @@ export function isUndefined(value: unknown): value is undefined {
 export function isDefined<T>(value: T | undefined): value is T {
   return !isUndefined(value);
 }
+
+export function hasKey(o: unknown, key: PropertyKey): boolean {
+  return Object.prototype.hasOwnProperty.call(o, key);
+}