@xo-cash/utils 0.0.3 → 0.0.4-development.16005132483

package/dist/index.mjs

@@ -3,6 +3,528 @@ import { BchVmVersions, XOTemplateBaseTypes, XOTemplateLockingTypes, XOTemplateN
 import { z } from "zod";
 import { FungibleTokenAmount, NFTCommitment, PublicKey, Satoshis, SchnorrSignature, TemplateIdentifier, Timestamp, TokenCategory, TransactionHash } from "@xo-cash/primitives";
 
+//#region source/errors.ts
+/**
+* Error thrown when a waitFor timeout is reached
+*/
+var WaitForTimeoutError = class extends Error {
+	constructor(type) {
+		super(`Timeout waiting for event "${type}"`);
+		this.name = "WaitForTimeoutError";
+	}
+};
+
+//#endregion
+//#region source/event-emitter.ts
+/**
+* A simple event emitter implementation.
+* @template T - The event map type.
+*/
+var EventEmitter = class {
+	/**
+	* The listeners map.
+	* @private
+	*/
+	#listeners = /* @__PURE__ */ new Map();
+	/**
+	* Add a listener for an event.
+	* @param type - The event type.
+	* @param listener - The listener function.
+	* @param debounceMilliseconds - The debounce time in milliseconds.
+	* @returns An off callback that can be called to stop listening for events.
+	*/
+	on(type, listener, debounceMilliseconds = 0) {
+		const { cancel, listener: cancellableListener } = this.cancellable(listener);
+		const wrappedListener = debounceMilliseconds > 0 ? this.debounce(cancellableListener, debounceMilliseconds) : cancellableListener;
+		if (!this.#listeners.has(type)) this.#listeners.set(type, /* @__PURE__ */ new Set());
+		const listenerEntry = {
+			listener,
+			wrappedListener,
+			cancel
+		};
+		this.#listeners.get(type)?.add(listenerEntry);
+		return () => this.off(type, listener);
+	}
+	/**
+	* Add a one-time listener for an event.
+	* @param type - The event type.
+	* @param listener - The listener function.
+	* @param debounceMilliseconds - The debounce time in milliseconds.
+	* @returns An off callback that can be called to stop listening for events.
+	*/
+	once(type, listener, debounceMilliseconds = 0) {
+		const wrappedListener = (detail) => {
+			this.off(type, listener);
+			listener(detail);
+		};
+		const { cancel, listener: cancellableListener } = this.cancellable(wrappedListener);
+		const debouncedListener = debounceMilliseconds > 0 ? this.debounce(cancellableListener, debounceMilliseconds) : cancellableListener;
+		if (!this.#listeners.has(type)) this.#listeners.set(type, /* @__PURE__ */ new Set());
+		const listenerEntry = {
+			listener,
+			wrappedListener: debouncedListener,
+			cancel
+		};
+		this.#listeners.get(type)?.add(listenerEntry);
+		return () => this.off(type, listener);
+	}
+	/**
+	* Remove a listener for an event.
+	* @param type - The event type.
+	* @param listener - The listener function.
+	*/
+	off(type, listener) {
+		const listeners = this.#listeners.get(type);
+		if (!listeners) return;
+		Array.from(listeners).filter((entry) => !listener || entry.listener === listener || entry.wrappedListener === listener).forEach((entry) => {
+			entry.cancel();
+			listeners.delete(entry);
+		});
+		if (!listener || this.#listeners.get(type)?.size === 0) this.#listeners.delete(type);
+	}
+	/**
+	* Emit an event.
+	*
+	* @remarks The caller is responsible for ensuring the payload suits the intended mutability requirements.
+	*          By default, the payload will be mutable, so listeners may mutate the payload, effecting both
+	*          the original object and the other listeners.
+	*          To prevent this, the caller can use the {@link Object.freeze} or {@link deepFreeze} function to freeze the payload.
+	*          This will need to be defined in the EventMap using the built-in {@link Readonly} type or the provided {@link DeeplyReadonly} type.
+	*
+	* @param type - The event type.
+	* @param payload - The event payload.
+	* @returns True if there are listeners for the event, false otherwise.
+	*/
+	emit(type, payload) {
+		const listeners = this.#listeners.get(type);
+		if (!listeners) return false;
+		listeners.forEach((entry) => {
+			try {
+				entry.wrappedListener(payload);
+			} catch (error) {
+				console.error(error);
+			}
+		});
+		return listeners.size > 0;
+	}
+	/**
+	* Remove all listeners.
+	*/
+	removeAllListeners() {
+		for (const [type, listeners] of this.#listeners.entries()) listeners.forEach((entry) => {
+			this.off(type, entry.listener);
+		});
+	}
+	/**
+	* Wait for an event to be emitted that matches the provided predicate function's criteria.
+	* @param type - The event type.
+	* @param predicate - Predicate function to filter for whether the event payload matches the criteria.
+	* @param timeoutMs - The timeout in milliseconds.
+	* @returns The event payload.
+	*/
+	async waitFor(type, predicate, timeoutMs) {
+		return new Promise((resolve, reject) => {
+			let timeoutId;
+			const cleanup = (listener) => {
+				this.off(type, listener);
+				if (timeoutId !== void 0) clearTimeout(timeoutId);
+			};
+			const listener = (payload) => {
+				try {
+					if (!predicate(payload)) return;
+					cleanup(listener);
+					resolve(payload);
+				} catch (error) {
+					cleanup(listener);
+					reject(error);
+				}
+			};
+			if (timeoutMs !== void 0) timeoutId = setTimeout(() => {
+				this.off(type, listener);
+				reject(new WaitForTimeoutError(String(type)));
+			}, timeoutMs);
+			this.on(type, listener);
+		});
+	}
+	/**
+	* Debounce a function.
+	*
+	* @remarks If {@link off} is called on a listener while it is debounced, the timeout is not cleared with clearTimeout.
+	*          Instead, the function is no-oped.
+	*
+	* @param func - The function to debounce.
+	* @param wait - The wait time in milliseconds.
+	* @returns The debounced function.
+	*/
+	debounce(func, wait) {
+		let timeout;
+		return (detail) => {
+			if (timeout !== void 0) clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				func(detail);
+			}, wait);
+		};
+	}
+	/**
+	* Make a function cancellable.
+	* @param func - The function to make cancelable.
+	* @returns The cancellable function with a cancel method.
+	*/
+	cancellable(func) {
+		let cancelled = false;
+		return {
+			cancel: () => cancelled = true,
+			listener: (detail) => {
+				if (cancelled) return;
+				func(detail);
+			}
+		};
+	}
+};
+
+//#endregion
+//#region source/exponential-backoff/errors.ts
+/**
+* Error thrown when the maximum number of retries is hit in an exponential backoff
+*/
+var ExponentialBackoffMaxRetriesHitError = class extends Error {
+	constructor(errors) {
+		super("Exponential backoff: Max retries hit", { cause: errors });
+		this.name = "ExponentialBackoffMaxRetriesHitError";
+	}
+};
+/**
+* Error thrown when the exponential backoff retries are stopped
+*/
+var ExponentialBackoffStoppedRetriesError = class extends Error {
+	constructor(reason) {
+		const reasonError = reason instanceof Error ? reason : /* @__PURE__ */ new Error(`${reason}`);
+		super(`Exponential backoff was aborted: "${reasonError.message}"`, { cause: reasonError });
+		this.name = "ExponentialBackoffStoppedRetriesError";
+	}
+};
+/**
+* Error thrown when an exponential backoff option is too small
+*/
+var ExponentialBackoffNumberTooSmallError = class extends Error {
+	constructor(option, value, min) {
+		super(`Exponential backoff option "${option}" is too small. Must be at least ${min}. Received value: ${value}`);
+		this.name = "ExponentialBackoffNumberTooSmallError";
+	}
+};
+/**
+* Error thrown when an exponential backoff option is out of bounds
+*/
+var ExponentialBackoffNumberOutOfBoundsError = class extends Error {
+	constructor(option, value, min, max) {
+		super(`Exponential backoff option "${option}" is out of bounds. Must be between ${min} and ${max}. Received value: ${value}`);
+		this.name = "ExponentialBackoffNumberOutOfBoundsError";
+	}
+};
+/**
+* Error thrown when an exponential backoff option is an invalid infinite integer
+*/
+var ExponentialBackoffNumberNotFiniteError = class extends Error {
+	constructor(option, value) {
+		super(`Exponential backoff option "${option}" is invalid. Must be a finite number. Received value: ${value}`);
+		this.name = "ExponentialBackoffNumberNotFiniteError";
+	}
+};
+/**
+* Error thrown when an exponential backoff option is not an integer
+*/
+var ExponentialBackoffNonIntegerError = class extends Error {
+	constructor(option, value) {
+		super(`Exponential backoff option "${option}" is invalid. Must be an integer. Received value: ${value}`);
+		this.name = "ExponentialBackoffNonIntegerError";
+	}
+};
+/**
+* Error thrown when an externally aborted exponential backoff is aborted
+* due to the external abort signal that was passed in to the constructor being aborted by an upstream consumer
+*/
+var ExternallyAbortedExponentialBackoffExternalSignalAbortedError = class extends Error {
+	constructor(reason) {
+		const reasonError = reason instanceof Error ? reason : /* @__PURE__ */ new Error(`${reason}`);
+		super(`Externally aborted exponential backoff: "${reasonError.message}"`, { cause: reasonError });
+		this.name = "ExternallyAbortedExponentialBackoffExternalSignalAbortedError";
+	}
+};
+/**
+* Error thrown when an externally aborted exponential backoff is aborted
+* due to the internal abort signal being aborted using the .abort() method
+*/
+var ExternallyAbortedExponentialBackoffInternalSignalAbortedError = class extends Error {
+	constructor(reason) {
+		const reasonError = reason instanceof Error ? reason : /* @__PURE__ */ new Error(`${reason}`);
+		super(`Externally aborted exponential backoff: "${reasonError.message}"`, { cause: reasonError });
+		this.name = "ExternallyAbortedExponentialBackoffInternalSignalAbortedError";
+	}
+};
+
+//#endregion
+//#region source/misc.ts
+/**
+* Validate the value is within the bounds, returning true if it is within the bounds, false otherwise
+*
+* @param value - The value to validate
+* @param min - The minimum value
+* @param max - The maximum value
+*
+* @returns True if the value is within the bounds, false otherwise
+*/
+const isWithinBounds = (value, min, max) => {
+	if (value < min || value > max) return false;
+	return true;
+};
+
+//#endregion
+//#region source/exponential-backoff/exponential-backoff.ts
+/**
+* Exponential backoff is a technique used to retry a function after a delay.
+*
+* The delay increases exponentially with each attempt, up to a maximum delay.
+*
+* The jitter is a random amount of time subtracted from the delay to prevent thundering herd problems.
+*
+* The growth rate is the factor by which the delay increases with each attempt.
+*/
+var ExponentialBackoff = class ExponentialBackoff {
+	#options;
+	/**
+	* Creates a new exponential-backoff instance.
+	*
+	* Unspecified options use the defaults listed below.
+	*
+	* @param options - Exponential-backoff configuration overrides.
+	* @param options.maxDelay - Maximum delay between retries. Default: `10_000` ms.
+	* @param options.maxAttempts - Maximum number of attempts; `0` retries indefinitely. Default: `10`.
+	* @param options.baseDelay - Delay used as the basis for the first retry. Default: `1_000` ms.
+	* @param options.growthRate - Multiplier applied to the delay after each attempt. Default: `2`.
+	* @param options.jitter - Maximum proportional reduction subtracted from each delay (0–1). Default: `0.1`.
+	*
+	* @throws An {@link ExponentialBackoffNumberNotFiniteError} if a provided option is not a finite number
+	* @throws An {@link ExponentialBackoffNumberOutOfBoundsError} if a provided option is out of bounds
+	* @throws An {@link ExponentialBackoffNumberTooSmallError} if a provided option is too small
+	* @throws An {@link ExponentialBackoffNonIntegerError} if a provided option is not an integer
+	*/
+	constructor(options = {}) {
+		this.#options = {
+			maxDelay: 1e4,
+			maxAttempts: 10,
+			baseDelay: 1e3,
+			growthRate: 2,
+			jitter: .1,
+			...options
+		};
+		ExponentialBackoff.validateOptions(this.#options);
+	}
+	/**
+	* Create a new ExponentialBackoff instance
+	*
+	* @param config - The configuration for the exponential backoff
+	*
+	* @throws An {@link ExponentialBackoffNumberNotFiniteError} if a provided option is not a finite number
+	* @throws An {@link ExponentialBackoffNumberOutOfBoundsError} if a provided option is out of bounds
+	* @throws An {@link ExponentialBackoffNumberTooSmallError} if a provided option is too small
+	* @throws An {@link ExponentialBackoffNonIntegerError} if a provided option is not an integer
+	*
+	* @returns The ExponentialBackoff instance
+	*/
+	static from(config) {
+		return new ExponentialBackoff(config);
+	}
+	/**
+	* Run the function with exponential backoff
+	*
+	* @param taskFn - The function to run
+	* @param options - Backoff configuration and options for this run
+	*
+	* @throws An {@link ExponentialBackoffMaxRetriesHitError} with all the errors that were thrown by the task function
+	* @throws An {@link ExponentialBackoffStoppedRetriesError} if the abort signal is activated
+	*
+	* @returns The result of the function
+	*/
+	static run(taskFn, options = {}) {
+		const { onError, signal, ...backoffOptions } = options;
+		return ExponentialBackoff.from(backoffOptions).run(taskFn, {
+			onError,
+			signal
+		});
+	}
+	/**
+	* Validate the options for the exponential backoff
+	*
+	* @param options - The options to validate
+	*
+	* @throws {@link ExponentialBackoffNumberNotFiniteError} if a provided option is not a finite number
+	* @throws {@link ExponentialBackoffNonIntegerError} if a provided option is not an integer
+	* @throws {@link ExponentialBackoffNumberOutOfBoundsError} if a provided option is out of bounds
+	* @throws {@link ExponentialBackoffNumberTooSmallError} if a provided option is too small
+	*/
+	static validateOptions(options) {
+		/** Validate the value is finite, throwing an {@link ExponentialBackoffInvalidInfiniteIntegerError} if the value is infinite */
+		const assertIsFinite = (key, value) => {
+			if (!Number.isFinite(value)) throw new ExponentialBackoffNumberNotFiniteError(key, value);
+		};
+		/** Validate the value is an integer, throwing a {@link ExponentialBackoffNonIntegerError} if it is not an integer */
+		const assertIsInteger = (key, value) => {
+			if (!Number.isInteger(value)) throw new ExponentialBackoffNonIntegerError(key, value);
+		};
+		/** Validate the value is greater than the minimum, throwing a {@link ExponentialBackoffNumberTooSmallError} if it is not */
+		const assertIsHigherThan = (key, value, min) => {
+			if (value < min) throw new ExponentialBackoffNumberTooSmallError(key, value, min);
+		};
+		/** Validate the value is within the bounds, throwing a {@link ExponentialBackoffNumberOutOfBoundsError} if it is not within the bounds */
+		const assertIsWithinBounds = (key, value, min, max) => {
+			if (!isWithinBounds(value, min, max)) throw new ExponentialBackoffNumberOutOfBoundsError(key, value, min, max);
+		};
+		assertIsFinite("maxDelay", options.maxDelay);
+		assertIsHigherThan("maxDelay", options.maxDelay, 0);
+		assertIsFinite("maxAttempts", options.maxAttempts);
+		assertIsInteger("maxAttempts", options.maxAttempts);
+		assertIsHigherThan("maxAttempts", options.maxAttempts, 0);
+		assertIsFinite("baseDelay", options.baseDelay);
+		assertIsHigherThan("baseDelay", options.baseDelay, 0);
+		assertIsFinite("growthRate", options.growthRate);
+		assertIsHigherThan("growthRate", options.growthRate, 0);
+		assertIsFinite("jitter", options.jitter);
+		assertIsWithinBounds("jitter", options.jitter, 0, 1);
+	}
+	/**
+	* Run the function with exponential backoff
+	*
+	* If the function fails but we have not hit the max attempts, the error will be passed to the onError callback
+	* and the function will be retried with an exponential delay
+	*
+	* If every attempt fails, an ExponentialBackoffMaxRetriesHitError will be thrown
+	* with all errors from the task function.
+	*
+	* @param taskFn - The function to run
+	* @param options - Options that control this run
+	*
+	* @throws An {@link ExponentialBackoffMaxRetriesHitError} with all the errors that were thrown by the task function
+	* @throws An {@link ExponentialBackoffStoppedRetriesError} if the abort signal is activated
+	*
+	* @returns The result of the function
+	*/
+	async run(taskFn, options = {}) {
+		const { onError, signal: suppliedSignal } = options;
+		const abortController = new AbortController();
+		const stopRetries = abortController.abort.bind(abortController);
+		const signals = [abortController.signal];
+		if (suppliedSignal !== void 0) signals.push(suppliedSignal);
+		const signal = AbortSignal.any(signals);
+		if (signal.aborted) throw new ExponentialBackoffStoppedRetriesError(signal.reason);
+		const errors = [];
+		let attempt = 0;
+		const unlimitedAttempts = this.#options.maxAttempts === 0;
+		while (true) {
+			try {
+				return await taskFn({ stopRetries });
+			} catch (error) {
+				const errorInstance = error instanceof Error ? error : /* @__PURE__ */ new Error(`${error}`);
+				onError?.(errorInstance);
+				if (!unlimitedAttempts) errors.push(errorInstance);
+			}
+			if (signal.aborted) throw new ExponentialBackoffStoppedRetriesError(signal.reason);
+			const nextAttemptExceedsMaxAttempts = attempt + 1 >= this.#options.maxAttempts;
+			if (!unlimitedAttempts && nextAttemptExceedsMaxAttempts) break;
+			const delay = this.#calculateDelay(this.#options, attempt);
+			await new Promise((resolve, reject) => {
+				let timeout;
+				const abortHandler = () => {
+					clearTimeout(timeout);
+					reject(new ExponentialBackoffStoppedRetriesError(signal.reason));
+				};
+				const timeoutHandler = () => {
+					signal.removeEventListener("abort", abortHandler);
+					resolve(void 0);
+				};
+				timeout = setTimeout(timeoutHandler, delay);
+				signal.addEventListener("abort", abortHandler, { once: true });
+			});
+			attempt++;
+		}
+		throw new ExponentialBackoffMaxRetriesHitError(errors);
+	}
+	/**
+	* Calculate the delay before we should attempt to retry
+	*
+	* @param options - The configuration for the exponential backoff
+	* @param attempt - The current attempt number
+	* @returns The time in milliseconds before another attempt should be made
+	*/
+	#calculateDelay(options, attempt) {
+		const power = options.growthRate ** attempt;
+		const rawDelay = options.baseDelay * power;
+		const cappedDelay = Math.min(rawDelay, options.maxDelay);
+		return cappedDelay - Math.random() * options.jitter * cappedDelay;
+	}
+};
+
+//#endregion
+//#region source/exponential-backoff/exponential-backoff-externally-aborted.ts
+/**
+* An exponential backoff that can be stopped by calling `.abort()` or by passing an
+* `abortSignal` to the constructor.
+*
+* @remarks One instance can run many tasks. Aborting it stops retries for every run.
+*/
+var ExponentialBackoffExternallyAbortable = class {
+	#abortController = new AbortController();
+	#exponentialBackoff;
+	constructor(options = {}) {
+		const { abortSignal, ...backoffOptions } = options;
+		this.#exponentialBackoff = new ExponentialBackoff(backoffOptions);
+		abortSignal?.addEventListener("abort", () => {
+			this.#abortController.abort(new ExternallyAbortedExponentialBackoffExternalSignalAbortedError(abortSignal.reason));
+		}, {
+			once: true,
+			signal: this.#abortController.signal
+		});
+		if (abortSignal?.aborted) this.#abortController.abort(new ExternallyAbortedExponentialBackoffExternalSignalAbortedError(abortSignal.reason));
+	}
+	/**
+	* Run the function with exponential backoff
+	*
+	* If the function fails but we have not hit the max attempts, the error will be passed to the onError callback
+	* and the function will be retried with an exponential delay
+	*
+	* If every attempt fails, an ExponentialBackoffMaxRetriesHitError will be thrown
+	* with all errors from the task function.
+	*
+	* @param taskFn - The function to run
+	* @param options - Options that control this run
+	*
+	* @throws An {@link ExponentialBackoffMaxRetriesHitError} with all the errors that were thrown by the task function
+	* @throws An {@link ExponentialBackoffStoppedRetriesError} if the abort signal is activated
+	* @throws An {@link ExternallyAbortedExponentialBackoffExternalSignalAbortedError}
+	*         if the abort signal that was provided during construction is activated
+	* @throws An {@link ExternallyAbortedExponentialBackoffInternalSignalAbortedError}
+	*         if {@link ExponentialBackoffExternallyAbortable.abort} is called on this class
+	*
+	* @returns The result of the function
+	*/
+	run(taskFn, options = {}) {
+		let signal = this.#abortController.signal;
+		if (options.signal !== void 0) signal = AbortSignal.any([signal, options.signal]);
+		return this.#exponentialBackoff.run(taskFn, {
+			...options,
+			signal
+		});
+	}
+	/**
+	* Stops retries for all current and future runs.
+	*
+	* @param reason - The reason for stopping retries
+	*/
+	abort(reason) {
+		this.#abortController.abort(new ExternallyAbortedExponentialBackoffInternalSignalAbortedError(reason));
+	}
+};
+
+//#endregion
 //#region source/extended-json.ts
 /**
 * Matches a bigint encoded in Extended JSON format: `<bigint: 123n>`.
@@ -1535,5 +2057,5 @@ const compileCashAssemblyString = (parameters) => {
 };
 
 //#endregion
-export { AsyncPushIterator, CASHASSEMBLY_EVALUATION_PATTERN, CASHASSEMBLY_EXPRESSION_PATTERN, CASHASSEMBLY_LITERAL_TOKEN_PATTERN, CASHASSEMBLY_VARIABLE_METHOD_REFERENCE_PATTERN, CASHASSEMBLY_VARIABLE_PATTERN, CashAssemblyCompilationFailedError, CashAssemblyNumberNotSafeIntegerError, CashAssemblyPrimitiveMethodMissingError, CashAssemblyPrimitiveVariableMissingError, CashAssemblyRequiredVariableMissingError, CashAssemblyUnsupportedValueTypeError, CashAssemblyVariableTypeMismatchError, CashAssemblyVmNumberDecodeError, SSEEventParser, TemplateInvalidError, TemplateJsonMalformedError, TemplateSerializationFailedError, VIEW_PROPERTIES_DESCRIPTION_MAX_LENGTH, VIEW_PROPERTIES_ICON_MAX_LENGTH, VIEW_PROPERTIES_NAME_MAX_LENGTH, bchVmVersionSchema, buildErrorDescription, compileCashAssemblyEvaluations, compileCashAssemblyString, convertValueToBytes, decodeCompiledCashAssemblyEvaluation, extendedJsonReplacer, extendedJsonReviver, extractCashAssemblyEvaluations, extractVariablesFromEvaluations, fromExtendedJson, generateCashAssemblyBytecode, generateTemplateIdentifier, isCashAssemblyExpression, parseTemplate, resolvePrimitiveMethodBytes, satoshisSchema, scriptToScriptHash, serializeTemplate, toExtendedJson, uint8ArraySchema, xoTemplateActionIntentSchema, xoTemplateActionRequirementsSchema, xoTemplateActionRoleRequirementsSchema, xoTemplateActionRoleSchema, xoTemplateActionSchema, xoTemplateAssetAmountsSchema, xoTemplateBaseTypeSchema, xoTemplateConstantSchema, xoTemplateDataSchema, xoTemplateDefaultsSchema, xoTemplateIconSchema, xoTemplateImportDefaultValueSchema, xoTemplateInputSchema, xoTemplateIntentSchema, xoTemplateLockingScriptIntentSchema, xoTemplateLockingScriptRoleSchema, xoTemplateLockingScriptSchema, xoTemplateLockingTypeSchema, xoTemplateNftCapabilitySchema, xoTemplateNonFungibleTokenDetailsSchema, xoTemplateOutputIntentSchema, xoTemplateOutputSchema, xoTemplatePrimitiveTypeSchema, xoTemplateResourceSchema, xoTemplateRoleSlotSchema, xoTemplateRoleSlotsRequirementsSchema, xoTemplateSchema, xoTemplateStateSchema, xoTemplateTokenSchema, xoTemplateTransactionInputSchema, xoTemplateTransactionOutputSchema, xoTemplateTransactionRoleDataSchema, xoTemplateTransactionSchema, xoTemplateVariableSchema, xoTemplateViewPropertiesSchema };
+export { AsyncPushIterator, CASHASSEMBLY_EVALUATION_PATTERN, CASHASSEMBLY_EXPRESSION_PATTERN, CASHASSEMBLY_LITERAL_TOKEN_PATTERN, CASHASSEMBLY_VARIABLE_METHOD_REFERENCE_PATTERN, CASHASSEMBLY_VARIABLE_PATTERN, CashAssemblyCompilationFailedError, CashAssemblyNumberNotSafeIntegerError, CashAssemblyPrimitiveMethodMissingError, CashAssemblyPrimitiveVariableMissingError, CashAssemblyRequiredVariableMissingError, CashAssemblyUnsupportedValueTypeError, CashAssemblyVariableTypeMismatchError, CashAssemblyVmNumberDecodeError, EventEmitter, ExponentialBackoff, ExponentialBackoffExternallyAbortable, ExponentialBackoffMaxRetriesHitError, ExponentialBackoffNonIntegerError, ExponentialBackoffNumberNotFiniteError, ExponentialBackoffNumberOutOfBoundsError, ExponentialBackoffNumberTooSmallError, ExponentialBackoffStoppedRetriesError, ExternallyAbortedExponentialBackoffExternalSignalAbortedError, ExternallyAbortedExponentialBackoffInternalSignalAbortedError, SSEEventParser, TemplateInvalidError, TemplateJsonMalformedError, TemplateSerializationFailedError, VIEW_PROPERTIES_DESCRIPTION_MAX_LENGTH, VIEW_PROPERTIES_ICON_MAX_LENGTH, VIEW_PROPERTIES_NAME_MAX_LENGTH, WaitForTimeoutError, bchVmVersionSchema, buildErrorDescription, compileCashAssemblyEvaluations, compileCashAssemblyString, convertValueToBytes, decodeCompiledCashAssemblyEvaluation, extendedJsonReplacer, extendedJsonReviver, extractCashAssemblyEvaluations, extractVariablesFromEvaluations, fromExtendedJson, generateCashAssemblyBytecode, generateTemplateIdentifier, isCashAssemblyExpression, parseTemplate, resolvePrimitiveMethodBytes, satoshisSchema, scriptToScriptHash, serializeTemplate, toExtendedJson, uint8ArraySchema, xoTemplateActionIntentSchema, xoTemplateActionRequirementsSchema, xoTemplateActionRoleRequirementsSchema, xoTemplateActionRoleSchema, xoTemplateActionSchema, xoTemplateAssetAmountsSchema, xoTemplateBaseTypeSchema, xoTemplateConstantSchema, xoTemplateDataSchema, xoTemplateDefaultsSchema, xoTemplateIconSchema, xoTemplateImportDefaultValueSchema, xoTemplateInputSchema, xoTemplateIntentSchema, xoTemplateLockingScriptIntentSchema, xoTemplateLockingScriptRoleSchema, xoTemplateLockingScriptSchema, xoTemplateLockingTypeSchema, xoTemplateNftCapabilitySchema, xoTemplateNonFungibleTokenDetailsSchema, xoTemplateOutputIntentSchema, xoTemplateOutputSchema, xoTemplatePrimitiveTypeSchema, xoTemplateResourceSchema, xoTemplateRoleSlotSchema, xoTemplateRoleSlotsRequirementsSchema, xoTemplateSchema, xoTemplateStateSchema, xoTemplateTokenSchema, xoTemplateTransactionInputSchema, xoTemplateTransactionOutputSchema, xoTemplateTransactionRoleDataSchema, xoTemplateTransactionSchema, xoTemplateVariableSchema, xoTemplateViewPropertiesSchema };
 //# sourceMappingURL=index.mjs.map