@fleet-sdk/common 0.1.0-alpha.12

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@fleet-sdk/common",
+  "version": "0.1.0-alpha.12",
+  "description": "Internal utility functions, constants and types shared across @fleet-sdk packages.",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "typings": "dist/esm/index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fleet-sdk/fleet.git",
+    "directory": "packages/common"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ergo",
+    "blockchain"
+  ],
+  "engines": {
+    "node": ">=10"
+  },
+  "files": [
+    "src",
+    "dist",
+    "!**/*.spec.*",
+    "!**/*.json",
+    "!tests",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "run-p build:*",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "fix": "run-s fix:*",
+    "fix:prettier": "prettier src/**/*.ts --write",
+    "fix:lint": "eslint src --ext .ts --fix",
+    "test": "run-s build test:*",
+    "test:lint": "eslint src --ext .ts",
+    "test:prettier": "prettier src/**/*.ts --list-different",
+    "test:unit": "jest",
+    "watch:build": "tsc -p tsconfig.json -w",
+    "watch:test": "jest --watch",
+    "cov:html": "jest --coverage --coverageReporters=html ; open-cli coverage/index.html",
+    "cov:json": "jest --coverage --coverageReporters=json",
+    "cov:check": "jest --coverage --coverageReporters=text"
+  }
+}

package/src/index.ts

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

package/src/types/boxes.ts

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

package/src/types/common.ts

@@ -0,0 +1,22 @@
+export type HexString = string;
+export type ErgoTree = string;
+export type Base58String = string;
+export type Amount = string | bigint;
+
+export type SortingSelector<T> = (item: T) => string | number | bigint;
+export type SortingDirection = "asc" | "desc";
+
+export type FilterPredicate<T> = (item: T) => boolean;
+
+export type BuildOutputType = "default" | "EIP-12";
+
+export enum Network {
+  Mainnet = 0 << 4,
+  Testnet = 1 << 4
+}
+
+export enum AddressType {
+  P2PK = 1,
+  P2SH = 2,
+  P2S = 3
+}

package/src/types/contextExtension.ts

@@ -0,0 +1,3 @@
+import { HexString } from "./common";
+
+export type ContextExtension = { [key: number]: HexString | undefined };

package/src/types/index.ts

@@ -0,0 +1,8 @@
+export * from "./boxes";
+export * from "./contextExtension";
+export * from "./inputs";
+export * from "./common";
+export * from "./proverResult";
+export * from "./registers";
+export * from "./token";
+export * from "./transactions";

package/src/types/inputs.ts

@@ -0,0 +1,42 @@
+import { BoxId } from "./boxes";
+import { ErgoTree } from "./common";
+import { ContextExtension } from "./contextExtension";
+import { ProverResult } from "./proverResult";
+import { NonMandatoryRegisters } from "./registers";
+import { TokenAmount } from "./token";
+import { TransactionId } from "./transactions";
+
+export type SignedInput = {
+  readonly boxId: BoxId;
+  readonly spendingProof: ProverResult;
+};
+
+export type UnsignedInput = {
+  boxId: BoxId;
+  extension: ContextExtension;
+};
+
+export type EIP12UnsignedInput = UnsignedInput & {
+  transactionId: TransactionId;
+  index: number;
+  ergoTree: ErgoTree;
+  creationHeight: number;
+  value: string;
+  assets: TokenAmount<string>[];
+  additionalRegisters: NonMandatoryRegisters;
+};
+
+export type EIP12UnsignedDataInput = {
+  boxId: BoxId;
+  transactionId: TransactionId;
+  index: number;
+  ergoTree: ErgoTree;
+  creationHeight: number;
+  value: string;
+  assets: TokenAmount<string>[];
+  additionalRegisters: NonMandatoryRegisters;
+};
+
+export type DataInput = {
+  boxId: BoxId;
+};

package/src/types/proverResult.ts

@@ -0,0 +1,7 @@
+import { HexString } from "./common";
+import { ContextExtension } from "./contextExtension";
+
+export type ProverResult = {
+  readonly proofBytes: HexString;
+  readonly extension: ContextExtension;
+};

package/src/types/registers.ts

@@ -0,0 +1,10 @@
+import { HexString } from "./common";
+
+export type NonMandatoryRegisters = {
+  R4?: HexString;
+  R5?: HexString;
+  R6?: HexString;
+  R7?: HexString;
+  R8?: HexString;
+  R9?: HexString;
+};

package/src/types/token.ts

@@ -0,0 +1,21 @@
+export type TokenId = string;
+
+type TokenBase<AmountType> = {
+  amount: AmountType;
+};
+
+export type TokenAmount<AmountType> = TokenBase<AmountType> & {
+  tokenId: TokenId;
+};
+
+export type NewToken<AmountType> = TokenBase<AmountType> & {
+  tokenId?: TokenId;
+  name?: string;
+  decimals?: number;
+  description?: string;
+};
+
+export type TokenTargetAmount<AmountType> = {
+  tokenId: TokenId;
+  amount?: AmountType;
+};

package/src/types/transactions.ts

@@ -0,0 +1,32 @@
+import { Box, BoxCandidate } from "./boxes";
+import { Amount } from "./common";
+import {
+  DataInput,
+  EIP12UnsignedDataInput,
+  EIP12UnsignedInput,
+  SignedInput,
+  UnsignedInput
+} from "./inputs";
+
+export type TransactionId = string;
+
+export type UnsignedTransaction = {
+  id?: TransactionId;
+  inputs: UnsignedInput[];
+  dataInputs: DataInput[];
+  outputs: BoxCandidate<Amount>[];
+};
+
+export type EIP12UnsignedTransaction = {
+  id?: TransactionId;
+  inputs: EIP12UnsignedInput[];
+  dataInputs: EIP12UnsignedDataInput[];
+  outputs: BoxCandidate<string>[];
+};
+
+export type SignedTransaction = {
+  readonly id: TransactionId;
+  readonly inputs: SignedInput[];
+  readonly dataInputs: DataInput[];
+  readonly outputs: Box<Amount>[];
+};

package/src/utils/arrayUtils.ts

@@ -0,0 +1,135 @@
+import { SortingDirection, SortingSelector } from "../types";
+
+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 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;
+  }
+
+  if (!array[0]) {
+    throw Error("Empty array.");
+  }
+
+  return array[0];
+}
+
+/**
+ * Check for duplicate elements using the equality operator
+ */
+export function hasDuplicates<T>(array: T[]): boolean {
+  return array.some((item, index) => {
+    return array.indexOf(item) !== index;
+  });
+}
+
+/**
+ * Check for duplicate keys in complex elements
+ */
+export function hasDuplicatesBy<T>(array: T[], selector: (value: T) => unknown): boolean {
+  return array.some((item, index) => {
+    return array.findIndex((x) => selector(x) === selector(item)) !== index;
+  });
+}
+
+export function chunk<T>(array: T[], size: number): T[][] {
+  if (array.length <= size) {
+    return [array];
+  }
+
+  const chunks: T[][] = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+
+  return chunks;
+}
+
+export function orderBy<T>(
+  array: T[],
+  iteratee: SortingSelector<T>,
+  order: SortingDirection = "asc"
+): T[] {
+  return array.sort((a: T, b: T) => {
+    if (iteratee(a) > iteratee(b)) {
+      return order === "asc" ? 1 : -1;
+    } else if (iteratee(a) < iteratee(b)) {
+      return order === "asc" ? -1 : 1;
+    } else {
+      return 0;
+    }
+  });
+}
+
+export function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean {
+  if (array1 === array2) {
+    return true;
+  }
+
+  if (array1.length != array2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < array1.length; i++) {
+    if (array1[i] !== array2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function startsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
+  if (array === target) {
+    return true;
+  }
+
+  if (target.length > array.length) {
+    return false;
+  }
+
+  for (let i = 0; i < target.length; i++) {
+    if (target[i] !== array[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function endsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
+  if (array === target) {
+    return true;
+  }
+
+  if (target.length > array.length) {
+    return false;
+  }
+
+  const offset = array.length - target.length;
+
+  for (let i = target.length - 1; i >= 0; i--) {
+    if (target[i] !== array[i + offset]) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/utils/bigIntLiterals.ts

@@ -0,0 +1,7 @@
+// Make some ECMAScript parsers happy by not using bigint literals like 123n
+
+export const _0n = BigInt(0);
+export const _1n = BigInt(1);
+export const _7n = BigInt(7);
+export const _63n = BigInt(63);
+export const _127n = BigInt(127);

package/src/utils/bigIntUtils.ts

@@ -0,0 +1,26 @@
+import { isEmpty } from "./arrayUtils";
+import { _0n } from "./bigIntLiterals";
+import { isUndefined } from "./objectUtils";
+
+export function ensureBigInt(number: string | number | bigint | boolean): bigint {
+  return typeof number === "bigint" ? number : BigInt(number);
+}
+
+export function sumBy<T>(
+  collection: T[],
+  iteratee: (value: T) => bigint,
+  condition?: (value: T) => boolean
+): bigint {
+  let acc = _0n;
+  if (isEmpty(collection)) {
+    return acc;
+  }
+
+  for (const item of collection) {
+    if (isUndefined(condition) || condition(item)) {
+      acc += iteratee(item);
+    }
+  }
+
+  return acc;
+}

package/src/utils/boxUtils.ts

@@ -0,0 +1,77 @@
+import { Amount, NonMandatoryRegisters, TokenId } from "../types";
+import { _0n } from "./bigIntLiterals";
+import { ensureBigInt } from "./bigIntUtils";
+import { isDefined, isUndefined } from "./objectUtils";
+
+const NANOERGS_TOKEN_ID = "nanoErgs";
+
+export function utxoSum(boxes: MinimalBoxAmountFields[]): BoxAmounts;
+export function utxoSum(boxes: MinimalBoxAmountFields[], tokenId: TokenId): bigint;
+export function utxoSum(boxes: MinimalBoxAmountFields[], tokenId?: TokenId): BoxAmounts | bigint {
+  const balances: { [tokenId: string]: bigint } = {};
+
+  for (const box of boxes) {
+    if (isUndefined(tokenId) || tokenId === NANOERGS_TOKEN_ID) {
+      balances[NANOERGS_TOKEN_ID] = (balances[NANOERGS_TOKEN_ID] || _0n) + ensureBigInt(box.value);
+    }
+
+    if (tokenId !== NANOERGS_TOKEN_ID) {
+      for (const token of box.assets) {
+        if (isDefined(tokenId) && tokenId !== token.tokenId) {
+          continue;
+        }
+
+        balances[token.tokenId] = (balances[token.tokenId] || _0n) + ensureBigInt(token.amount);
+      }
+    }
+  }
+
+  if (isDefined(tokenId)) {
+    return balances[tokenId] || _0n;
+  }
+
+  return {
+    nanoErgs: balances[NANOERGS_TOKEN_ID],
+    tokens: Object.keys(balances)
+      .filter((x) => x !== NANOERGS_TOKEN_ID)
+      .map((tokenId) => ({ tokenId, amount: balances[tokenId] }))
+  };
+}
+
+const MIN_REGISTER_NUMBER = 4;
+const MAX_REGISTER_NUMBER = 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;
+        continue;
+      }
+
+      if (i - lastValueIndex > 1) {
+        return false;
+      }
+
+      lastValueIndex = i;
+    }
+  }
+
+  return true;
+}
+
+type TokenAmount<AmountType> = {
+  tokenId: TokenId;
+  amount: AmountType;
+};
+
+export type BoxAmounts = {
+  nanoErgs: bigint;
+  tokens: TokenAmount<bigint>[];
+};
+
+type MinimalBoxAmountFields = {
+  value: Amount;
+  assets: TokenAmount<Amount>[];
+};

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from "./arrayUtils";
+export * from "./bigIntLiterals";
+export * from "./bigIntUtils";
+export * from "./boxUtils";
+export * from "./objectUtils";
+export * from "./stringUtils";

package/src/utils/objectUtils.ts

@@ -0,0 +1,19 @@
+export function removeUndefined(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 isUndefined(value: unknown): value is undefined {
+  return value === undefined || value === null || Number.isNaN(value);
+}
+
+export function isDefined<T>(value: T | undefined): value is T {
+  return !isUndefined(value);
+}

package/src/utils/stringUtils.ts

@@ -0,0 +1,9 @@
+const HEX_PATTERN = /^[0-9A-Fa-f]+$/s;
+
+export function isHex(value?: string) {
+  if (!value) {
+    return false;
+  }
+
+  return HEX_PATTERN.test(value);
+}