@fleet-sdk/common 0.1.2 → 0.2.0

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 → array.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];
 }
 
 /**
@@ -189,3 +190,7 @@ export function uniqBy<T>(
       .values()
   );
 }
+
+export function depthOf(array: unknown | unknown[]): number {
+  return Array.isArray(array) ? 1 + Math.max(0, ...array.map(depthOf)) : 0;
+}

package/src/utils/assertions.ts

@@ -0,0 +1,90 @@
+export type AssertErrorMessageInput = string | Error | (() => string);
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type Constructable = Function;
+
+type JSPrimitiveTypes =
+  | "string"
+  | "number"
+  | "bigint"
+  | "boolean"
+  | "symbol"
+  | "undefined"
+  | "object"
+  | "function";
+
+export function assert(condition: boolean, error: AssertErrorMessageInput): asserts condition {
+  if (condition) return;
+
+  let err: Error | undefined = undefined;
+  switch (typeof error) {
+    case "string":
+      err = new Error(error);
+      break;
+    case "function":
+      err = new Error(error());
+      break;
+    default:
+      err = error;
+  }
+
+  throw err;
+}
+
+export function assertTypeOf<T>(obj: T, expected: JSPrimitiveTypes): asserts obj {
+  const type = typeof obj;
+
+  if (type !== expected) {
+    throw new Error(`Expected an object of type '${expected}', got '${type}'.`);
+  }
+}
+
+const toString = (value: unknown) => Object.prototype.toString.call(value);
+function getTypeName(value: unknown): string {
+  if (value === null) return "null";
+  const type = typeof value;
+
+  return type === "object" || type === "function" ? toString(value).slice(8, -1) : type;
+}
+
+export function assertInstanceOf<T>(obj: T, expected: Constructable): asserts obj {
+  const condition = obj instanceof expected;
+
+  if (!condition) {
+    throw new Error(`Expected an instance of '${expected.name}', got '${getTypeName(obj)}'.`);
+  }
+}
+
+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>(value?: T): value is NonNullable<T> {
+  return !!value;
+}
+
+export function isFalsy<T>(value?: T): value is undefined {
+  return !value;
+}
+
+export function isUndefined(v: unknown): v is undefined {
+  return v === undefined || v === null || Number.isNaN(v);
+}
+
+export function isDefined<T>(v: T | undefined): v is T {
+  return !isUndefined(v);
+}
+
+export function hasKey(o: unknown, key: PropertyKey): boolean {
+  return Object.prototype.hasOwnProperty.call(o, key);
+}

package/src/utils/{bigIntUtils.ts → bigInt.ts}

@@ -1,10 +1,17 @@
 import { Amount } from "../types";
-import { first, isEmpty } from "./arrayUtils";
-import { _0n, _10n } from "./bigIntLiterals";
-import { isUndefined } from "./objectUtils";
+import { first } from "./array";
+import { isEmpty, isUndefined } from "./assertions";
 
 type NumberLike = string | number | bigint | boolean;
 
+export const _0n = BigInt(0);
+export const _1n = BigInt(1);
+export const _7n = BigInt(7);
+export const _10n = BigInt(10);
+export const _63n = BigInt(63);
+export const _127n = BigInt(127);
+export const _128n = BigInt(128);
+
 export function ensureBigInt(number: NumberLike): bigint {
   return typeof number === "bigint" ? number : BigInt(number);
 }
@@ -92,6 +99,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,
@@ -150,74 +161,26 @@ export function sumBy<T>(
   return acc;
 }
 
-/**
- * Converts a hex string to bigint.
- * @param hex The hex string to be converted.
- * @returns The bigint value represented by the hex string.
- */
-export function hexToBigInt(hex: string): bigint {
-  // https://coolaj86.com/articles/convert-hex-to-decimal-with-js-bigints/
-  if (hex.length % 2) {
-    hex = "0" + hex;
-  }
-
-  const value = BigInt("0x" + hex);
-  const highByte = parseInt(hex.slice(0, 2), 16);
-
-  if (0x80 & highByte) {
-    return -_bitNegate(value); // add two's complement and invert the number to negative
-  }
-
-  return value;
-}
-
-/**
- * Serializes a `BigInt` to a hex string
- * @param value The bigint value to be serialized
- * @returns Hex representation for the provided `number`.
- */
-export function bigIntToHex(value: bigint): string {
-  // implementation inspired on
-  // https://coolaj86.com/articles/convert-decimal-to-hex-with-js-bigints/
-  const positive = value >= _0n;
-  if (!positive) {
-    value = _bitNegate(value);
-  }
+export function min<T extends bigint | number>(...numbers: T[]): T {
+  let min = first(numbers);
 
-  let hex = value.toString(16);
-  if (hex.length % 2) {
-    hex = "0" + hex;
-  }
-
-  if (positive && 0x80 & parseInt(hex.slice(0, 2), 16)) {
-    hex = "00" + hex;
+  for (const num of numbers) {
+    if (num < min) {
+      min = num;
+    }
   }
 
-  return hex;
+  return min;
 }
 
-/**
- * Returns the two’s complement of a bigint value.
- * @param value The bigint value to negate.
- * @returns The two’s complement of `number` as a bigint.
- */
-export function _bitNegate(value: bigint): bigint {
-  const negative = value < _0n;
-  if (negative) {
-    value = -value; // turn into a positive number
-  }
-
-  const bits = value.toString(2);
-  let bitLen = bits.length; // convert to binary
+export function max<T extends bigint | number>(...numbers: T[]): T {
+  let max = first(numbers);
 
-  const mod = bitLen % 8;
-  if (mod > 0) {
-    bitLen += 8 - mod;
-  } else if (negative && first(bits) === "1" && bits.indexOf("1", 1) !== -1) {
-    bitLen += 8;
+  for (const num of numbers) {
+    if (num > max) {
+      max = num;
+    }
   }
 
-  const mask = (1n << BigInt(bitLen)) - 1n; // create a mask
-
-  return (~value & mask) + 1n; // invert bits, mask it, and add one
+  return max;
 }

package/src/utils/bytes.bench.ts

@@ -0,0 +1,43 @@
+import { bench, describe } from "vitest";
+import { isHex } from "./bytes";
+
+const HEX_PATTERN = /^[0-9A-Fa-f]+$/s;
+export function isHexRegex(value?: string) {
+  if (!value || value.length % 2) return false;
+
+  return HEX_PATTERN.test(value);
+}
+
+const HEX_CHARSET = new Set("0123456789abcdefABCDEF");
+function isHexChar(value: string) {
+  if (!value || value.length % 2) return false;
+
+  const valueSet = new Set(Array.from(value));
+  for (const c of valueSet) {
+    if (!HEX_CHARSET.has(c)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+describe("Hex string checking", () => {
+  const validHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7";
+  const invalidHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7tt";
+
+  bench("Using charset", () => {
+    isHexChar(validHex);
+    isHexChar(invalidHex);
+  });
+
+  bench("Using regex", () => {
+    isHexRegex(validHex);
+    isHexRegex(invalidHex);
+  });
+
+  bench("Using number constructor", () => {
+    isHex(validHex);
+    isHex(invalidHex);
+  });
+});

package/src/utils/bytes.ts

@@ -0,0 +1,34 @@
+import { assertInstanceOf } from ".";
+
+export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
+  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
+
+  let pad = 0;
+  for (const bytes of arrays) {
+    assertInstanceOf(bytes, Uint8Array);
+
+    r.set(bytes, pad);
+    pad += bytes.length;
+  }
+
+  return r;
+}
+
+export function isHex(value?: string) {
+  if (!value || value.length % 2) return false;
+
+  if (!value.startsWith("0x")) {
+    value = "0x" + value;
+  }
+
+  return !isNaN(Number(value));
+}
+
+/**
+ * Get hex string size in bytes
+ * @param hex
+ * @returns the byte size if the hex string
+ */
+export function byteSizeOf(hex: string): number {
+  return hex.length / 2;
+}

package/src/utils/index.ts

@@ -1,6 +1,6 @@
-export * from "./arrayUtils";
-export * from "./bigIntLiterals";
-export * from "./bigIntUtils";
-export * from "./boxUtils";
-export * from "./objectUtils";
-export * from "./stringUtils";
+export * from "./array";
+export * from "./bigInt";
+export * from "./utxo";
+export * from "./object";
+export * from "./assertions";
+export * from "./bytes";

package/src/utils/object.ts

@@ -0,0 +1,28 @@
+import { isEmpty, isUndefined } from "./assertions";
+
+export function clearUndefined(value: Record<string, unknown>) {
+  const result: Record<string, unknown> = {};
+  for (const key in value) {
+    const val = value[key];
+    if (!isUndefined(val)) {
+      result[key] = val;
+    }
+  }
+
+  return result;
+}
+
+export function ensureDefaults<T extends Partial<R>, R extends object = Required<T>>(
+  options: T | undefined,
+  defaults: R
+): R & T {
+  if (isEmpty(options)) return defaults as R & T;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const newObj: any = { ...defaults, ...options };
+  for (const key in newObj) {
+    newObj[key as keyof object] = options[key as keyof R] ?? defaults[key as keyof R];
+  }
+
+  return newObj;
+}

package/src/utils/{boxUtils.ts → utxo.ts}

@@ -1,8 +1,15 @@
-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";
+import {
+  Amount,
+  AmountType,
+  Box,
+  BoxCandidate,
+  NonMandatoryRegisters,
+  TokenAmount,
+  TokenId
+} from "../types";
+import { isDefined, isEmpty, isUndefined } from "./assertions";
+import { ensureBigInt } from "./bigInt";
+import { _0n } from "./bigInt";
 
 const NANOERGS_TOKEN_ID = "nanoErgs";
 
@@ -159,3 +166,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/dist/cjs/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./utils";
-export * from "./types";

package/dist/cjs/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./utils"), exports);
-__exportStar(require("./types"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,0CAAwB"}

package/dist/cjs/types/boxes.d.ts

@@ -1,22 +0,0 @@
-import { ErgoTree } from "./common";
-import { NonMandatoryRegisters } from "./registers";
-import { TokenAmount } from "./token";
-import { TransactionId } from "./transactions";
-export type BoxId = string;
-export type AmountType = string | bigint;
-type BoxBaseType<T extends AmountType, R extends NonMandatoryRegisters> = {
-    ergoTree: ErgoTree;
-    creationHeight: number;
-    value: T;
-    assets: TokenAmount<T>[];
-    additionalRegisters: R;
-};
-export type BoxCandidate<T extends AmountType, R extends NonMandatoryRegisters = NonMandatoryRegisters> = BoxBaseType<T, R> & {
-    boxId?: BoxId;
-};
-export type Box<T extends AmountType, R extends NonMandatoryRegisters = NonMandatoryRegisters> = BoxBaseType<T, R> & {
-    boxId: BoxId;
-    transactionId: TransactionId;
-    index: number;
-};
-export {};

package/dist/cjs/types/boxes.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=boxes.js.map

package/dist/cjs/types/boxes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boxes.js","sourceRoot":"","sources":["../../../src/types/boxes.ts"],"names":[],"mappings":""}