@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/esm/providers/onchain.js

@@ -1,258 +0,0 @@
-/**
- * The default base URLs for esplora API providers.
- *
- * Mainnet, mutinynet, and signet point at Ark Labs–operated
- * mempool deployments (mempool.space-compatible esplora API).
- * Testnet falls back to the public mempool.space deployment
- * because Ark doesn't host it. Regtest assumes a local nigiri
- * stack on the standard port.
- */
-export const ESPLORA_URL = {
-    bitcoin: "https://mempool.arkade.sh/api",
-    testnet: "https://mempool.space/testnet/api",
-    signet: "https://mempool.signet.arkade.sh/api",
-    mutinynet: "https://mempool.mutinynet.arkade.sh/api",
-    regtest: "http://localhost:3000",
-};
-/**
- * Implementation of the onchain provider interface for esplora REST API.
- *
- * @see https://mempool.space/docs/api/rest
- * @example
- * ```typescript
- * const provider = new EsploraProvider("https://mempool.space/api");
- * const outputs = await provider.getCoins("bcrt1q679zsd45msawvr7782r0twvmukns3drlstjt77");
- * ```
- */
-export class EsploraProvider {
-    constructor(baseUrl, opts) {
-        this.baseUrl = baseUrl;
-        this.pollingInterval = opts?.pollingInterval ?? 15000;
-        this.forcePolling = opts?.forcePolling ?? false;
-    }
-    async getCoins(address) {
-        const response = await fetch(`${this.baseUrl}/address/${address}/utxo`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch UTXOs: ${response.statusText}`);
-        }
-        return response.json();
-    }
-    async getFeeRate() {
-        const response = await fetch(`${this.baseUrl}/fee-estimates`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch fee rate: ${response.statusText}`);
-        }
-        const fees = (await response.json());
-        return fees["1"] ?? undefined;
-    }
-    async broadcastTransaction(...txs) {
-        switch (txs.length) {
-            case 1:
-                return this.broadcastTx(txs[0]);
-            case 2:
-                return this.broadcastPackage(txs[0], txs[1]);
-            default:
-                throw new Error("Only 1 or 1C1P package can be broadcast");
-        }
-    }
-    async getTxOutspends(txid) {
-        const response = await fetch(`${this.baseUrl}/tx/${txid}/outspends`);
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Failed to get transaction outspends: ${error}`);
-        }
-        return response.json();
-    }
-    async getTransactions(address) {
-        const response = await fetch(`${this.baseUrl}/address/${address}/txs`);
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Failed to get transactions: ${error}`);
-        }
-        return response.json();
-    }
-    async getTxStatus(txid) {
-        // make sure tx exists in mempool or in block
-        const txresponse = await fetch(`${this.baseUrl}/tx/${txid}`);
-        if (!txresponse.ok) {
-            throw new Error(txresponse.statusText);
-        }
-        const tx = await txresponse.json();
-        if (!tx.status.confirmed) {
-            return { confirmed: false };
-        }
-        const response = await fetch(`${this.baseUrl}/tx/${txid}/status`);
-        if (!response.ok) {
-            throw new Error(`Failed to get transaction status: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (!data.confirmed) {
-            return { confirmed: false };
-        }
-        return {
-            confirmed: data.confirmed,
-            blockTime: data.block_time,
-            blockHeight: data.block_height,
-        };
-    }
-    async watchAddresses(addresses, callback) {
-        let intervalId = null;
-        const wsUrl = this.baseUrl.replace(/^http(s)?:/, "ws$1:") + "/v1/ws";
-        const poll = async () => {
-            const getAllTxs = async () => {
-                const txArrays = await Promise.all(addresses.map((address) => this.getTransactions(address)));
-                return txArrays.flat();
-            };
-            // initial fetch to get existing transactions
-            const initialTxs = await getAllTxs();
-            // we use block_time in key to also notify when a transaction is confirmed
-            const txKey = (tx) => `${tx.txid}_${tx.status.block_time}`;
-            // create a set of existing transactions to avoid duplicates
-            const existingTxs = new Set(initialTxs.map(txKey));
-            // polling for new transactions
-            intervalId = setInterval(async () => {
-                try {
-                    // get current transactions
-                    // we will compare with initialTxs to find new ones
-                    const currentTxs = await getAllTxs();
-                    // filter out transactions that are already in initialTxs
-                    const newTxs = currentTxs.filter((tx) => !existingTxs.has(txKey(tx)));
-                    if (newTxs.length > 0) {
-                        // Update the tracking set instead of growing the array
-                        newTxs.forEach((tx) => existingTxs.add(txKey(tx)));
-                        callback(newTxs);
-                    }
-                }
-                catch (error) {
-                    console.error("Error in polling mechanism:", error);
-                }
-            }, this.pollingInterval);
-        };
-        let ws = null;
-        const stopFunc = () => {
-            if (ws)
-                ws.close();
-            if (intervalId)
-                clearInterval(intervalId);
-        };
-        if (this.forcePolling) {
-            await poll();
-            return stopFunc;
-        }
-        try {
-            ws = new WebSocket(wsUrl);
-            ws.addEventListener("open", () => {
-                // subscribe to address updates
-                const subscribeMsg = {
-                    "track-addresses": addresses,
-                };
-                ws.send(JSON.stringify(subscribeMsg));
-            });
-            ws.addEventListener("message", (event) => {
-                try {
-                    const newTxs = [];
-                    const message = JSON.parse(event.data.toString());
-                    if (!message["multi-address-transactions"])
-                        return;
-                    const aux = message["multi-address-transactions"];
-                    for (const address in aux) {
-                        for (const type of [
-                            "mempool",
-                            "confirmed",
-                            "removed",
-                        ]) {
-                            if (!aux[address][type])
-                                continue;
-                            newTxs.push(...aux[address][type].filter(isExplorerTransaction));
-                        }
-                    }
-                    // callback with new transactions
-                    if (newTxs.length > 0)
-                        callback(newTxs);
-                }
-                catch (error) {
-                    console.error("Failed to process WebSocket message:", error);
-                }
-            });
-            ws.addEventListener("error", async () => {
-                // if websocket is not available, fallback to polling
-                await poll();
-            });
-        }
-        catch {
-            if (intervalId)
-                clearInterval(intervalId);
-            // if websocket is not available, fallback to polling
-            await poll();
-        }
-        return stopFunc;
-    }
-    async getChainTip() {
-        const tipBlocks = await fetch(`${this.baseUrl}/blocks/tip`);
-        if (!tipBlocks.ok) {
-            throw new Error(`Failed to get chain tip: ${tipBlocks.statusText}`);
-        }
-        const tip = await tipBlocks.json();
-        if (!isValidBlocksTip(tip)) {
-            throw new Error(`Invalid chain tip: ${JSON.stringify(tip)}`);
-        }
-        if (tip.length === 0) {
-            throw new Error("No chain tip found");
-        }
-        const hash = tip[0].id;
-        return {
-            height: tip[0].height,
-            time: tip[0].mediantime,
-            hash,
-        };
-    }
-    async broadcastPackage(parent, child) {
-        const response = await fetch(`${this.baseUrl}/txs/package`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify([parent, child]),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Failed to broadcast package: ${error}`);
-        }
-        return response.json();
-    }
-    async broadcastTx(tx) {
-        const response = await fetch(`${this.baseUrl}/tx`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "text/plain",
-            },
-            body: tx,
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Failed to broadcast transaction: ${error}`);
-        }
-        return response.text();
-    }
-}
-function isValidBlocksTip(tip) {
-    return (Array.isArray(tip) &&
-        tip.every((t) => {
-            return (t &&
-                typeof t === "object" &&
-                typeof t.id === "string" &&
-                t.id.length > 0 &&
-                typeof t.height === "number" &&
-                t.height >= 0 &&
-                typeof t.mediantime === "number" &&
-                t.mediantime > 0);
-        }));
-}
-const isExplorerTransaction = (tx) => {
-    return (typeof tx.txid === "string" &&
-        Array.isArray(tx.vout) &&
-        tx.vout.every((vout) => typeof vout.scriptpubkey_address === "string" &&
-            typeof vout.value === "number") &&
-        typeof tx.status === "object" &&
-        typeof tx.status.confirmed === "boolean");
-};

package/dist/esm/providers/utils.js

@@ -1,117 +0,0 @@
-function createAbortError() {
-    const error = new Error("EventSource closed");
-    error.name = "AbortError";
-    return error;
-}
-/**
- * Creates a close-aware EventSource async iterator.
- *
- * Listeners attach eagerly so events are buffered before the first next() call.
- * close() closes the EventSource, removes listeners, and wakes any pending
- * next() even when the browser does not emit an error from EventSource.close().
- */
-export function eventSourceIterator(eventSource) {
-    const messageQueue = [];
-    const errorQueue = [];
-    let messageResolve = null;
-    let errorResolve = null;
-    let closed = false;
-    let cleanedUp = false;
-    const cleanup = () => {
-        if (cleanedUp)
-            return;
-        cleanedUp = true;
-        eventSource.removeEventListener("message", messageHandler);
-        eventSource.removeEventListener("error", errorHandler);
-    };
-    const close = () => {
-        if (closed)
-            return;
-        closed = true;
-        messageQueue.length = 0;
-        errorQueue.length = 0;
-        eventSource.close();
-        cleanup();
-        if (errorResolve) {
-            const reject = errorResolve;
-            messageResolve = null;
-            errorResolve = null;
-            reject(createAbortError());
-        }
-    };
-    const messageHandler = (event) => {
-        if (closed)
-            return;
-        if (messageResolve) {
-            const resolve = messageResolve;
-            messageResolve = null;
-            errorResolve = null;
-            resolve(event);
-        }
-        else {
-            messageQueue.push(event);
-        }
-    };
-    const errorHandler = () => {
-        if (closed)
-            return;
-        const error = new Error("EventSource error");
-        error.name = "EventSourceError";
-        if (errorResolve) {
-            const reject = errorResolve;
-            messageResolve = null;
-            errorResolve = null;
-            reject(error);
-        }
-        else {
-            errorQueue.push(error);
-        }
-    };
-    // Attach listeners immediately so events are buffered
-    // even before the caller starts iterating
-    eventSource.addEventListener("message", messageHandler);
-    eventSource.addEventListener("error", errorHandler);
-    const gen = (async function* () {
-        try {
-            while (!closed) {
-                // if we have queued messages, yield the first one, remove it from the queue
-                if (messageQueue.length > 0) {
-                    yield messageQueue.shift();
-                    continue;
-                }
-                // if we have queued errors, throw the first one, remove it from the queue
-                if (errorQueue.length > 0) {
-                    const error = errorQueue.shift();
-                    throw error;
-                }
-                // wait for the next message or error
-                const result = await new Promise((resolve, reject) => {
-                    messageResolve = resolve;
-                    errorResolve = reject;
-                }).finally(() => {
-                    messageResolve = null;
-                    errorResolve = null;
-                });
-                if (!closed && result) {
-                    yield result;
-                }
-            }
-        }
-        finally {
-            closed = true;
-            cleanup();
-            eventSource.close();
-        }
-    })();
-    const origReturn = gen.return.bind(gen);
-    const managed = gen;
-    managed.close = close;
-    managed.return = (value) => {
-        close();
-        return origReturn(value);
-    };
-    return managed;
-}
-export function isEventSourceError(error) {
-    return error instanceof Error && error.name === "EventSourceError";
-}

package/dist/esm/repositories/contractRepository.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/repositories/inMemory/contractRepository.js

@@ -1,51 +0,0 @@
-/**
- * In-memory implementation of ContractRepository.
- * Data is ephemeral and scoped to the instance.
- */
-export class InMemoryContractRepository {
-    constructor() {
-        this.version = 1;
-        this.contractData = new Map();
-        this.collections = new Map();
-        this.contractsByScript = new Map();
-    }
-    async clear() {
-        this.contractData.clear();
-        this.collections.clear();
-        this.contractsByScript.clear();
-    }
-    // Contract entity management methods
-    async getContracts(filter) {
-        const contracts = this.contractsByScript.values();
-        if (!filter) {
-            return [...contracts];
-        }
-        const matches = (value, criterion) => {
-            if (criterion === undefined) {
-                return true;
-            }
-            return Array.isArray(criterion)
-                ? criterion.includes(value)
-                : value === criterion;
-        };
-        const results = [];
-        for (const contract of contracts) {
-            if (matches(contract.script, filter.script) &&
-                matches(contract.state, filter.state) &&
-                matches(contract.type, filter.type)) {
-                results.push(contract);
-            }
-        }
-        return results;
-    }
-    async saveContract(contract) {
-        this.contractsByScript.set(contract.script, contract);
-    }
-    async deleteContract(script) {
-        this.contractsByScript.delete(script);
-    }
-    async [Symbol.asyncDispose]() {
-        // nothing to dispose, data is ephemeral and scoped to the instance
-        return;
-    }
-}

package/dist/esm/repositories/inMemory/walletRepository.js

@@ -1,111 +0,0 @@
-import { isVtxoForScript } from "../../contracts/vtxoOwnership.js";
-/**
- * In-memory implementation of WalletRepository.
- * Data is ephemeral and scoped to the instance.
- */
-export class InMemoryWalletRepository {
-    constructor() {
-        this.version = 1;
-        this.vtxosByAddress = new Map();
-        this.utxosByAddress = new Map();
-        this.txsByAddress = new Map();
-        this.walletState = null;
-    }
-    async getVtxos(address) {
-        return this.vtxosByAddress.get(address) ?? [];
-    }
-    async saveVtxos(address, vtxos) {
-        const existing = this.vtxosByAddress.get(address) ?? [];
-        const next = mergeByKey(existing, vtxos, (item) => `${item.txid}:${item.vout}`);
-        this.vtxosByAddress.set(address, next);
-    }
-    async deleteVtxos(address) {
-        this.vtxosByAddress.delete(address);
-    }
-    async getVtxosForScript(script) {
-        const allMatches = [];
-        for (const bucket of this.vtxosByAddress.values()) {
-            for (const vtxo of bucket) {
-                if (isVtxoForScript(vtxo, script)) {
-                    allMatches.push(vtxo);
-                }
-            }
-        }
-        // Dedup by outpoint (last-write-wins across address buckets)
-        return mergeByKey([], allMatches, (item) => `${item.txid}:${item.vout}`);
-    }
-    async saveVtxosForScript(key, vtxos) {
-        if (!key.address) {
-            throw new Error("InMemoryWalletRepository requires an address");
-        }
-        for (const vtxo of vtxos) {
-            if (!isVtxoForScript(vtxo, key.script)) {
-                throw new Error(`VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`);
-            }
-        }
-        return this.saveVtxos(key.address, vtxos);
-    }
-    async deleteVtxosForScript(script) {
-        for (const [address, bucket] of this.vtxosByAddress.entries()) {
-            const next = bucket.filter((v) => !isVtxoForScript(v, script));
-            if (next.length === 0) {
-                this.vtxosByAddress.delete(address);
-            }
-            else {
-                this.vtxosByAddress.set(address, next);
-            }
-        }
-    }
-    async getUtxos(address) {
-        return this.utxosByAddress.get(address) ?? [];
-    }
-    async saveUtxos(address, utxos) {
-        const existing = this.utxosByAddress.get(address) ?? [];
-        const next = mergeByKey(existing, utxos, (item) => `${item.txid}:${item.vout}`);
-        this.utxosByAddress.set(address, next);
-    }
-    async deleteUtxos(address) {
-        this.utxosByAddress.delete(address);
-    }
-    async getTransactionHistory(address) {
-        return this.txsByAddress.get(address) ?? [];
-    }
-    async saveTransactions(address, txs) {
-        const existing = this.txsByAddress.get(address) ?? [];
-        const next = mergeByKey(existing, txs, serializeTxKey);
-        this.txsByAddress.set(address, next);
-    }
-    async deleteTransactions(address) {
-        this.txsByAddress.delete(address);
-    }
-    async getWalletState() {
-        return this.walletState;
-    }
-    async saveWalletState(state) {
-        this.walletState = state;
-    }
-    async clear() {
-        this.vtxosByAddress.clear();
-        this.utxosByAddress.clear();
-        this.txsByAddress.clear();
-        this.walletState = null;
-    }
-    async [Symbol.asyncDispose]() {
-        // nothing to dispose, data is ephemeral and scoped to the instance
-        return;
-    }
-}
-function serializeTxKey(tx) {
-    const key = tx.key;
-    return `${key.boardingTxid}:${key.commitmentTxid}:${key.arkTxid}`;
-}
-function mergeByKey(existing, incoming, toKey) {
-    const next = new Map();
-    existing.forEach((item) => {
-        next.set(toKey(item), item);
-    });
-    incoming.forEach((item) => {
-        next.set(toKey(item), item);
-    });
-    return Array.from(next.values());
-}

package/dist/esm/repositories/index.js

@@ -1,10 +0,0 @@
-export * from "./walletRepository.js";
-export * from "./contractRepository.js";
-export * from "./inMemory/walletRepository.js";
-export * from "./inMemory/contractRepository.js";
-export * from "./indexedDB/contractRepository.js";
-export * from "./indexedDB/walletRepository.js";
-export { MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, } from "./migrations/fromStorageAdapter.js";
-// Deprecated
-export { WalletRepositoryImpl } from "./migrations/walletRepositoryImpl.js";
-export { ContractRepositoryImpl } from "./migrations/contractRepositoryImpl.js";