@fleet-sdk/common 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @fleet-sdk/common
 
+## 0.2.0
+
+### Minor Changes
+
+- 5a79c57: Add `concatBytes()` function.
+- a491ab9: Add `ensureDefaults()` function.
+- 3236dd8: Add new assertion functions:
+  - `assertTypeOf()` - uses `typeof` to check for JavaScript type primitives;
+  - `assertInstanceOf()` - uses `instanceof` to check for object instances.
+- 9bd393b: Add `depthOf()` function.
+
 ## 0.1.3
 
 ### Patch Changes

package/README.md

@@ -1,3 +1,3 @@
-# @fleet-sdk/core [![License](https://badgen.net/github/license/fleet-sdk/fleet/)](https://github.com/fleet-sdk/fleet/blob/master/LICENSE) [![npm](https://badgen.net/npm/v/@fleet-sdk/common)](https://www.npmjs.com/package/@fleet-sdk/common)
+# @fleet-sdk/common [![License](https://badgen.net/github/license/fleet-sdk/fleet/)](https://github.com/fleet-sdk/fleet/blob/master/LICENSE) [![npm](https://badgen.net/npm/v/@fleet-sdk/common)](https://www.npmjs.com/package/@fleet-sdk/common)
 
 Internal utility functions, constants and types shared across @fleet-sdk packages.

package/dist/index.d.mts

@@ -0,0 +1,268 @@
+type HexString = string;
+type ErgoTreeHex = string;
+type Base58String = string;
+type Amount = string | bigint;
+type OneOrMore<T> = T | T[];
+type SortingSelector<T> = (item: T) => string | number | bigint;
+type SortingDirection = "asc" | "desc";
+type FilterPredicate<T> = (item: T) => boolean;
+type BuildOutputType = "default" | "EIP-12";
+declare enum Network {
+    Mainnet = 0,
+    Testnet = 16
+}
+declare enum AddressType {
+    P2PK = 1,
+    P2SH = 2,
+    P2S = 3
+}
+declare const ergoTreeHeaderFlags: {
+    readonly sizeInclusion: 8;
+    readonly constantSegregation: 16;
+};
+type ErgoTreeHeaderFlag = (typeof ergoTreeHeaderFlags)[keyof typeof ergoTreeHeaderFlags];
+
+type NonMandatoryRegisters = {
+    R4?: HexString;
+    R5?: HexString;
+    R6?: HexString;
+    R7?: HexString;
+    R8?: HexString;
+    R9?: HexString;
+};
+
+type TokenId = string;
+type TokenBase<AmountType> = {
+    amount: AmountType;
+};
+type TokenAmount<AmountType> = TokenBase<AmountType> & {
+    tokenId: TokenId;
+};
+type NewToken<AmountType> = TokenBase<AmountType> & {
+    tokenId?: TokenId;
+    name?: string;
+    decimals?: number;
+    description?: string;
+};
+type TokenTargetAmount<AmountType> = {
+    tokenId: TokenId;
+    amount?: AmountType;
+};
+
+type ContextExtension = {
+    [key: number]: HexString | undefined;
+};
+
+type ProverResult = {
+    readonly proofBytes: HexString;
+    readonly extension: ContextExtension;
+};
+
+type SignedInput = {
+    readonly boxId: BoxId;
+    readonly spendingProof: ProverResult;
+};
+type UnsignedInput = {
+    boxId: BoxId;
+    extension: ContextExtension;
+};
+type EIP12UnsignedInput = UnsignedInput & {
+    transactionId: TransactionId;
+    index: number;
+    ergoTree: ErgoTreeHex;
+    creationHeight: number;
+    value: string;
+    assets: TokenAmount<string>[];
+    additionalRegisters: NonMandatoryRegisters;
+};
+type EIP12UnsignedDataInput = {
+    boxId: BoxId;
+    transactionId: TransactionId;
+    index: number;
+    ergoTree: ErgoTreeHex;
+    creationHeight: number;
+    value: string;
+    assets: TokenAmount<string>[];
+    additionalRegisters: NonMandatoryRegisters;
+};
+type DataInput = {
+    boxId: BoxId;
+};
+
+type TransactionId = string;
+type UnsignedTransaction = {
+    id?: TransactionId;
+    inputs: UnsignedInput[];
+    dataInputs: DataInput[];
+    outputs: BoxCandidate<Amount>[];
+};
+type EIP12UnsignedTransaction = {
+    id?: TransactionId;
+    inputs: EIP12UnsignedInput[];
+    dataInputs: EIP12UnsignedDataInput[];
+    outputs: BoxCandidate<string>[];
+};
+type SignedTransaction = {
+    readonly id: TransactionId;
+    readonly inputs: SignedInput[];
+    readonly dataInputs: DataInput[];
+    readonly outputs: Box<Amount>[];
+};
+
+type BoxId = string;
+type AmountType = string | bigint;
+type BoxBaseType<T extends AmountType, R extends NonMandatoryRegisters> = {
+    ergoTree: ErgoTreeHex;
+    creationHeight: number;
+    value: T;
+    assets: TokenAmount<T>[];
+    additionalRegisters: R;
+};
+type BoxCandidate<T extends AmountType, R extends NonMandatoryRegisters = NonMandatoryRegisters> = BoxBaseType<T, R> & {
+    boxId?: BoxId;
+};
+type Box<T extends AmountType, R extends NonMandatoryRegisters = NonMandatoryRegisters> = BoxBaseType<T, R> & {
+    boxId: BoxId;
+    transactionId: TransactionId;
+    index: number;
+};
+
+type ObjectSelector<T> = (item: T) => T[keyof T];
+declare function first(array: undefined): undefined;
+declare function first<T>(array: ArrayLike<T>): T;
+declare function last(array: undefined): undefined;
+declare function last<T>(array: ArrayLike<T>): T;
+declare function at(array: undefined, index: number): undefined;
+declare function at<T>(array: ArrayLike<T>, index: number): T;
+/**
+ * Check for duplicate elements using the equality operator
+ */
+declare function hasDuplicates<T>(array: T[]): boolean;
+/**
+ * Check for duplicate keys in complex elements
+ */
+declare function hasDuplicatesBy<T>(array: T[], selector: ObjectSelector<T>): boolean;
+declare function chunk<T>(array: T[], size: number): T[][];
+declare function orderBy<T>(array: T[], iteratee: SortingSelector<T>, order?: SortingDirection): T[];
+declare function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean;
+declare function areEqualBy<T>(array1: ArrayLike<T>, array2: ArrayLike<T>, selector: ObjectSelector<T>): boolean;
+declare function startsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean;
+declare function endsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean;
+declare function uniq<T>(array: Array<T>): Array<T>;
+declare function uniqBy<T>(array: Array<T>, selector: ObjectSelector<T>, selection?: "keep-first" | "keep-last"): Array<T>;
+declare function depthOf(array: unknown | unknown[]): number;
+
+type NumberLike = string | number | bigint | boolean;
+declare const _0n: bigint;
+declare const _1n: bigint;
+declare const _7n: bigint;
+declare const _10n: bigint;
+declare const _63n: bigint;
+declare const _127n: bigint;
+declare const _128n: bigint;
+declare function ensureBigInt(number: NumberLike): bigint;
+type ParsingOptions = {
+    /**
+     * Number of decimals.
+     */
+    decimals?: number;
+    /**
+     * Thousand mark char.
+     * Default: `.`
+     */
+    decimalMark?: string;
+};
+declare function undecimalize(decimalStr: string, options?: ParsingOptions | number): bigint;
+type FormattingOptions = {
+    /**
+     * Number of decimals.
+     */
+    decimals: number;
+    /**
+     * Thousand mark char.
+     */
+    thousandMark?: string;
+    /**
+     * Decimal mark char.
+     * Default: `.`
+     */
+    decimalMark?: string;
+};
+declare function decimalize(value: Amount, options?: FormattingOptions | number): string;
+declare function percent(value: bigint, percentage: bigint, precision?: bigint): bigint;
+declare function sumBy<T>(collection: readonly T[], iteratee: (value: T) => bigint, condition?: (value: T) => boolean): bigint;
+declare function min<T extends bigint | number>(...numbers: T[]): T;
+declare function max<T extends bigint | number>(...numbers: T[]): T;
+
+declare function utxoSum(boxes: MinimalBoxAmounts): BoxSummary;
+declare function utxoSum(boxes: MinimalBoxAmounts, tokenId: TokenId): bigint;
+declare function utxoDiff(minuend: BoxSummary | Box<Amount>[], subtrahend: BoxSummary | Box<Amount>[]): BoxSummary;
+declare function areRegistersDenselyPacked(registers: NonMandatoryRegisters): boolean;
+declare function utxoFilter<T extends AmountType>(utxos: Box<T>[], filterParams: UTxOFilterParams<T>): Box<T>[];
+type UTxOFilterParams<T extends AmountType> = {
+    by?: (utxo: Box<T>) => boolean;
+    max?: {
+        count?: number;
+        aggregatedDistinctTokens?: number;
+    };
+};
+type BoxSummary = {
+    nanoErgs: bigint;
+    tokens: TokenAmount<bigint>[];
+};
+type MinimalBoxAmounts = readonly {
+    value: Amount;
+    assets: TokenAmount<Amount>[];
+}[];
+declare function ensureUTxOBigInt(box: Box<Amount>): Box<bigint>;
+declare function ensureUTxOBigInt(candidate: BoxCandidate<Amount>): BoxCandidate<bigint>;
+
+declare function clearUndefined(value: Record<string, unknown>): Record<string, unknown>;
+declare function ensureDefaults<T extends Partial<R>, R extends object = Required<T>>(options: T | undefined, defaults: R): R & T;
+
+type AssertErrorMessageInput = string | Error | (() => string);
+type Constructable = Function;
+type JSPrimitiveTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+declare function assert(condition: boolean, error: AssertErrorMessageInput): asserts condition;
+declare function assertTypeOf<T>(obj: T, expected: JSPrimitiveTypes): asserts obj;
+declare function assertInstanceOf<T>(obj: T, expected: Constructable): asserts obj;
+declare function isEmpty<T extends object>(obj?: T): obj is undefined;
+declare function isEmpty<T>(array?: T[]): array is undefined;
+declare function some<T extends object>(obj?: T): obj is T;
+declare function some<T>(array?: T[]): array is T[];
+declare function isTruthy<T>(value?: T): value is NonNullable<T>;
+declare function isFalsy<T>(value?: T): value is undefined;
+declare function isUndefined(v: unknown): v is undefined;
+declare function isDefined<T>(v: T | undefined): v is T;
+declare function hasKey(o: unknown, key: PropertyKey): boolean;
+
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+declare function isHex(value?: string): boolean;
+/**
+ * Get hex string size in bytes
+ * @param hex
+ * @returns the byte size if the hex string
+ */
+declare function byteSizeOf(hex: string): number;
+
+type CollectionAddOptions = {
+    index?: number;
+};
+declare abstract class Collection<InternalType, ExternalType> implements Iterable<InternalType> {
+    protected readonly _items: InternalType[];
+    constructor();
+    protected _isIndexOutOfBounds(index: number): boolean;
+    [Symbol.iterator](): Iterator<InternalType>;
+    get length(): number;
+    get isEmpty(): boolean;
+    at(index: number): InternalType;
+    add(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number;
+    abstract remove(item: unknown): number;
+    protected abstract _map(item: ExternalType | InternalType): InternalType;
+    protected _addOne(item: InternalType | ExternalType, options?: CollectionAddOptions): number;
+    protected _addOneOrMore(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number;
+    toArray(): InternalType[];
+    reduce<U>(callbackFn: (accumulator: U, currentValue: InternalType, currentIndex: number, array: InternalType[]) => U, initialValue: U): U;
+}
+
+export { AddressType, Amount, AmountType, AssertErrorMessageInput, Base58String, Box, BoxCandidate, BoxId, BoxSummary, BuildOutputType, Collection, CollectionAddOptions, ContextExtension, DataInput, EIP12UnsignedDataInput, EIP12UnsignedInput, EIP12UnsignedTransaction, ErgoTreeHeaderFlag, ErgoTreeHex, FilterPredicate, HexString, MinimalBoxAmounts, Network, NewToken, NonMandatoryRegisters, OneOrMore, ProverResult, SignedInput, SignedTransaction, SortingDirection, SortingSelector, TokenAmount, TokenId, TokenTargetAmount, TransactionId, UTxOFilterParams, UnsignedInput, UnsignedTransaction, _0n, _10n, _127n, _128n, _1n, _63n, _7n, areEqual, areEqualBy, areRegistersDenselyPacked, assert, assertInstanceOf, assertTypeOf, at, byteSizeOf, chunk, clearUndefined, concatBytes, decimalize, depthOf, endsWith, ensureBigInt, ensureDefaults, ensureUTxOBigInt, ergoTreeHeaderFlags, first, hasDuplicates, hasDuplicatesBy, hasKey, isDefined, isEmpty, isFalsy, isHex, isTruthy, isUndefined, last, max, min, orderBy, percent, some, startsWith, sumBy, undecimalize, uniq, uniqBy, utxoDiff, utxoFilter, utxoSum };

package/dist/index.d.ts

@@ -0,0 +1,268 @@
+type HexString = string;
+type ErgoTreeHex = string;
+type Base58String = string;
+type Amount = string | bigint;
+type OneOrMore<T> = T | T[];
+type SortingSelector<T> = (item: T) => string | number | bigint;
+type SortingDirection = "asc" | "desc";
+type FilterPredicate<T> = (item: T) => boolean;
+type BuildOutputType = "default" | "EIP-12";
+declare enum Network {
+    Mainnet = 0,
+    Testnet = 16
+}
+declare enum AddressType {
+    P2PK = 1,
+    P2SH = 2,
+    P2S = 3
+}
+declare const ergoTreeHeaderFlags: {
+    readonly sizeInclusion: 8;
+    readonly constantSegregation: 16;
+};
+type ErgoTreeHeaderFlag = (typeof ergoTreeHeaderFlags)[keyof typeof ergoTreeHeaderFlags];
+
+type NonMandatoryRegisters = {
+    R4?: HexString;
+    R5?: HexString;
+    R6?: HexString;
+    R7?: HexString;
+    R8?: HexString;
+    R9?: HexString;
+};
+
+type TokenId = string;
+type TokenBase<AmountType> = {
+    amount: AmountType;
+};
+type TokenAmount<AmountType> = TokenBase<AmountType> & {
+    tokenId: TokenId;
+};
+type NewToken<AmountType> = TokenBase<AmountType> & {
+    tokenId?: TokenId;
+    name?: string;
+    decimals?: number;
+    description?: string;
+};
+type TokenTargetAmount<AmountType> = {
+    tokenId: TokenId;
+    amount?: AmountType;
+};
+
+type ContextExtension = {
+    [key: number]: HexString | undefined;
+};
+
+type ProverResult = {
+    readonly proofBytes: HexString;
+    readonly extension: ContextExtension;
+};
+
+type SignedInput = {
+    readonly boxId: BoxId;
+    readonly spendingProof: ProverResult;
+};
+type UnsignedInput = {
+    boxId: BoxId;
+    extension: ContextExtension;
+};
+type EIP12UnsignedInput = UnsignedInput & {
+    transactionId: TransactionId;
+    index: number;
+    ergoTree: ErgoTreeHex;
+    creationHeight: number;
+    value: string;
+    assets: TokenAmount<string>[];
+    additionalRegisters: NonMandatoryRegisters;
+};
+type EIP12UnsignedDataInput = {
+    boxId: BoxId;
+    transactionId: TransactionId;
+    index: number;
+    ergoTree: ErgoTreeHex;
+    creationHeight: number;
+    value: string;
+    assets: TokenAmount<string>[];
+    additionalRegisters: NonMandatoryRegisters;
+};
+type DataInput = {
+    boxId: BoxId;
+};
+
+type TransactionId = string;
+type UnsignedTransaction = {
+    id?: TransactionId;
+    inputs: UnsignedInput[];
+    dataInputs: DataInput[];
+    outputs: BoxCandidate<Amount>[];
+};
+type EIP12UnsignedTransaction = {
+    id?: TransactionId;
+    inputs: EIP12UnsignedInput[];
+    dataInputs: EIP12UnsignedDataInput[];
+    outputs: BoxCandidate<string>[];
+};
+type SignedTransaction = {
+    readonly id: TransactionId;
+    readonly inputs: SignedInput[];
+    readonly dataInputs: DataInput[];
+    readonly outputs: Box<Amount>[];
+};
+
+type BoxId = string;
+type AmountType = string | bigint;
+type BoxBaseType<T extends AmountType, R extends NonMandatoryRegisters> = {
+    ergoTree: ErgoTreeHex;
+    creationHeight: number;
+    value: T;
+    assets: TokenAmount<T>[];
+    additionalRegisters: R;
+};
+type BoxCandidate<T extends AmountType, R extends NonMandatoryRegisters = NonMandatoryRegisters> = BoxBaseType<T, R> & {
+    boxId?: BoxId;
+};
+type Box<T extends AmountType, R extends NonMandatoryRegisters = NonMandatoryRegisters> = BoxBaseType<T, R> & {
+    boxId: BoxId;
+    transactionId: TransactionId;
+    index: number;
+};
+
+type ObjectSelector<T> = (item: T) => T[keyof T];
+declare function first(array: undefined): undefined;
+declare function first<T>(array: ArrayLike<T>): T;
+declare function last(array: undefined): undefined;
+declare function last<T>(array: ArrayLike<T>): T;
+declare function at(array: undefined, index: number): undefined;
+declare function at<T>(array: ArrayLike<T>, index: number): T;
+/**
+ * Check for duplicate elements using the equality operator
+ */
+declare function hasDuplicates<T>(array: T[]): boolean;
+/**
+ * Check for duplicate keys in complex elements
+ */
+declare function hasDuplicatesBy<T>(array: T[], selector: ObjectSelector<T>): boolean;
+declare function chunk<T>(array: T[], size: number): T[][];
+declare function orderBy<T>(array: T[], iteratee: SortingSelector<T>, order?: SortingDirection): T[];
+declare function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean;
+declare function areEqualBy<T>(array1: ArrayLike<T>, array2: ArrayLike<T>, selector: ObjectSelector<T>): boolean;
+declare function startsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean;
+declare function endsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean;
+declare function uniq<T>(array: Array<T>): Array<T>;
+declare function uniqBy<T>(array: Array<T>, selector: ObjectSelector<T>, selection?: "keep-first" | "keep-last"): Array<T>;
+declare function depthOf(array: unknown | unknown[]): number;
+
+type NumberLike = string | number | bigint | boolean;
+declare const _0n: bigint;
+declare const _1n: bigint;
+declare const _7n: bigint;
+declare const _10n: bigint;
+declare const _63n: bigint;
+declare const _127n: bigint;
+declare const _128n: bigint;
+declare function ensureBigInt(number: NumberLike): bigint;
+type ParsingOptions = {
+    /**
+     * Number of decimals.
+     */
+    decimals?: number;
+    /**
+     * Thousand mark char.
+     * Default: `.`
+     */
+    decimalMark?: string;
+};
+declare function undecimalize(decimalStr: string, options?: ParsingOptions | number): bigint;
+type FormattingOptions = {
+    /**
+     * Number of decimals.
+     */
+    decimals: number;
+    /**
+     * Thousand mark char.
+     */
+    thousandMark?: string;
+    /**
+     * Decimal mark char.
+     * Default: `.`
+     */
+    decimalMark?: string;
+};
+declare function decimalize(value: Amount, options?: FormattingOptions | number): string;
+declare function percent(value: bigint, percentage: bigint, precision?: bigint): bigint;
+declare function sumBy<T>(collection: readonly T[], iteratee: (value: T) => bigint, condition?: (value: T) => boolean): bigint;
+declare function min<T extends bigint | number>(...numbers: T[]): T;
+declare function max<T extends bigint | number>(...numbers: T[]): T;
+
+declare function utxoSum(boxes: MinimalBoxAmounts): BoxSummary;
+declare function utxoSum(boxes: MinimalBoxAmounts, tokenId: TokenId): bigint;
+declare function utxoDiff(minuend: BoxSummary | Box<Amount>[], subtrahend: BoxSummary | Box<Amount>[]): BoxSummary;
+declare function areRegistersDenselyPacked(registers: NonMandatoryRegisters): boolean;
+declare function utxoFilter<T extends AmountType>(utxos: Box<T>[], filterParams: UTxOFilterParams<T>): Box<T>[];
+type UTxOFilterParams<T extends AmountType> = {
+    by?: (utxo: Box<T>) => boolean;
+    max?: {
+        count?: number;
+        aggregatedDistinctTokens?: number;
+    };
+};
+type BoxSummary = {
+    nanoErgs: bigint;
+    tokens: TokenAmount<bigint>[];
+};
+type MinimalBoxAmounts = readonly {
+    value: Amount;
+    assets: TokenAmount<Amount>[];
+}[];
+declare function ensureUTxOBigInt(box: Box<Amount>): Box<bigint>;
+declare function ensureUTxOBigInt(candidate: BoxCandidate<Amount>): BoxCandidate<bigint>;
+
+declare function clearUndefined(value: Record<string, unknown>): Record<string, unknown>;
+declare function ensureDefaults<T extends Partial<R>, R extends object = Required<T>>(options: T | undefined, defaults: R): R & T;
+
+type AssertErrorMessageInput = string | Error | (() => string);
+type Constructable = Function;
+type JSPrimitiveTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+declare function assert(condition: boolean, error: AssertErrorMessageInput): asserts condition;
+declare function assertTypeOf<T>(obj: T, expected: JSPrimitiveTypes): asserts obj;
+declare function assertInstanceOf<T>(obj: T, expected: Constructable): asserts obj;
+declare function isEmpty<T extends object>(obj?: T): obj is undefined;
+declare function isEmpty<T>(array?: T[]): array is undefined;
+declare function some<T extends object>(obj?: T): obj is T;
+declare function some<T>(array?: T[]): array is T[];
+declare function isTruthy<T>(value?: T): value is NonNullable<T>;
+declare function isFalsy<T>(value?: T): value is undefined;
+declare function isUndefined(v: unknown): v is undefined;
+declare function isDefined<T>(v: T | undefined): v is T;
+declare function hasKey(o: unknown, key: PropertyKey): boolean;
+
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+declare function isHex(value?: string): boolean;
+/**
+ * Get hex string size in bytes
+ * @param hex
+ * @returns the byte size if the hex string
+ */
+declare function byteSizeOf(hex: string): number;
+
+type CollectionAddOptions = {
+    index?: number;
+};
+declare abstract class Collection<InternalType, ExternalType> implements Iterable<InternalType> {
+    protected readonly _items: InternalType[];
+    constructor();
+    protected _isIndexOutOfBounds(index: number): boolean;
+    [Symbol.iterator](): Iterator<InternalType>;
+    get length(): number;
+    get isEmpty(): boolean;
+    at(index: number): InternalType;
+    add(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number;
+    abstract remove(item: unknown): number;
+    protected abstract _map(item: ExternalType | InternalType): InternalType;
+    protected _addOne(item: InternalType | ExternalType, options?: CollectionAddOptions): number;
+    protected _addOneOrMore(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number;
+    toArray(): InternalType[];
+    reduce<U>(callbackFn: (accumulator: U, currentValue: InternalType, currentIndex: number, array: InternalType[]) => U, initialValue: U): U;
+}
+
+export { AddressType, Amount, AmountType, AssertErrorMessageInput, Base58String, Box, BoxCandidate, BoxId, BoxSummary, BuildOutputType, Collection, CollectionAddOptions, ContextExtension, DataInput, EIP12UnsignedDataInput, EIP12UnsignedInput, EIP12UnsignedTransaction, ErgoTreeHeaderFlag, ErgoTreeHex, FilterPredicate, HexString, MinimalBoxAmounts, Network, NewToken, NonMandatoryRegisters, OneOrMore, ProverResult, SignedInput, SignedTransaction, SortingDirection, SortingSelector, TokenAmount, TokenId, TokenTargetAmount, TransactionId, UTxOFilterParams, UnsignedInput, UnsignedTransaction, _0n, _10n, _127n, _128n, _1n, _63n, _7n, areEqual, areEqualBy, areRegistersDenselyPacked, assert, assertInstanceOf, assertTypeOf, at, byteSizeOf, chunk, clearUndefined, concatBytes, decimalize, depthOf, endsWith, ensureBigInt, ensureDefaults, ensureUTxOBigInt, ergoTreeHeaderFlags, first, hasDuplicates, hasDuplicatesBy, hasKey, isDefined, isEmpty, isFalsy, isHex, isTruthy, isUndefined, last, max, min, orderBy, percent, some, startsWith, sumBy, undecimalize, uniq, uniqBy, utxoDiff, utxoFilter, utxoSum };