@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/cjs/worker/messageBus.js

@@ -1,473 +0,0 @@
-"use strict";
-/// <reference lib="webworker" />
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageBus = void 0;
-const service_worker_manager_1 = require("./browser/service-worker-manager");
-const ark_1 = require("../providers/ark");
-const delegator_1 = require("../providers/delegator");
-const identity_1 = require("../identity");
-const wallet_1 = require("../wallet/wallet");
-const errors_1 = require("./errors");
-/**
- * Grace period after a handler times out during which late handler
- * completion is still delivered to the client. Once this expires,
- * the bus sends an "Operation abandoned" error so the message id
- * never goes silent indefinitely.
- */
-const LATE_DELIVERY_GRACE_MS = 5 * 60000;
-class MessageBus {
-    /** Create the service-worker message bus with repositories and handler configuration. */
-    constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, messageTimeoutMs = 30000, messageTimeoutOverrides = {}, debug = false, buildServices, }) {
-        this.walletRepository = walletRepository;
-        this.contractRepository = contractRepository;
-        this.lateDeliveries = new Set();
-        this.running = false;
-        this.tickTimeout = null;
-        this.tickInProgress = false;
-        this.debug = false;
-        this.initialized = false;
-        this.boundOnMessage = this.onMessage.bind(this);
-        this.handlers = new Map(messageHandlers.map((u) => [u.messageTag, u]));
-        this.tickIntervalMs = tickIntervalMs;
-        this.messageTimeoutMs = messageTimeoutMs;
-        this.constructorTimeoutOverrides = { ...messageTimeoutOverrides };
-        this.messageTimeoutOverrides = { ...this.constructorTimeoutOverrides };
-        this.debug = debug;
-        this.buildServicesFn = buildServices ?? this.buildServices.bind(this);
-    }
-    /** Start the message bus and attach service-worker event listeners. */
-    async start() {
-        if (this.running)
-            return;
-        this.running = true;
-        if (this.debug)
-            console.log("MessageBus starting");
-        // Hook message routing
-        self.addEventListener("message", this.boundOnMessage);
-        // activate service worker immediately
-        self.addEventListener("install", () => {
-            self.skipWaiting();
-        });
-        // take control of clients immediately
-        self.addEventListener("activate", () => {
-            self.clients.claim();
-            if (this.initialized) {
-                this.runTick();
-            }
-        });
-    }
-    /** Stop the message bus, cancel ticks, and stop all registered handlers. */
-    async stop() {
-        if (this.debug)
-            console.log("MessageBus stopping");
-        this.running = false;
-        this.tickInProgress = false;
-        this.initialized = false;
-        if (this.tickTimeout !== null) {
-            self.clearTimeout(this.tickTimeout);
-            this.tickTimeout = null;
-        }
-        for (const record of this.lateDeliveries) {
-            record.settled = true;
-            self.clearTimeout(record.deadline);
-        }
-        this.lateDeliveries.clear();
-        self.removeEventListener("message", this.boundOnMessage);
-        await Promise.all(Array.from(this.handlers.values()).map((updater) => updater.stop()));
-    }
-    scheduleNextTick() {
-        if (!this.running)
-            return;
-        if (this.tickTimeout !== null)
-            return;
-        if (this.tickInProgress)
-            return;
-        this.tickTimeout = self.setTimeout(() => this.runTick(), this.tickIntervalMs);
-    }
-    async runTick() {
-        if (!this.running)
-            return;
-        if (this.tickInProgress)
-            return;
-        this.tickInProgress = true;
-        if (this.tickTimeout !== null) {
-            self.clearTimeout(this.tickTimeout);
-            this.tickTimeout = null;
-        }
-        try {
-            const now = Date.now();
-            for (const updater of this.handlers.values()) {
-                try {
-                    const tickLabel = `${updater.messageTag}:tick`;
-                    const response = await this.withTimeout(updater.tick(now), this.resolveTimeoutMs(tickLabel, updater.messageTag), tickLabel);
-                    if (this.debug)
-                        console.log(`[${updater.messageTag}] outgoing tick response:`, response);
-                    if (response && response.length > 0) {
-                        self.clients
-                            .matchAll({
-                            includeUncontrolled: true,
-                            type: "window",
-                        })
-                            .then((clients) => {
-                            for (const message of response) {
-                                clients.forEach((client) => {
-                                    client.postMessage(message);
-                                });
-                            }
-                        });
-                    }
-                }
-                catch (err) {
-                    if (this.debug)
-                        console.error(`[${updater.messageTag}] tick failed`, err);
-                }
-            }
-        }
-        finally {
-            this.tickInProgress = false;
-            this.scheduleNextTick();
-        }
-    }
-    async waitForInit(config) {
-        if (this.initialized) {
-            // Stop existing handlers before re-initializing.
-            // This handles the case where CLEAR was called, which nullifies
-            // handler state (readonlyWallet, etc.) without resetting the
-            // initialized flag. Without this, handlers never get start()
-            // called again and all messages fail with "not initialized".
-            //
-            // Clear the flag first so onMessage() rejects incoming messages
-            // during the stop/start window instead of routing them to
-            // half-reset handlers. Restored to true after start() completes.
-            this.initialized = false;
-            await Promise.all(Array.from(this.handlers.values()).map((h) => h.stop().catch(() => { })));
-        }
-        // Recompute the active timeout map from scratch so a prior init's
-        // keys cannot linger after re-init with a smaller map.
-        this.messageTimeoutOverrides = {
-            ...this.constructorTimeoutOverrides,
-            ...(config.messageTimeouts ?? {}),
-        };
-        const services = await this.buildServicesFn(config);
-        // Start all handlers
-        for (const updater of this.handlers.values()) {
-            if (this.debug)
-                console.log(`Starting updater: ${updater.messageTag}`);
-            await updater.start(services, {
-                walletRepository: this.walletRepository,
-            });
-        }
-        // Kick off scheduler
-        this.scheduleNextTick();
-        this.initialized = true;
-    }
-    async buildServices(config) {
-        const arkProvider = new ark_1.RestArkProvider(config.arkServer.url);
-        const storage = {
-            walletRepository: this.walletRepository,
-            contractRepository: this.contractRepository,
-        };
-        const delegatorProvider = config.delegatorUrl
-            ? new delegator_1.RestDelegatorProvider(config.delegatorUrl)
-            : undefined;
-        const serialized = (0, identity_1.normalizeSerializedIdentity)(config.wallet);
-        if ((0, identity_1.isSigningSerialized)(serialized)) {
-            const identity = (0, identity_1.hydrateIdentity)(serialized);
-            const wallet = await wallet_1.Wallet.create({
-                identity,
-                arkServerUrl: config.arkServer.url,
-                arkServerPublicKey: config.arkServer.publicKey,
-                indexerUrl: config.indexerUrl,
-                esploraUrl: config.esploraUrl,
-                storage,
-                delegatorProvider,
-                settlementConfig: config.settlementConfig,
-                watcherConfig: config.watcherConfig,
-            });
-            return { wallet, arkProvider, readonlyWallet: wallet };
-        }
-        const identity = (0, identity_1.hydrateIdentity)(serialized);
-        const readonlyWallet = await wallet_1.ReadonlyWallet.create({
-            identity,
-            arkServerUrl: config.arkServer.url,
-            arkServerPublicKey: config.arkServer.publicKey,
-            indexerUrl: config.indexerUrl,
-            esploraUrl: config.esploraUrl,
-            storage,
-            delegatorProvider,
-            watcherConfig: config.watcherConfig,
-        });
-        return { readonlyWallet, arkProvider };
-    }
-    onMessage(event) {
-        // Keep the service worker alive while async work is pending.
-        // Without this, the browser may terminate the SW mid-operation,
-        // causing all pending responses to be lost silently.
-        const promise = this.processMessage(event);
-        if (typeof event.waitUntil === "function") {
-            event.waitUntil(promise);
-        }
-        return promise;
-    }
-    async processMessage(event) {
-        const { id, tag, broadcast } = event.data;
-        if (tag === "PING") {
-            this.deliverResponse(event.source, { id, tag: "PONG" }, { id, tag: "PONG" });
-            return;
-        }
-        if (tag === "INITIALIZE_MESSAGE_BUS") {
-            if (this.debug) {
-                console.log("Init Command received");
-            }
-            // Intentionally not wrapped with withTimeout: initialization
-            // performs network calls (buildServices) and handler startup
-            // that may legitimately exceed the message timeout.
-            await this.waitForInit(event.data.config);
-            this.deliverResponse(event.source, { id, tag }, { id, tag });
-            if (this.debug) {
-                console.log("MessageBus initialized");
-            }
-            return;
-        }
-        if (!this.initialized) {
-            if (this.debug)
-                console.warn("Event received before initialization, dropping", event.data);
-            // Send error response so the caller's promise rejects instead of
-            // hanging forever. This happens when the browser kills and restarts
-            // the service worker — the new instance has initialized=false and
-            // messages arrive before INITIALIZE_MESSAGE_BUS is re-sent.
-            const fallbackTag = tag ?? "unknown";
-            this.deliverResponse(event.source, {
-                id,
-                tag: fallbackTag,
-                error: new errors_1.MessageBusNotInitializedError(),
-            }, { id, tag: fallbackTag });
-            return;
-        }
-        if (!id || !tag) {
-            if (this.debug)
-                console.error("Invalid message received, missing required fields:", event.data);
-            const fallbackTag = tag ?? "unknown";
-            this.deliverResponse(event.source, {
-                id,
-                tag: fallbackTag,
-                error: new TypeError("Invalid message received, missing required fields"),
-            }, { id, tag: fallbackTag });
-            return;
-        }
-        const messageType = this.extractMessageType(event.data);
-        if (broadcast) {
-            const updaters = Array.from(this.handlers.values());
-            const entries = updaters.map((updater) => {
-                const label = this.labelFor(messageType, updater.messageTag);
-                const timeoutMs = this.resolveTimeoutMs(messageType, updater.messageTag);
-                const handlerPromise = updater.handleMessage(event.data);
-                const raced = updater.isLongRunning?.(event.data)
-                    ? handlerPromise
-                    : this.withTimeout(handlerPromise, timeoutMs, label);
-                return { updater, handlerPromise, raced };
-            });
-            const results = await Promise.allSettled(entries.map((e) => e.raced));
-            results.forEach((result, index) => {
-                const { updater, handlerPromise } = entries[index];
-                const handlerTag = updater.messageTag;
-                const context = { id, tag: handlerTag, messageType };
-                if (result.status === "fulfilled") {
-                    const response = result.value;
-                    // Always deliver a response so the caller's message id
-                    // never goes silent. Handlers returning null/undefined
-                    // get an explicit ack envelope.
-                    this.deliverResponse(event.source, response ?? { id, tag: handlerTag }, context);
-                }
-                else {
-                    if (this.debug)
-                        console.error(`[${handlerTag}] handleMessage failed`, result.reason);
-                    const error = toError(result.reason);
-                    this.deliverResponse(event.source, { id, tag: handlerTag, error }, context);
-                    // If the error was a timeout, keep watching the
-                    // underlying handler and surface its eventual result
-                    // under the same id.
-                    if (result.reason instanceof errors_1.ServiceWorkerTimeoutError) {
-                        this.attachLateDelivery(handlerPromise, event.source, id, handlerTag, messageType);
-                    }
-                }
-            });
-            return;
-        }
-        const updater = this.handlers.get(tag);
-        if (!updater) {
-            if (this.debug)
-                console.warn(`[${tag}] unknown message tag, ignoring message`);
-            this.deliverResponse(event.source, {
-                id,
-                tag,
-                error: new Error(`Unknown handler tag: ${tag}`),
-            }, { id, tag, messageType });
-            return;
-        }
-        const label = this.labelFor(messageType, tag);
-        const timeoutMs = this.resolveTimeoutMs(messageType, tag);
-        const handlerPromise = updater.handleMessage(event.data);
-        const context = { id, tag, messageType };
-        try {
-            const response = updater.isLongRunning?.(event.data)
-                ? await handlerPromise
-                : await this.withTimeout(handlerPromise, timeoutMs, label);
-            if (this.debug)
-                console.log(`[${tag}] outgoing response:`, response);
-            // Always deliver a response so the caller's message id never
-            // goes silent. A handler returning null/undefined yields an
-            // explicit ack envelope.
-            this.deliverResponse(event.source, response ?? { id, tag }, context);
-        }
-        catch (err) {
-            if (this.debug)
-                console.error(`[${tag}] handleMessage failed`, err);
-            const error = toError(err);
-            this.deliverResponse(event.source, { id, tag, error }, context);
-            // When we abandoned the handler via timeout, keep watching it
-            // so the client's message id eventually gets a final response.
-            if (err instanceof errors_1.ServiceWorkerTimeoutError) {
-                this.attachLateDelivery(handlerPromise, event.source, id, tag, messageType);
-            }
-        }
-    }
-    /**
-     * Race `promise` against a timeout. Note: this does NOT cancel the
-     * underlying work — the original promise keeps running. Call
-     * `attachLateDelivery` after catching the timeout to surface the
-     * eventual result so the message id does not go silent.
-     */
-    withTimeout(promise, timeoutMs, label) {
-        if (timeoutMs <= 0)
-            return promise;
-        return new Promise((resolve, reject) => {
-            const timer = self.setTimeout(() => {
-                reject(new errors_1.ServiceWorkerTimeoutError(`Message handler timed out after ${timeoutMs}ms (${label})`));
-            }, timeoutMs);
-            promise.then((val) => {
-                self.clearTimeout(timer);
-                resolve(val);
-            }, (err) => {
-                self.clearTimeout(timer);
-                reject(err);
-            });
-        });
-    }
-    /**
-     * Extract the declared `type` from a request envelope (e.g. "SETTLE").
-     * Not every envelope carries a type (PING/INIT are special cased
-     * earlier), so this returns undefined for envelopes that lack one.
-     */
-    extractMessageType(data) {
-        const maybeType = data.type;
-        return typeof maybeType === "string" ? maybeType : undefined;
-    }
-    /**
-     * Resolve the timeout for an operation. Message-type overrides take
-     * precedence over handler-tag overrides, with the bus-wide default
-     * (`messageTimeoutMs`) as the final fallback.
-     */
-    resolveTimeoutMs(messageType, handlerTag) {
-        if (messageType &&
-            Object.prototype.hasOwnProperty.call(this.messageTimeoutOverrides, messageType)) {
-            return this.messageTimeoutOverrides[messageType];
-        }
-        if (Object.prototype.hasOwnProperty.call(this.messageTimeoutOverrides, handlerTag)) {
-            return this.messageTimeoutOverrides[handlerTag];
-        }
-        return this.messageTimeoutMs;
-    }
-    /**
-     * Build a human-readable label for timeout errors. Format:
-     * `"<MESSAGE_TYPE> via <HANDLER_TAG>"` when both are known, else the
-     * handler tag alone. Used so timeout errors name the operation the
-     * client actually triggered (e.g. SETTLE) rather than just the
-     * handler that received it (e.g. WALLET_UPDATER).
-     */
-    labelFor(messageType, handlerTag) {
-        return messageType ? `${messageType} via ${handlerTag}` : handlerTag;
-    }
-    /**
-     * Post a response to the originating client. When `source` is null
-     * (client tab closed, detached frame, etc.) the response cannot be
-     * delivered; we log the drop in debug mode so it is not invisible.
-     */
-    deliverResponse(source, response, context) {
-        if (!source) {
-            if (this.debug)
-                console.warn(`[${context.tag}] cannot deliver response: event.source is null`, {
-                    id: context.id,
-                    messageType: context.messageType,
-                });
-            return;
-        }
-        source.postMessage(response);
-    }
-    /**
-     * After a handler times out the client has already received a timeout
-     * error, but the handler keeps running. Attach a follow-up so the
-     * handler's eventual result (or error) is delivered under the same
-     * message id, or — if the handler never completes within
-     * {@link LATE_DELIVERY_GRACE_MS} — an "Operation abandoned" error is
-     * sent so the client's listener (if still attached) does not hang.
-     */
-    attachLateDelivery(handlerPromise, source, id, tag, messageType) {
-        const context = { id, tag, messageType };
-        const record = {
-            settled: false,
-            deadline: self.setTimeout(() => {
-                if (record.settled)
-                    return;
-                record.settled = true;
-                this.lateDeliveries.delete(record);
-                this.deliverResponse(source, {
-                    id,
-                    tag,
-                    error: new Error(`Operation abandoned: handler did not complete within ${LATE_DELIVERY_GRACE_MS}ms after timeout (${this.labelFor(messageType, tag)})`),
-                }, context);
-            }, LATE_DELIVERY_GRACE_MS),
-        };
-        this.lateDeliveries.add(record);
-        handlerPromise.then((response) => {
-            if (record.settled)
-                return;
-            record.settled = true;
-            self.clearTimeout(record.deadline);
-            this.lateDeliveries.delete(record);
-            this.deliverResponse(source, response ?? { id, tag }, context);
-        }, (err) => {
-            if (record.settled)
-                return;
-            record.settled = true;
-            self.clearTimeout(record.deadline);
-            this.lateDeliveries.delete(record);
-            this.deliverResponse(source, { id, tag, error: toError(err) }, context);
-        });
-    }
-    /**
-     * Returns the registered SW for the path.
-     * It uses the functions in `service-worker-manager.ts` module.
-     * @param path
-     * @return the Service Worker
-     * @throws if not running in a browser environment
-     */
-    static async getServiceWorker(path) {
-        return (0, service_worker_manager_1.getActiveServiceWorker)(path);
-    }
-    /**
-     * Set up and register the Service Worker, ensuring it's done once at most.
-     * It uses the functions in `service-worker-manager.ts` module.
-     * @param path
-     * @return the Service Worker
-     * @throws if not running in a browser environment
-     */
-    static async setup(path) {
-        await (0, service_worker_manager_1.setupServiceWorkerOnce)(path);
-        return (0, service_worker_manager_1.getActiveServiceWorker)(path);
-    }
-}
-exports.MessageBus = MessageBus;
-function toError(value) {
-    return value instanceof Error ? value : new Error(String(value));
-}

package/dist/esm/adapters/asyncStorage.js

@@ -1 +0,0 @@
-export { AsyncStorageAdapter } from "../storage/asyncStorage.js";

package/dist/esm/adapters/expo.js

@@ -1,3 +0,0 @@
-// Expo adapter for React Native/Expo environments
-export { ExpoArkProvider } from "../providers/expoArk.js";
-export { ExpoIndexerProvider } from "../providers/expoIndexer.js";

package/dist/esm/adapters/fileSystem.js

@@ -1 +0,0 @@
-export { FileSystemStorageAdapter } from "../storage/fileSystem.js";

package/dist/esm/adapters/indexedDB.js

@@ -1 +0,0 @@
-export { IndexedDBStorageAdapter } from "../storage/indexedDB.js";

package/dist/esm/adapters/localStorage.js

@@ -1 +0,0 @@
-export { LocalStorageAdapter } from "../storage/localStorage.js";

package/dist/esm/arkfee/celenv.js

@@ -1,40 +0,0 @@
-import { Environment } from "@marcbachmann/cel-js";
-/**
- * Variable names used in CEL expressions
- */
-export const AmountVariableName = "amount";
-export const ExpiryVariableName = "expiry";
-export const BirthVariableName = "birth";
-export const WeightVariableName = "weight";
-export const InputTypeVariableName = "inputType";
-export const OutputScriptVariableName = "script";
-const nowFunction = {
-    signature: "now(): double",
-    implementation: () => Math.floor(Date.now() / 1000),
-};
-/**
- * IntentOutputEnv is the CEL environment for output fee calculation
- * Variables: amount, script
- */
-export const IntentOutputEnv = new Environment()
-    .registerVariable(AmountVariableName, "double")
-    .registerVariable(OutputScriptVariableName, "string")
-    .registerFunction(nowFunction.signature, nowFunction.implementation);
-/**
- * IntentOffchainInputEnv is the CEL environment for offchain input fee calculation
- * Variables: amount, expiry, birth, weight, inputType
- */
-export const IntentOffchainInputEnv = new Environment()
-    .registerVariable(AmountVariableName, "double")
-    .registerVariable(ExpiryVariableName, "double")
-    .registerVariable(BirthVariableName, "double")
-    .registerVariable(WeightVariableName, "double")
-    .registerVariable(InputTypeVariableName, "string")
-    .registerFunction(nowFunction.signature, nowFunction.implementation);
-/**
- * IntentOnchainInputEnv is the CEL environment for onchain input fee calculation
- * Variables: amount
- */
-export const IntentOnchainInputEnv = new Environment()
-    .registerVariable(AmountVariableName, "double")
-    .registerFunction(nowFunction.signature, nowFunction.implementation);

package/dist/esm/arkfee/estimator.js

@@ -1,139 +0,0 @@
-import { IntentOffchainInputEnv, IntentOnchainInputEnv, IntentOutputEnv, } from "./celenv.js";
-import { FeeAmount, } from "./types.js";
-/**
- * Estimator evaluates CEL expressions to calculate fees for Arkade intents
- */
-export class Estimator {
-    /**
-     * Creates a new Estimator with the given config
-     * @param config - Configuration containing CEL programs for fee calculation
-     */
-    constructor(config) {
-        this.config = config;
-        this.intentOffchainInput = config.offchainInput
-            ? parseProgram(config.offchainInput, IntentOffchainInputEnv)
-            : undefined;
-        this.intentOnchainInput = config.onchainInput
-            ? parseProgram(config.onchainInput, IntentOnchainInputEnv)
-            : undefined;
-        this.intentOffchainOutput = config.offchainOutput
-            ? parseProgram(config.offchainOutput, IntentOutputEnv)
-            : undefined;
-        this.intentOnchainOutput = config.onchainOutput
-            ? parseProgram(config.onchainOutput, IntentOutputEnv)
-            : undefined;
-    }
-    /**
-     * Evaluates the fee for a given vtxo input
-     * @param input - The offchain input to evaluate
-     * @returns The fee amount for this input
-     */
-    evalOffchainInput(input) {
-        if (!this.intentOffchainInput) {
-            return FeeAmount.ZERO;
-        }
-        const args = inputToArgs(input);
-        return new FeeAmount(this.intentOffchainInput.program(args));
-    }
-    /**
-     * Evaluates the fee for a given boarding input
-     * @param input - The onchain input to evaluate
-     * @returns The fee amount for this input
-     */
-    evalOnchainInput(input) {
-        if (!this.intentOnchainInput) {
-            return FeeAmount.ZERO;
-        }
-        const args = {
-            amount: Number(input.amount),
-        };
-        return new FeeAmount(this.intentOnchainInput.program(args));
-    }
-    /**
-     * Evaluates the fee for a given vtxo output
-     * @param output - The output to evaluate
-     * @returns The fee amount for this output
-     */
-    evalOffchainOutput(output) {
-        if (!this.intentOffchainOutput) {
-            return FeeAmount.ZERO;
-        }
-        const args = outputToArgs(output);
-        return new FeeAmount(this.intentOffchainOutput.program(args));
-    }
-    /**
-     * Evaluates the fee for a given collaborative exit output
-     * @param output - The output to evaluate
-     * @returns The fee amount for this output
-     */
-    evalOnchainOutput(output) {
-        if (!this.intentOnchainOutput) {
-            return FeeAmount.ZERO;
-        }
-        const args = outputToArgs(output);
-        return new FeeAmount(this.intentOnchainOutput.program(args));
-    }
-    /**
-     * Evaluates the fee for a given set of inputs and outputs
-     * @param offchainInputs - Array of offchain inputs to evaluate
-     * @param onchainInputs - Array of onchain inputs to evaluate
-     * @param offchainOutputs - Array of offchain outputs to evaluate
-     * @param onchainOutputs - Array of onchain outputs to evaluate
-     * @returns The total fee amount
-     */
-    eval(offchainInputs, onchainInputs, offchainOutputs, onchainOutputs) {
-        let fee = FeeAmount.ZERO;
-        for (const input of offchainInputs) {
-            fee = fee.add(this.evalOffchainInput(input));
-        }
-        for (const input of onchainInputs) {
-            fee = fee.add(this.evalOnchainInput(input));
-        }
-        for (const output of offchainOutputs) {
-            fee = fee.add(this.evalOffchainOutput(output));
-        }
-        for (const output of onchainOutputs) {
-            fee = fee.add(this.evalOnchainOutput(output));
-        }
-        return fee;
-    }
-}
-function inputToArgs(input) {
-    const args = {
-        amount: Number(input.amount),
-        inputType: input.type,
-        weight: input.weight,
-    };
-    if (input.expiry) {
-        args.expiry = Math.floor(input.expiry.getTime() / 1000);
-    }
-    if (input.birth) {
-        args.birth = Math.floor(input.birth.getTime() / 1000);
-    }
-    return args;
-}
-function outputToArgs(output) {
-    return {
-        amount: Number(output.amount),
-        script: output.script,
-    };
-}
-/**
- * Parses a CEL program and validates its return type
- * @param text - The CEL program text to parse
- * @param env - The CEL environment to use
- * @returns parsed and validated program
- */
-function parseProgram(text, env) {
-    const program = env.parse(text);
-    // Type check the program
-    const checkResult = program.check();
-    if (!checkResult.valid) {
-        throw new Error(`type check failed: ${checkResult.error?.message ?? "unknown error"}`);
-    }
-    // Verify return type is double
-    if (checkResult.type !== "double") {
-        throw new Error(`expected return type double, got ${checkResult.type}`);
-    }
-    return { program, text };
-}

package/dist/esm/arkfee/index.js

@@ -1 +0,0 @@
-export { Estimator } from "./estimator.js";